import { createHash } from "node:crypto"; import { CatalogError, foundationErrors } from "@hivegrid/foundation"; import { publishOutboxEvent, type OutboxPublisherTransaction } from "@hivegrid/db/outbox"; import type { Prisma, TenantUserInvitation } from "@hivegrid/db/prisma-browser"; import { createWorkspaceInvite, generateWorkspaceInviteToken, hashWorkspaceInviteToken, WORKSPACE_INVITE_STATUS_PENDING, type WorkspaceInviteClient, } from "@hivegrid/db/workspace-invites.server"; import { hashWorkspaceOwnerInvitationMailContent, hasValidRedactedWorkspaceOwnerInvitationMailContent, hasValidWorkspaceOwnerInvitationMailContent, normalizeWorkspaceOwnerInvitationMailText, normalizeWorkspaceOwnerInvitationRecipient, readWorkspaceOwnerInvitationMailMetadata, WORKSPACE_OWNER_INVITATION_SECRET_REDACTED_MARKER, workspaceOwnerInvitationHashesEqual, } from "@hivegrid/db/workspace-owner-invite-mail-contract.server"; import { TenantUserType } from "~/application/enums/tenants/TenantUserType"; import EmailTemplates from "~/modules/emails/utils/EmailTemplates"; import { getMailTranslator } from "~/locale/mail-translator.server"; import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server"; import { getAbsoluteUrl } from "~/utils/url.server"; import { TENANT_PENDING_OWNER_REASON } from "./tenantBootstrap.constants"; const OWNER_INVITATION_SCOPE = "tenant-owner-invitation"; export type ReservedOwnerInvitationDraft = { issuanceKey: string; email: string; firstName: string; lastName: string; fromUserId: string | null; token: string; mail: { subject: string; html: string; }; }; export type ReservedOwnerInvitationIssuer = { id: string | null; firstName: string; locale: string | null; }; export async function prepareReservedOwnerInvitation(input: { request: Request; issuanceKey: string; tenantName: string; email: string; firstName?: string | null; lastName?: string | null; issuer: ReservedOwnerInvitationIssuer; }): Promise { const token = generateWorkspaceInviteToken(); const firstName = input.firstName?.trim() ?? ""; const lastName = input.lastName?.trim() ?? ""; const email = normalizeEmail(input.email); const [mailTranslator, appConfiguration] = await Promise.all([getMailTranslator(input.issuer.locale), getAppConfiguration({ request: input.request })]); const rendered = EmailTemplates.USER_INVITATION_EMAIL.parse({ appConfiguration, data: { name: firstName, invite_sender_name: input.issuer.firstName, invite_sender_organization: input.tenantName, action_url: getAbsoluteUrl(input.request, `/invitation/${token}`), }, t: mailTranslator.t, locale: mailTranslator.locale, }); return { issuanceKey: input.issuanceKey, email, firstName, lastName, fromUserId: input.issuer.id, token, mail: { subject: rendered.subject, html: rendered.body }, }; } /** * Creates the single active OWNER invitation and its mail outbox row in the * caller's reservation transaction. The raw token is persisted only as its * invite hash and inside the dedicated mail payload. */ export async function issueReservedOwnerInvitationWithTx( tx: Prisma.TransactionClient, input: ReservedOwnerInvitationDraft & { tenantId: string } ): Promise<{ invitationId: string; replayed: boolean }> { assertIssuanceInput(input); await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtextextended(${`tenant-owner-invitation:${input.tenantId}`}, 0))`; const reservation = await tx.tenant.findUnique({ where: { id: input.tenantId }, select: { active: true, deactivatedReason: true, _count: { select: { users: true } }, }, }); if (!reservation || reservation.active || reservation.deactivatedReason !== TENANT_PENDING_OWNER_REASON || reservation._count.users !== 0) { throw issuanceConflict(input.issuanceKey); } const now = new Date(); const activeInvitations = await tx.tenantUserInvitation.findMany({ where: { tenantId: input.tenantId, type: TenantUserType.OWNER, status: WORKSPACE_INVITE_STATUS_PENDING, pending: true, acceptedAt: null, revokedAt: null, OR: [{ expiresAt: null }, { expiresAt: { gt: now } }], }, orderBy: { id: "asc" }, take: 2, }); if (activeInvitations.length > 1) throw issuanceConflict(input.issuanceKey); const existing = activeInvitations[0]; if (existing) { assertExactInvitation(existing, input); const dispatchKey = ownerInvitationDispatchKey(existing.id); const outbox = await tx.outboxEvent.findUnique({ where: { dispatchKey } }); if (!outbox || !existing.tokenHash || !isExactReservedOwnerInvitationMailReplay(outbox, input, existing.id, existing.tokenHash)) { throw issuanceConflict(input.issuanceKey); } return { invitationId: existing.id, replayed: true }; } const invitation = await createWorkspaceInvite( { tenantId: input.tenantId, email: normalizeEmail(input.email), firstName: input.firstName.trim(), lastName: input.lastName.trim(), type: TenantUserType.OWNER, fromUserId: input.fromUserId, token: input.token, now, }, tx as unknown as WorkspaceInviteClient ); const invitationTokenHash = hashWorkspaceInviteToken(input.token); const mailContentHash = hashWorkspaceOwnerInvitationMailContent({ recipient: input.email, subject: input.mail.subject, html: input.mail.html, rawToken: input.token, invitationTokenHash, }); const outbox = await publishOutboxEvent(tx as OutboxPublisherTransaction, { tenantId: input.tenantId, type: "mail.transactional.send", dispatchKey: ownerInvitationDispatchKey(invitation.id), payload: { tenantId: input.tenantId, to: [normalizeEmail(input.email)], subject: input.mail.subject, html: input.mail.html, priorityOverride: "critical", metadata: { source: "workspace-owner-invitation", alias: "user-invitation", invitationId: invitation.id, invitationTokenHash, issuanceKeyHash: hashOwnerInvitationIssuanceKey(input.issuanceKey), mailContentHash, }, }, }); if (!isExactReservedOwnerInvitationMailReplay(outbox, input, invitation.id, invitationTokenHash)) { throw issuanceConflict(input.issuanceKey); } return { invitationId: invitation.id, replayed: false }; } function assertIssuanceInput(input: ReservedOwnerInvitationDraft & { tenantId: string }): void { const email = normalizeEmail(input.email); if ( !input.tenantId.trim() || !input.issuanceKey.trim() || !email.includes("@") || !/^[A-Za-z0-9_-]{32,512}$/u.test(input.token) || !input.mail.subject.trim() || !input.mail.html.includes(input.token) ) { throw issuanceConflict(input.issuanceKey); } } function assertExactInvitation(invitation: TenantUserInvitation, input: ReservedOwnerInvitationDraft & { tenantId: string }): void { if ( invitation.tenantId !== input.tenantId || invitation.email !== normalizeEmail(input.email) || invitation.firstName !== input.firstName.trim() || invitation.lastName !== input.lastName.trim() || invitation.type !== TenantUserType.OWNER || invitation.status !== WORKSPACE_INVITE_STATUS_PENDING || !invitation.pending || !invitation.tokenHash || !/^[a-f0-9]{64}$/u.test(invitation.tokenHash) || invitation.createdUserId !== null || invitation.fromUserId !== input.fromUserId || invitation.acceptedAt !== null || invitation.revokedAt !== null ) { throw issuanceConflict(input.issuanceKey); } } export function isExactReservedOwnerInvitationMailReplay( outbox: { tenantId: string | null; eventType: string; payload: Prisma.JsonValue; status: string }, input: ReservedOwnerInvitationDraft & { tenantId: string }, invitationId: string, invitationTokenHash: string ): boolean { const payload = asRecord(outbox.payload); const metadata = asRecord(payload?.metadata); const contractMetadata = readWorkspaceOwnerInvitationMailMetadata(payload); let expectedMailContentHash: string; try { expectedMailContentHash = hashWorkspaceOwnerInvitationMailContent({ recipient: input.email, subject: input.mail.subject, html: input.mail.html, rawToken: input.token, invitationTokenHash, }); } catch { return false; } const hasDeliveryBody = metadata?.[WORKSPACE_OWNER_INVITATION_SECRET_REDACTED_MARKER] !== true && hasValidWorkspaceOwnerInvitationMailContent(payload); const hasRedactedDoneBody = outbox.status === "DONE" && metadata?.[WORKSPACE_OWNER_INVITATION_SECRET_REDACTED_MARKER] === true && hasValidRedactedWorkspaceOwnerInvitationMailContent(payload); return ( outbox.tenantId === input.tenantId && outbox.eventType === "mail.transactional.send" && payload?.tenantId === input.tenantId && Array.isArray(payload.to) && payload.to.length === 1 && typeof payload.to[0] === "string" && normalizeWorkspaceOwnerInvitationRecipient(payload.to[0]) === normalizeWorkspaceOwnerInvitationRecipient(input.email) && typeof payload.subject === "string" && normalizeWorkspaceOwnerInvitationMailText(payload.subject) === normalizeWorkspaceOwnerInvitationMailText(input.mail.subject) && (hasDeliveryBody || hasRedactedDoneBody) && metadata?.source === "workspace-owner-invitation" && metadata.alias === "user-invitation" && metadata.invitationId === invitationId && contractMetadata !== null && contractMetadata.invitationId === invitationId && workspaceOwnerInvitationHashesEqual(contractMetadata.issuanceKeyHash, hashOwnerInvitationIssuanceKey(input.issuanceKey)) && workspaceOwnerInvitationHashesEqual(contractMetadata.invitationTokenHash, invitationTokenHash) && workspaceOwnerInvitationHashesEqual(contractMetadata.mailContentHash, expectedMailContentHash) ); } export function hashOwnerInvitationIssuanceKey(issuanceKey: string): string { return createHash("sha256").update(`workspace-owner-invitation:v1:${issuanceKey.trim()}`, "utf8").digest("hex"); } function asRecord(value: unknown): Record | null { return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record) : null; } function normalizeEmail(value: string): string { return value.trim().toLowerCase(); } function ownerInvitationDispatchKey(invitationId: string): string { return `mail:workspace-owner-invite:${invitationId}`; } function issuanceConflict(key: string): CatalogError { return new CatalogError(foundationErrors.idempotencyConflict, { scope: OWNER_INVITATION_SCOPE, key }); }