622 lines
26 KiB
TypeScript
622 lines
26 KiB
TypeScript
import UserValidationUtils from "~/utils/app/UserValidationUtils";
|
|
import { randomUUID } from "node:crypto";
|
|
import { useActionData, useLoaderData } from "react-router";
|
|
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect } from "react-router";
|
|
import { withMetrics } from "~/lib/metrics/ssr";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import { emitUserCreatedHook, getUser, getUserByEmail, register } from "~/utils/db/users.db.server";
|
|
import { queueTransactionalEmail } from "~/modules/emails/services/TransactionalEmailQueue.server";
|
|
import { createTenantUser, getInvitationTenantIdentity, getTenantUserByIds } from "~/utils/db/tenants.db.server";
|
|
import { createUserSession, getUserInfo, setLoggedUser, validateCSRFToken } from "~/utils/session.server";
|
|
import { getAllRoles } from "~/utils/db/permissions/roles.db.server";
|
|
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
|
|
import { getAbsoluteUrl } from "~/utils/url.server";
|
|
import EventsService from "~/modules/events/services/.server/EventsService";
|
|
import { MemberInvitationAcceptedDto } from "~/modules/events/dtos/MemberInvitationAcceptedDto";
|
|
import SetPasswordScreen from "~/modules/users/components/SetPasswordScreen";
|
|
import EmailTemplates from "~/modules/emails/utils/EmailTemplates";
|
|
import { getMailTranslator } from "~/locale/mail-translator.server";
|
|
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
|
|
import { appPath } from "~/utils/app/CanonicalUrlUtils";
|
|
import { loadRequiredWebConfig } from "@hivegrid/config";
|
|
import { absoluteAppRootPath } from "~/utils/app/CrossHostUrls";
|
|
import {
|
|
acceptWorkspaceInvite,
|
|
getWorkspaceInviteByToken,
|
|
type WorkspaceInviteClient,
|
|
WorkspaceInviteDto,
|
|
WorkspaceInviteError,
|
|
} from "@hivegrid/db/workspace-invites.server";
|
|
import { getDbClient } from "@hivegrid/db/client.server";
|
|
import { beginAlternativeLoginMfa, LOGIN_MFA_CHALLENGE_PATH } from "~/services/auth/alternative-login-mfa.server";
|
|
import { runWithRlsContext } from "@hivegrid/db/rls-context.server";
|
|
import { CatalogError } from "@hivegrid/foundation";
|
|
import { createScopedLogger } from "~/utils/logger.server";
|
|
import { toSafeErrorLog } from "~/utils/safeErrorLog.server";
|
|
import { hashPassword } from "~/utils/auth/passwordHasher.server";
|
|
import { TENANT_PENDING_OWNER_REASON } from "~/domain/tenant-bootstrap/tenantBootstrap.constants";
|
|
import { claimReservedTenantWithShkDefaults } from "~/domain/tenant-bootstrap/tenantBootstrapService.server";
|
|
import { checkAuthRateLimit } from "~/services/auth/auth-rate-limit.server";
|
|
|
|
const invitationLogger = createScopedLogger("invitation");
|
|
const INVITATION_RATE_WINDOW_MS = 15 * 60 * 1000;
|
|
const INVITATION_VIEW_RATE_LIMIT = 30;
|
|
const INVITATION_VIEW_IDENTIFIER_LIMIT = 120;
|
|
const INVITATION_VIEW_CLIENT_LIMIT = 300;
|
|
const INVITATION_ACCEPT_RATE_LIMIT = 10;
|
|
const INVITATION_ACCEPT_IDENTIFIER_LIMIT = 30;
|
|
const INVITATION_ACCEPT_CLIENT_LIMIT = 100;
|
|
const MAX_INVITATION_THROTTLE_TOKEN_LENGTH = 256;
|
|
|
|
type LoaderData = {
|
|
title: string;
|
|
invitation: (Pick<WorkspaceInviteDto, "email" | "firstName" | "pending"> & { tenant: { name: string } }) | null;
|
|
existingUser: { id: string } | null;
|
|
appRootPath: string;
|
|
};
|
|
|
|
type ResolvedInvitation = WorkspaceInviteDto & {
|
|
tenant: { id: string; name: string; slug: string; active: boolean; deactivatedReason: string | null };
|
|
};
|
|
|
|
async function getResolvedInvitation(token: string): Promise<ResolvedInvitation | null> {
|
|
const invite = await getWorkspaceInviteByToken({ token });
|
|
if (!invite) return null;
|
|
|
|
return runWithRlsContext({ tenantId: invite.tenantId }, async () => {
|
|
const tenant =
|
|
invite.type === TenantUserType.OWNER
|
|
? await getInvitationTenantIdentity(invite.tenantId, { allowedInactiveReason: TENANT_PENDING_OWNER_REASON })
|
|
: await getInvitationTenantIdentity(invite.tenantId);
|
|
return tenant ? { ...invite, tenant } : null;
|
|
});
|
|
}
|
|
|
|
export const loader = withMetrics("invitation", async ({ request, params }: LoaderFunctionArgs) => {
|
|
const { t } = await getTranslations(request);
|
|
const appRootPath = absoluteAppRootPath(loadRequiredWebConfig().routing);
|
|
const invitationToken = params.id ?? "";
|
|
const rateLimit = await checkInvitationRateLimit({ request, token: invitationToken, action: "invitation-view" });
|
|
if (!rateLimit.allowed) {
|
|
return Response.json(
|
|
{
|
|
title: `${t("account.invitation.title")} | ${process.env.APP_NAME}`,
|
|
invitation: null,
|
|
existingUser: null,
|
|
appRootPath,
|
|
} satisfies LoaderData,
|
|
{ status: 429, headers: invitationRateLimitHeaders(rateLimit.retryAfterSeconds) }
|
|
);
|
|
}
|
|
|
|
if (!isBoundedInvitationToken(invitationToken)) {
|
|
return {
|
|
title: `${t("account.invitation.title")} | ${process.env.APP_NAME}`,
|
|
invitation: null,
|
|
existingUser: null,
|
|
appRootPath,
|
|
} satisfies LoaderData;
|
|
}
|
|
|
|
const candidateInvitation = await getResolvedInvitation(invitationToken);
|
|
const replayUserInfo = candidateInvitation && isAcceptedOwnerClaimCandidate(candidateInvitation) ? await getUserInfo(request) : null;
|
|
const replayableOwnerClaim = Boolean(candidateInvitation && isAcceptedOwnerClaimReplay(candidateInvitation, replayUserInfo?.userId));
|
|
const resolvedInvitation =
|
|
candidateInvitation && ((candidateInvitation.status === "pending" && candidateInvitation.pending) || replayableOwnerClaim) ? candidateInvitation : null;
|
|
const invitation = resolvedInvitation
|
|
? {
|
|
email: resolvedInvitation.email,
|
|
firstName: resolvedInvitation.firstName,
|
|
pending: resolvedInvitation.pending || replayableOwnerClaim,
|
|
tenant: { name: resolvedInvitation.tenant.name },
|
|
}
|
|
: null;
|
|
const existingUserRecord =
|
|
resolvedInvitation && !replayableOwnerClaim
|
|
? await runWithRlsContext({ tenantId: resolvedInvitation.tenantId }, () => getUserByEmail(resolvedInvitation.email))
|
|
: null;
|
|
const data: LoaderData = {
|
|
title: `${t("account.invitation.title")} | ${process.env.APP_NAME}`,
|
|
invitation,
|
|
existingUser: replayableOwnerClaim && replayUserInfo?.userId ? { id: replayUserInfo.userId } : existingUserRecord ? { id: existingUserRecord.id } : null,
|
|
appRootPath,
|
|
};
|
|
return data;
|
|
});
|
|
|
|
export function headers() {
|
|
return {
|
|
"Cache-Control": "no-store",
|
|
"Referrer-Policy": "no-referrer",
|
|
};
|
|
}
|
|
|
|
type ActionData = {
|
|
success?: string;
|
|
error?: string;
|
|
invitationAccepted?: boolean;
|
|
};
|
|
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
|
|
function invitationRateLimitHeaders(retryAfterSeconds: number) {
|
|
return {
|
|
"Cache-Control": "no-store",
|
|
"Referrer-Policy": "no-referrer",
|
|
"Retry-After": String(retryAfterSeconds),
|
|
};
|
|
}
|
|
|
|
function isBoundedInvitationToken(token: string): boolean {
|
|
return token.length > 0 && token.length <= MAX_INVITATION_THROTTLE_TOKEN_LENGTH;
|
|
}
|
|
|
|
async function checkInvitationRateLimit(input: { request: Request; token: string; action: "invitation-view" | "invitation-accept" }) {
|
|
const isView = input.action === "invitation-view";
|
|
return checkAuthRateLimit({
|
|
request: input.request,
|
|
action: input.action,
|
|
identifier: isBoundedInvitationToken(input.token) ? input.token : null,
|
|
limit: isView ? INVITATION_VIEW_RATE_LIMIT : INVITATION_ACCEPT_RATE_LIMIT,
|
|
identifierLimit: isView ? INVITATION_VIEW_IDENTIFIER_LIMIT : INVITATION_ACCEPT_IDENTIFIER_LIMIT,
|
|
clientLimit: isView ? INVITATION_VIEW_CLIENT_LIMIT : INVITATION_ACCEPT_CLIENT_LIMIT,
|
|
windowMs: INVITATION_RATE_WINDOW_MS,
|
|
});
|
|
}
|
|
|
|
function workspaceInviteErrorResponse(error: unknown, t: (key: string) => string) {
|
|
if (error instanceof WorkspaceInviteError) {
|
|
return badRequest({
|
|
error: error.code === "invite_expired" ? t("auth:invitation.errors.expired") : t("auth:invitation.errors.invalid"),
|
|
});
|
|
}
|
|
if (error instanceof CatalogError) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
if (typeof error === "object" && error !== null && "code" in error && error.code === "P2002") {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
throw error;
|
|
}
|
|
export function invitationCreatedUserDashboardPath(tenant: { slug?: string | null } | null) {
|
|
return tenant?.slug ? appPath({ tenantSlug: tenant.slug, path: "dashboard", mode: "host-aware" }) : "/";
|
|
}
|
|
|
|
function getDefaultInvitationRoles(roles: Awaited<ReturnType<typeof getAllRoles>>) {
|
|
return roles.filter((role) => role.assignToNewUsers && role.isDefault);
|
|
}
|
|
|
|
function isPendingOwnerReservation(invitation: ResolvedInvitation): boolean {
|
|
return (
|
|
invitation.pending &&
|
|
invitation.type === TenantUserType.OWNER &&
|
|
!invitation.tenant.active &&
|
|
invitation.tenant.deactivatedReason === TENANT_PENDING_OWNER_REASON
|
|
);
|
|
}
|
|
|
|
function isAcceptedOwnerClaimReplay(invitation: ResolvedInvitation, userId?: string): boolean {
|
|
return Boolean(userId) && invitation.type === TenantUserType.OWNER && invitation.status === "accepted" && invitation.acceptedByUserId === userId;
|
|
}
|
|
|
|
function isAcceptedOwnerClaimCandidate(invitation: ResolvedInvitation): boolean {
|
|
return invitation.type === TenantUserType.OWNER && invitation.status === "accepted" && Boolean(invitation.acceptedByUserId);
|
|
}
|
|
|
|
type InvitationAcceptanceResult = {
|
|
claimedReservedOwner: boolean;
|
|
createdByInvitation: boolean;
|
|
replayed: boolean;
|
|
};
|
|
|
|
async function acceptInvitationForUser(
|
|
{
|
|
invitation,
|
|
token,
|
|
userId,
|
|
createdUserId,
|
|
bindCreatedUserId = false,
|
|
t,
|
|
}: {
|
|
invitation: ResolvedInvitation;
|
|
token: string;
|
|
userId: string;
|
|
createdUserId?: string;
|
|
bindCreatedUserId?: boolean;
|
|
t: (key: string) => string;
|
|
},
|
|
transaction?: WorkspaceInviteClient
|
|
): Promise<InvitationAcceptanceResult> {
|
|
const acceptedReplay = isAcceptedOwnerClaimReplay(invitation, userId);
|
|
if (isPendingOwnerReservation(invitation) || acceptedReplay) {
|
|
const invitationCreatedUserId = createdUserId ?? (invitation.createdUserId === userId ? userId : undefined);
|
|
const result = await claimReservedTenantWithShkDefaults({
|
|
tenantId: invitation.tenantId,
|
|
userId,
|
|
t,
|
|
claim: {
|
|
kind: "workspace-invite",
|
|
inviteId: invitation.id,
|
|
token,
|
|
...(invitationCreatedUserId ? { createdUserId: invitationCreatedUserId } : {}),
|
|
},
|
|
});
|
|
return {
|
|
claimedReservedOwner: true,
|
|
createdByInvitation: invitationCreatedUserId === userId,
|
|
replayed: result.replayed,
|
|
};
|
|
}
|
|
|
|
if (!invitation.pending) {
|
|
throw new WorkspaceInviteError("invite_already_finalized");
|
|
}
|
|
const acceptAndCreateMembership = async (tx: WorkspaceInviteClient) => {
|
|
const existingMembership = await getTenantUserByIds(invitation.tenantId, userId);
|
|
if (existingMembership) {
|
|
throw new WorkspaceInviteError("invite_not_found");
|
|
}
|
|
await acceptWorkspaceInvite(
|
|
{
|
|
tenantId: invitation.tenantId,
|
|
inviteId: invitation.id,
|
|
token,
|
|
acceptedByUserId: userId,
|
|
...(createdUserId ? { createdUserId } : {}),
|
|
...(bindCreatedUserId ? { bindCreatedUserId: true } : {}),
|
|
},
|
|
tx
|
|
);
|
|
const roles = await getAllRoles("app");
|
|
await createTenantUser(
|
|
{
|
|
tenantId: invitation.tenantId,
|
|
userId,
|
|
type: invitation.type,
|
|
},
|
|
getDefaultInvitationRoles(roles)
|
|
);
|
|
return { claimedReservedOwner: false, createdByInvitation: Boolean(createdUserId), replayed: false } satisfies InvitationAcceptanceResult;
|
|
};
|
|
return transaction
|
|
? acceptAndCreateMembership(transaction)
|
|
: getDbClient().$transaction((tx) => acceptAndCreateMembership(tx as unknown as WorkspaceInviteClient));
|
|
}
|
|
|
|
async function queueInvitationWelcomeEmail({
|
|
request,
|
|
invitation,
|
|
user,
|
|
locale,
|
|
idempotencyKey,
|
|
}: {
|
|
request: Request;
|
|
invitation: ResolvedInvitation;
|
|
user: { id: string; locale?: string | null };
|
|
locale: string;
|
|
idempotencyKey?: string;
|
|
}): Promise<void> {
|
|
const welcomeTemplateData = {
|
|
action_url: getAbsoluteUrl(request, "/login"),
|
|
name: invitation.firstName,
|
|
};
|
|
const welcomeMailTranslator = await getMailTranslator(user.locale ?? locale);
|
|
await queueTransactionalEmail({
|
|
to: invitation.email,
|
|
alias: "welcome",
|
|
tenantId: invitation.tenantId,
|
|
userId: user.id,
|
|
...(idempotencyKey ? { idempotencyKey } : {}),
|
|
...EmailTemplates.WELCOME_EMAIL.parse({
|
|
appConfiguration: await getAppConfiguration({ request }),
|
|
data: welcomeTemplateData,
|
|
t: welcomeMailTranslator.t,
|
|
locale: welcomeMailTranslator.locale,
|
|
}),
|
|
data: welcomeTemplateData,
|
|
});
|
|
}
|
|
|
|
async function runInvitationPostCommitStep(input: { operation: string; tenantId: string; userId: string }, step: () => Promise<void>): Promise<void> {
|
|
try {
|
|
await step();
|
|
} catch (error) {
|
|
invitationLogger.error(
|
|
{ ...toSafeErrorLog(error), op: input.operation, tenantId: input.tenantId, userId: input.userId },
|
|
"Invitation acceptance committed, but a post-commit step failed."
|
|
);
|
|
}
|
|
}
|
|
|
|
export const action: ActionFunction = async ({ request, params }) => {
|
|
const { t } = await getTranslations(request);
|
|
const invitationToken = params.id ?? "";
|
|
const rateLimit = await checkInvitationRateLimit({ request, token: invitationToken, action: "invitation-accept" });
|
|
if (!rateLimit.allowed) {
|
|
return Response.json({ error: t("auth:invitation.errors.invalid") }, { status: 429, headers: invitationRateLimitHeaders(rateLimit.retryAfterSeconds) });
|
|
}
|
|
if (!isBoundedInvitationToken(invitationToken)) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
|
|
const form = await request.formData();
|
|
await validateCSRFToken(request, { formData: form });
|
|
const userInfo = await getUserInfo(request);
|
|
const intent = form.get("intent")?.toString() ?? "set-password";
|
|
const useMagicLink = intent === "magic-link";
|
|
const password = form.get("password")?.toString() ?? "";
|
|
const passwordConfirm = form.get("password-confirm")?.toString() ?? "";
|
|
const invitation = await getResolvedInvitation(invitationToken);
|
|
if (!invitation) {
|
|
return badRequest({
|
|
error: t("auth:invitation.errors.invalid"),
|
|
});
|
|
}
|
|
if (invitation.status === "expired") {
|
|
return badRequest({ error: t("auth:invitation.errors.expired") });
|
|
}
|
|
if (isAcceptedOwnerClaimCandidate(invitation) && !isAcceptedOwnerClaimReplay(invitation, userInfo.userId)) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
if (!invitation.pending && !isAcceptedOwnerClaimCandidate(invitation)) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
return runWithRlsContext({ tenantId: invitation.tenantId }, async () => {
|
|
const authenticatedUser = userInfo.userId ? await getUser(userInfo.userId) : null;
|
|
if (userInfo.userId && (!authenticatedUser || authenticatedUser.email.toLowerCase() !== invitation.email.toLowerCase())) {
|
|
return badRequest({ error: t("auth:invitation.errors.signInAsInvitedUser") });
|
|
}
|
|
let existingUser: Awaited<ReturnType<typeof getUserByEmail>> | typeof authenticatedUser;
|
|
try {
|
|
existingUser = authenticatedUser ?? (await getUserByEmail(invitation.email));
|
|
} catch {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
const isReservedOwnerFlow = isPendingOwnerReservation(invitation) || isAcceptedOwnerClaimCandidate(invitation);
|
|
const fromUser = !isReservedOwnerFlow && invitation.fromUserId ? await getUser(invitation.fromUserId) : null;
|
|
if (!existingUser) {
|
|
if (!invitation.pending) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
// Register user. Two paths:
|
|
// - intent="magic-link": accept invitation without password — generate
|
|
// a strong random throwaway hash; the user signs in later via the
|
|
// forgot-password → magic-link flow (#19). Mirrors the spirit of the
|
|
// detail-MD's "magic-link invitation" feature without needing to
|
|
// overlay the magic-link-token infrastructure (which requires a User
|
|
// row to exist for its FK, which is exactly what's missing here).
|
|
// - intent="set-password" (default): traditional confirm+validate path.
|
|
let effectivePassword = password;
|
|
if (useMagicLink) {
|
|
// 32 bytes of crypto-random → 256 bits → far beyond any policy floor;
|
|
// the user never sees it and it's not stored anywhere outside the hash.
|
|
const { createInvitationMagicLinkPassword } = await import("~/services/auth/invitation-password.server");
|
|
effectivePassword = createInvitationMagicLinkPassword();
|
|
} else {
|
|
const passwordError = await UserValidationUtils.validatePasswords({ t, password, passwordConfirm, email: invitation.email });
|
|
if (passwordError) {
|
|
return badRequest({ error: passwordError });
|
|
}
|
|
}
|
|
|
|
let user: Awaited<ReturnType<typeof register>>;
|
|
let committedAcceptance: InvitationAcceptanceResult | null = null;
|
|
if (isPendingOwnerReservation(invitation)) {
|
|
const userId = randomUUID();
|
|
const passwordHash = await hashPassword(effectivePassword);
|
|
try {
|
|
const claimResult = await runWithRlsContext({ userId }, () =>
|
|
claimReservedTenantWithShkDefaults({
|
|
tenantId: invitation.tenantId,
|
|
userId,
|
|
t,
|
|
createUser: {
|
|
id: userId,
|
|
email: invitation.email.trim().toLowerCase(),
|
|
passwordHash,
|
|
firstName: invitation.firstName,
|
|
lastName: invitation.lastName,
|
|
locale: userInfo.lng,
|
|
},
|
|
claim: {
|
|
kind: "workspace-invite",
|
|
inviteId: invitation.id,
|
|
token: invitationToken,
|
|
createdUserId: userId,
|
|
},
|
|
})
|
|
);
|
|
user = {
|
|
id: claimResult.user.id,
|
|
email: claimResult.user.email,
|
|
defaultTenantId: invitation.tenantId,
|
|
locale: claimResult.user.locale ?? undefined,
|
|
createdAt: claimResult.user.createdAt,
|
|
};
|
|
committedAcceptance = { claimedReservedOwner: true, createdByInvitation: true, replayed: claimResult.replayed };
|
|
} catch (error) {
|
|
return workspaceInviteErrorResponse(error, t);
|
|
}
|
|
} else {
|
|
try {
|
|
user = await register({
|
|
email: invitation.email,
|
|
password: effectivePassword,
|
|
firstName: invitation.firstName,
|
|
lastName: invitation.lastName,
|
|
locale: userInfo.lng,
|
|
request,
|
|
transactionalMutation: async (transaction, createdUser) => {
|
|
committedAcceptance = await acceptInvitationForUser(
|
|
{
|
|
invitation,
|
|
token: invitationToken,
|
|
userId: createdUser.id,
|
|
createdUserId: createdUser.id,
|
|
bindCreatedUserId: true,
|
|
t,
|
|
},
|
|
transaction as unknown as WorkspaceInviteClient
|
|
);
|
|
},
|
|
});
|
|
} catch (error) {
|
|
return workspaceInviteErrorResponse(error, t);
|
|
}
|
|
}
|
|
if (!user) {
|
|
return badRequest({ error: t("auth:invitation.errors.createUserFailed") });
|
|
}
|
|
return runWithRlsContext({ userId: user.id }, async () => {
|
|
const acceptance = committedAcceptance;
|
|
if (!acceptance) {
|
|
return badRequest({ error: t("auth:invitation.errors.createUserFailed") });
|
|
}
|
|
if (acceptance.createdByInvitation && acceptance.claimedReservedOwner) {
|
|
await runInvitationPostCommitStep({ operation: "owner-claim.user-hook", tenantId: invitation.tenantId, userId: user.id }, () =>
|
|
emitUserCreatedHook({ ...user, locale: user.locale ?? null, defaultTenantId: invitation.tenantId })
|
|
);
|
|
}
|
|
const eventInput = {
|
|
request,
|
|
event: "member.invitation.accepted" as const,
|
|
tenantId: invitation.tenant.id,
|
|
userId: user.id,
|
|
data: {
|
|
newUser: acceptance.createdByInvitation,
|
|
tenant: { id: invitation.tenantId, name: invitation.tenant.name, slug: invitation.tenant.slug },
|
|
fromUser: acceptance.claimedReservedOwner || !fromUser ? null : { id: fromUser.id, email: fromUser.email },
|
|
user: { id: user.id, email: user.email, firstName: invitation.firstName, lastName: invitation.lastName, type: TenantUserType[invitation.type] },
|
|
invitation: { id: invitation.id },
|
|
} satisfies MemberInvitationAcceptedDto,
|
|
};
|
|
await runInvitationPostCommitStep({ operation: "invitation.accepted-event", tenantId: invitation.tenantId, userId: user.id }, () =>
|
|
EventsService.createIdempotentTenantEvent({
|
|
...eventInput,
|
|
idempotencyKey: `invitation:${invitation.id}:accepted`,
|
|
}).then(() => undefined)
|
|
);
|
|
|
|
const queueWelcome = () =>
|
|
queueInvitationWelcomeEmail({
|
|
request,
|
|
invitation,
|
|
user,
|
|
locale: userInfo.lng,
|
|
idempotencyKey: `invitation:${invitation.id}:welcome`,
|
|
});
|
|
await runInvitationPostCommitStep({ operation: "invitation.welcome-email", tenantId: invitation.tenantId, userId: user.id }, queueWelcome);
|
|
|
|
const dashboardPath = invitationCreatedUserDashboardPath(invitation.tenant);
|
|
const mfa = await beginAlternativeLoginMfa({ request, userId: user.id, redirectTo: dashboardPath, primaryMethod: "invitation" });
|
|
if (mfa.required) {
|
|
return redirect(LOGIN_MFA_CHALLENGE_PATH, { headers: { "Set-Cookie": mfa.setCookie } });
|
|
}
|
|
const userSession = await setLoggedUser(user);
|
|
if (userSession.userId !== user.id || userSession.defaultTenantId !== invitation.tenantId) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
return createUserSession(
|
|
{
|
|
...userInfo,
|
|
userId: user.id,
|
|
lng: user.locale ?? userInfo.lng,
|
|
},
|
|
dashboardPath,
|
|
{ request, rotate: true }
|
|
);
|
|
});
|
|
} else {
|
|
// Existing user
|
|
if (userInfo.userId !== existingUser.id) {
|
|
return badRequest({ error: t("auth:invitation.errors.signInAsInvitedUser") });
|
|
}
|
|
if (!invitation.pending && !isAcceptedOwnerClaimReplay(invitation, existingUser.id)) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
return runWithRlsContext({ userId: existingUser.id }, async () => {
|
|
let acceptance: InvitationAcceptanceResult;
|
|
try {
|
|
acceptance = await acceptInvitationForUser({
|
|
invitation,
|
|
token: invitationToken,
|
|
userId: existingUser.id,
|
|
t,
|
|
});
|
|
} catch (error) {
|
|
return workspaceInviteErrorResponse(error, t);
|
|
}
|
|
if (acceptance.createdByInvitation && acceptance.claimedReservedOwner) {
|
|
await runInvitationPostCommitStep({ operation: "owner-claim.user-hook", tenantId: invitation.tenantId, userId: existingUser.id }, () =>
|
|
emitUserCreatedHook({ ...existingUser, defaultTenantId: invitation.tenantId })
|
|
);
|
|
}
|
|
const eventInput = {
|
|
request,
|
|
event: "member.invitation.accepted" as const,
|
|
tenantId: invitation.tenant.id,
|
|
userId: existingUser.id,
|
|
data: {
|
|
newUser: acceptance.createdByInvitation,
|
|
tenant: { id: invitation.tenantId, name: invitation.tenant.name, slug: invitation.tenant.slug },
|
|
fromUser: acceptance.claimedReservedOwner || !fromUser ? null : { id: fromUser.id, email: fromUser.email },
|
|
user: {
|
|
id: existingUser.id,
|
|
email: existingUser.email,
|
|
firstName: acceptance.claimedReservedOwner ? invitation.firstName : existingUser.firstName,
|
|
lastName: acceptance.claimedReservedOwner ? invitation.lastName : existingUser.lastName,
|
|
type: TenantUserType[invitation.type],
|
|
},
|
|
invitation: { id: invitation.id },
|
|
} satisfies MemberInvitationAcceptedDto,
|
|
};
|
|
await runInvitationPostCommitStep({ operation: "invitation.accepted-event", tenantId: invitation.tenantId, userId: existingUser.id }, () =>
|
|
EventsService.createIdempotentTenantEvent({
|
|
...eventInput,
|
|
idempotencyKey: `invitation:${invitation.id}:accepted`,
|
|
}).then(() => undefined)
|
|
);
|
|
|
|
if (acceptance.createdByInvitation && acceptance.claimedReservedOwner) {
|
|
await runInvitationPostCommitStep({ operation: "owner-claim.welcome-email", tenantId: invitation.tenantId, userId: existingUser.id }, () =>
|
|
queueInvitationWelcomeEmail({
|
|
request,
|
|
invitation,
|
|
user: existingUser,
|
|
locale: userInfo.lng,
|
|
idempotencyKey: `invitation:${invitation.id}:welcome`,
|
|
})
|
|
);
|
|
}
|
|
|
|
if (acceptance.claimedReservedOwner) {
|
|
const dashboardPath = invitationCreatedUserDashboardPath(invitation.tenant);
|
|
const userSession = await setLoggedUser({ ...existingUser, defaultTenantId: invitation.tenantId });
|
|
if (userSession.userId !== existingUser.id || userSession.defaultTenantId !== invitation.tenantId) {
|
|
return badRequest({ error: t("auth:invitation.errors.invalid") });
|
|
}
|
|
return createUserSession(
|
|
{
|
|
...userInfo,
|
|
userId: existingUser.id,
|
|
lng: existingUser.locale ?? userInfo.lng,
|
|
},
|
|
dashboardPath,
|
|
{ request, rotate: true }
|
|
);
|
|
}
|
|
|
|
return { invitationAccepted: true };
|
|
});
|
|
}
|
|
});
|
|
};
|
|
|
|
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
|
|
|
|
export default function InvitationRoute() {
|
|
const data = useLoaderData<LoaderData>();
|
|
const actionData = useActionData<ActionData>();
|
|
// WF-P2 / S01 — Davids "Neues Passwort setzen". Loader/Action unverändert (intent=set-password /
|
|
// intent=magic-link), nur die UI re-skinned auf Davids Auth-Optik.
|
|
return <SetPasswordScreen data={data} actionData={actionData} />;
|
|
}
|