288 lines
11 KiB
TypeScript
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 });
|
|
}
|