Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/domain/tenant-bootstrap/ownerInvitationIssuance.server.test.ts
T

355 lines
14 KiB
TypeScript

// @vitest-environment node
import { describe, expect, it, vi } from "vitest";
import type { Prisma, TenantUserInvitation } from "@hivegrid/db/prisma-browser";
import { hashWorkspaceInviteToken } from "@hivegrid/db/workspace-invites.server";
import { hashWorkspaceOwnerInvitationMailContent } from "@hivegrid/db/workspace-owner-invite-mail-contract.server";
import { hashOwnerInvitationIssuanceKey, issueReservedOwnerInvitationWithTx, type ReservedOwnerInvitationDraft } from "./ownerInvitationIssuance.server";
const TENANT_ID = "tenant_reserved";
const ISSUER_ID = "operator_1";
const TOKEN = "o".repeat(43);
function draft(overrides: Partial<ReservedOwnerInvitationDraft> = {}): ReservedOwnerInvitationDraft {
return {
issuanceKey: "reservation_1",
email: "Owner@Heizkraft.example",
firstName: "Mara",
lastName: "König",
fromUserId: ISSUER_ID,
token: TOKEN,
mail: {
subject: "Einladung",
html: `<a href="https://app.example.test/invitation/${TOKEN}">Einladung annehmen</a>`,
},
...overrides,
};
}
function invitation(overrides: Partial<TenantUserInvitation> = {}): TenantUserInvitation {
const token = "s".repeat(43);
return {
id: "invite_existing",
tenantId: TENANT_ID,
email: "owner@heizkraft.example",
firstName: "Mara",
lastName: "König",
type: 0,
pending: true,
status: "pending",
tokenHash: hashWorkspaceInviteToken(token),
tokenPrefix: token.slice(0, 12),
expiresAt: new Date(Date.now() + 60_000),
acceptedAt: null,
revokedAt: null,
createdUserId: null,
fromUserId: ISSUER_ID,
acceptedByUserId: null,
revokedByUserId: null,
...overrides,
};
}
function mailOutbox(existing: TenantUserInvitation, overrides: Record<string, unknown> = {}) {
const storedToken = "s".repeat(43);
const subject = "Einladung";
const html = `<a href="https://app.example.test/invitation/${storedToken}">Einladung annehmen</a>`;
return {
id: "outbox_existing",
tenantId: TENANT_ID,
eventType: "mail.transactional.send",
payload: {
tenantId: TENANT_ID,
to: [existing.email],
subject,
html,
priorityOverride: "critical",
metadata: {
source: "workspace-owner-invitation",
alias: "user-invitation",
invitationId: existing.id,
invitationTokenHash: existing.tokenHash,
issuanceKeyHash: hashOwnerInvitationIssuanceKey("reservation_1"),
mailContentHash: hashWorkspaceOwnerInvitationMailContent({
recipient: existing.email,
subject,
html,
rawToken: storedToken,
invitationTokenHash: existing.tokenHash!,
}),
},
},
status: "PENDING",
createdAt: new Date(),
processedAt: null,
retries: 0,
lastError: null,
scheduledAt: new Date(),
dispatchKey: `mail:workspace-owner-invite:${existing.id}`,
priority: 0,
lockedUntil: null,
...overrides,
};
}
function buildTx(
activeInvitations: TenantUserInvitation[] = [],
existingOutbox: ReturnType<typeof mailOutbox> | null = null,
reservation = { active: false, deactivatedReason: "pending_owner", _count: { users: 0 } }
) {
const createdOutboxes = new Map<string, ReturnType<typeof mailOutbox>>();
const tx = {
$executeRaw: vi.fn().mockResolvedValue(1),
tenant: {
findUnique: vi.fn().mockResolvedValue(reservation),
},
tenantUserInvitation: {
findMany: vi.fn().mockResolvedValue(activeInvitations),
findFirst: vi.fn().mockResolvedValue(null),
updateMany: vi.fn().mockResolvedValue({ count: 0 }),
create: vi.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) =>
Promise.resolve({
id: "invite_created",
acceptedAt: null,
revokedAt: null,
acceptedByUserId: null,
revokedByUserId: null,
...data,
})
),
},
outboxEvent: {
findUnique: vi.fn().mockImplementation(({ where }: { where: { dispatchKey: string } }) => {
if (existingOutbox?.dispatchKey === where.dispatchKey) return Promise.resolve(existingOutbox);
return Promise.resolve(createdOutboxes.get(where.dispatchKey) ?? null);
}),
create: vi.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) => {
const row = {
id: "outbox_created",
tenantId: data.tenantId as string,
eventType: data.eventType as string,
payload: data.payload as Prisma.JsonValue,
status: "PENDING",
createdAt: new Date(),
processedAt: null,
retries: 0,
lastError: null,
scheduledAt: new Date(),
dispatchKey: data.dispatchKey as string,
priority: 0,
lockedUntil: null,
} as ReturnType<typeof mailOutbox>;
createdOutboxes.set(row.dispatchKey, row);
return Promise.resolve(row);
}),
},
};
return tx;
}
describe("reserved OWNER invitation issuance", () => {
it("creates exactly one OWNER capability and keeps the raw token out of invite columns and metadata", async () => {
const tx = buildTx();
const input = draft();
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...input })).resolves.toEqual({
invitationId: "invite_created",
replayed: false,
});
expect(tx.$executeRaw).toHaveBeenCalledOnce();
expect(tx.tenantUserInvitation.create).toHaveBeenCalledOnce();
const inviteData = tx.tenantUserInvitation.create.mock.calls[0]?.[0].data as Record<string, unknown>;
expect(inviteData).toMatchObject({
tenantId: TENANT_ID,
email: "owner@heizkraft.example",
type: 0,
pending: true,
status: "pending",
tokenHash: hashWorkspaceInviteToken(TOKEN),
tokenPrefix: TOKEN.slice(0, 12),
createdUserId: null,
fromUserId: ISSUER_ID,
});
expect(JSON.stringify(inviteData)).not.toContain(TOKEN);
expect(tx.outboxEvent.create).toHaveBeenCalledOnce();
const outboxData = tx.outboxEvent.create.mock.calls[0]?.[0].data as { payload: Record<string, unknown>; dispatchKey: string };
expect(outboxData.dispatchKey).toBe("mail:workspace-owner-invite:invite_created");
expect(outboxData.payload.html).toContain(TOKEN);
const payloadWithoutHtml = { ...outboxData.payload, html: "[redacted]" };
expect(JSON.stringify(payloadWithoutHtml)).not.toContain(TOKEN);
expect(payloadWithoutHtml.metadata).toMatchObject({
source: "workspace-owner-invitation",
invitationId: "invite_created",
invitationTokenHash: hashWorkspaceInviteToken(TOKEN),
issuanceKeyHash: hashOwnerInvitationIssuanceKey("reservation_1"),
mailContentHash: expect.stringMatching(/^[a-f0-9]{64}$/u),
});
expect(JSON.stringify(payloadWithoutHtml.metadata)).not.toContain("reservation_1");
});
it("replays the exact stored invitation and outbox even when the caller prepared a fresh token", async () => {
const existing = invitation();
const tx = buildTx([existing], mailOutbox(existing));
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...draft() })).resolves.toEqual({
invitationId: existing.id,
replayed: true,
});
expect(hashWorkspaceInviteToken(TOKEN)).not.toBe(existing.tokenHash);
expect(tx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(tx.outboxEvent.create).not.toHaveBeenCalled();
});
it("fails closed when an active OWNER invitation belongs to another issuance key", async () => {
const existing = invitation();
const tx = buildTx([existing], mailOutbox(existing));
await expect(
issueReservedOwnerInvitationWithTx(tx as never, {
tenantId: TENANT_ID,
...draft({ issuanceKey: "reservation_2" }),
})
).rejects.toMatchObject({ code: "foundation.idempotency_conflict" });
expect(tx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(tx.outboxEvent.create).not.toHaveBeenCalled();
});
it("fails closed when a replay changes the OWNER identity", async () => {
const existing = invitation();
const tx = buildTx([existing], mailOutbox(existing));
await expect(
issueReservedOwnerInvitationWithTx(tx as never, {
tenantId: TENANT_ID,
...draft({ email: "other-owner@heizkraft.example" }),
})
).rejects.toMatchObject({ code: "foundation.idempotency_conflict" });
expect(tx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(tx.outboxEvent.create).not.toHaveBeenCalled();
});
it("accepts an exact replay after a DONE mail outbox payload has been safely redacted", async () => {
const existing = invitation();
const outbox = mailOutbox(existing, { status: "DONE", processedAt: new Date() });
const payload = outbox.payload as Record<string, unknown>;
delete payload.html;
payload.metadata = {
...(payload.metadata as Record<string, unknown>),
secretBodyRedacted: true,
};
const tx = buildTx([existing], outbox);
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...draft() })).resolves.toEqual({
invitationId: existing.id,
replayed: true,
});
expect(JSON.stringify(outbox.payload)).not.toContain("stored-token");
expect(tx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(tx.outboxEvent.create).not.toHaveBeenCalled();
});
it("rejects a redaction marker before the mail outbox reaches DONE", async () => {
const existing = invitation();
const outbox = mailOutbox(existing);
const payload = outbox.payload as Record<string, unknown>;
delete payload.html;
payload.metadata = {
...(payload.metadata as Record<string, unknown>),
secretBodyRedacted: true,
};
const tx = buildTx([existing], outbox);
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
});
it("fails closed when the stored mail capability does not match the invitation hash", async () => {
const existing = invitation();
const outbox = mailOutbox(existing);
(outbox.payload.metadata as Record<string, unknown>).invitationTokenHash = hashWorkspaceInviteToken("different-token");
const tx = buildTx([existing], outbox);
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
expect(tx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(tx.outboxEvent.create).not.toHaveBeenCalled();
});
it("fails closed when a pre-redaction mail body or its retained content hash is damaged", async () => {
const existing = invitation();
const damagedBody = mailOutbox(existing);
(damagedBody.payload as Record<string, unknown>).html = `${(damagedBody.payload as Record<string, unknown>).html}<p>corrupted</p>`;
const damagedHash = mailOutbox(existing);
((damagedHash.payload as Record<string, unknown>).metadata as Record<string, unknown>).mailContentHash = "c".repeat(64);
await expect(issueReservedOwnerInvitationWithTx(buildTx([existing], damagedBody) as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
await expect(issueReservedOwnerInvitationWithTx(buildTx([existing], damagedHash) as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
});
it("fails closed on delivery-affecting extras before and after redaction", async () => {
const existing = invitation();
const preRedaction = mailOutbox(existing);
(preRedaction.payload as Record<string, unknown>).bcc = ["attacker@example.test"];
const postRedaction = mailOutbox(existing, { status: "DONE", processedAt: new Date() });
const postPayload = postRedaction.payload as Record<string, unknown>;
delete postPayload.html;
postPayload.headers = [{ name: "x-unexpected", value: "1" }];
postPayload.metadata = { ...(postPayload.metadata as Record<string, unknown>), secretBodyRedacted: true };
await expect(issueReservedOwnerInvitationWithTx(buildTx([existing], preRedaction) as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
await expect(issueReservedOwnerInvitationWithTx(buildTx([existing], postRedaction) as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
});
it("rejects multiple active OWNER capabilities before writing", async () => {
const tx = buildTx([invitation(), invitation({ id: "invite_second" })]);
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
expect(tx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(tx.outboxEvent.create).not.toHaveBeenCalled();
});
it("refuses issuance once the reservation is active or already has a member", async () => {
const activeTx = buildTx([], null, { active: true, deactivatedReason: null, _count: { users: 0 } });
const memberTx = buildTx([], null, { active: false, deactivatedReason: "pending_owner", _count: { users: 1 } });
await expect(issueReservedOwnerInvitationWithTx(activeTx as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
await expect(issueReservedOwnerInvitationWithTx(memberTx as never, { tenantId: TENANT_ID, ...draft() })).rejects.toMatchObject({
code: "foundation.idempotency_conflict",
});
expect(activeTx.tenantUserInvitation.create).not.toHaveBeenCalled();
expect(memberTx.tenantUserInvitation.create).not.toHaveBeenCalled();
});
it("propagates outbox failure so the surrounding reservation transaction can roll back", async () => {
const tx = buildTx();
tx.outboxEvent.create.mockRejectedValueOnce(new Error("outbox unavailable"));
await expect(issueReservedOwnerInvitationWithTx(tx as never, { tenantId: TENANT_ID, ...draft() })).rejects.toThrow("outbox unavailable");
expect(tx.tenantUserInvitation.create).toHaveBeenCalledOnce();
});
});