Files

288 lines
11 KiB
TypeScript

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<ReservedOwnerInvitationDraft> {
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<string, unknown> | null {
return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : 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 });
}