import { beforeEach, describe, expect, it, vi } from "vitest"; import { action, headers, loader } from "./invitation.$id"; import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server"; import { queueTransactionalEmail } from "~/modules/emails/services/TransactionalEmailQueue.server"; import { sendEmail } from "~/modules/emails/services/EmailService"; import EmailTemplates from "~/modules/emails/utils/EmailTemplates"; import { emitUserCreatedHook, getUser, getUserByEmail, register } from "~/utils/db/users.db.server"; import { createTenantUser, getInvitationTenantIdentity, getTenantUserByIds } from "~/utils/db/tenants.db.server"; import { getAllRoles } from "~/utils/db/permissions/roles.db.server"; import { createUserSession, getUserInfo, setLoggedUser, validateCSRFToken } from "~/utils/session.server"; import EventsService from "~/modules/events/services/.server/EventsService"; import { acceptWorkspaceInvite, getWorkspaceInviteByToken, hashWorkspaceInviteToken, type WorkspaceInviteClient, WorkspaceInviteError, } from "@hivegrid/db/workspace-invites.server"; import { getDbClient } from "@hivegrid/db/client.server"; import { loadRequiredWebConfig } from "@hivegrid/config"; import { beginAlternativeLoginMfa } from "~/services/auth/alternative-login-mfa.server"; import { getRlsExecutionContext } from "@hivegrid/db/rls-context.server"; import { claimReservedTenantWithShkDefaults } from "~/domain/tenant-bootstrap/tenantBootstrapService.server"; import { hashPassword } from "~/utils/auth/passwordHasher.server"; import { checkAuthRateLimit } from "~/services/auth/auth-rate-limit.server"; vi.mock("~/utils/db/appConfiguration.db.server", () => ({ getAppConfiguration: vi.fn(), })); vi.mock("~/lib/metrics/ssr", () => ({ withMetrics: (_name: string, handler: unknown) => handler, })); vi.mock("@hivegrid/config", () => ({ loadRequiredWebConfig: vi.fn(() => ({ routing: { adminAppHost: "admin.example.test", apiHost: "api.example.test", appBaseDomain: "example.test", protocol: "https", webAppHost: "app.example.test", }, })), })); vi.mock("~/services/auth/password-policy.server", () => ({ validatePassword: vi.fn(async () => ({ valid: true, errors: [] })), loadPasswordPolicy: vi.fn(() => ({ minLength: 1, requireUpper: false, requireLower: false, requireDigit: false, requireSpecial: false, hibpCheck: false, hibpMaxOccurrences: 0, })), MIN_PASSWORD_LENGTH: 12, })); vi.mock("~/utils/auth/passwordHasher.server", () => ({ hashPassword: vi.fn(), })); vi.mock("~/services/auth/invitation-password.server", () => ({ createInvitationMagicLinkPassword: vi.fn(() => "generated-magic-link-password"), })); vi.mock("~/services/auth/auth-rate-limit.server", () => ({ checkAuthRateLimit: vi.fn(), })); vi.mock("~/modules/emails/services/TransactionalEmailQueue.server", () => ({ queueTransactionalEmail: vi.fn(), })); vi.mock("~/modules/emails/services/EmailService", () => ({ sendEmail: vi.fn(), })); vi.mock("~/modules/emails/utils/EmailTemplates", () => ({ default: { WELCOME_EMAIL: { parse: vi.fn(({ data }) => ({ subject: "Welcome to Example", body: `

Welcome ${data.name} at ${data.action_url}

`, })), }, }, })); vi.mock("~/utils/url.server", () => ({ getAbsoluteUrl: vi.fn((_request: Request, path: string) => `https://example.com${path}`), })); vi.mock("~/utils/logger.server", () => ({ createScopedLogger: vi.fn(() => ({ debug: vi.fn(), error: vi.fn(), info: vi.fn(), warn: vi.fn() })), })); vi.mock("~/utils/safeErrorLog.server", () => ({ toSafeErrorLog: vi.fn(() => ({ err: { name: "Error" } })), })); vi.mock("~/locale/i18next.server", () => ({ enabledLocales: ["de", "en"], getTranslations: vi.fn(async () => ({ t: (key: string) => key })), remixI18Next: { getFixedT: vi.fn(async () => (key: string) => key), getLocale: vi.fn(async () => "en"), }, })); vi.mock("~/components/brand/Logo", () => ({ default: () => null })); vi.mock("~/components/ui/buttons/LoadingButton", () => ({ default: () => null })); vi.mock("~/components/ui/modals/ErrorModal", () => ({ default: () => null })); vi.mock("~/components/ui/banners/SuccessBanner", () => ({ default: () => null })); vi.mock("~/components/ui/button", () => ({ Button: ({ children }: { children: React.ReactNode }) => <>{children} })); vi.mock("~/utils/db/users.db.server", () => ({ emitUserCreatedHook: vi.fn(), getUser: vi.fn(), getUserByEmail: vi.fn(), register: vi.fn(), })); vi.mock("@hivegrid/db/client.server", () => ({ getDbClient: vi.fn(), })); vi.mock("@hivegrid/db/workspace-invites.server", async (importOriginal) => { const actual = await importOriginal(); return { ...actual, acceptWorkspaceInvite: vi.fn(actual.acceptWorkspaceInvite), getWorkspaceInviteByToken: vi.fn(), }; }); vi.mock("~/utils/db/tenants.db.server", () => ({ createTenantUser: vi.fn(), getInvitationTenantIdentity: vi.fn(), getTenantUserByIds: vi.fn(), })); vi.mock("~/domain/tenant-bootstrap/tenantBootstrapService.server", () => ({ claimReservedTenantWithShkDefaults: vi.fn(), TENANT_PENDING_OWNER_REASON: "pending_owner", })); vi.mock("~/utils/db/permissions/roles.db.server", () => ({ getAllRoles: vi.fn(), })); vi.mock("~/utils/session.server", () => ({ createUserSession: vi.fn(), getUserInfo: vi.fn(), setLoggedUser: vi.fn(), validateCSRFToken: vi.fn(), })); vi.mock("~/services/auth/alternative-login-mfa.server", () => ({ beginAlternativeLoginMfa: vi.fn(), LOGIN_MFA_CHALLENGE_PATH: "/login-mfa", })); vi.mock("~/modules/events/services/.server/EventsService", () => ({ default: { create: vi.fn(), createIdempotentTenantEvent: vi.fn(), }, })); const appConfiguration = { app: { name: "Example" } } as Awaited>; const invitation = { id: "invitation_1", email: "invitee@example.com", firstName: "Ada", lastName: "Lovelace", tenantId: "tenant_1", type: 2, fromUserId: "from_user_1", tenant: { id: "tenant_1", name: "Example Co", slug: "example-co" }, }; const workspaceInvite = { id: invitation.id, email: invitation.email, firstName: invitation.firstName, lastName: invitation.lastName, tenantId: invitation.tenantId, type: invitation.type, fromUserId: invitation.fromUserId, pending: true, status: "pending", tokenPrefix: "invite-token".slice(0, 12), createdUserId: null, acceptedByUserId: null, revokedByUserId: null, expiresAt: new Date("2030-01-01T00:00:00.000Z"), acceptedAt: null, revokedAt: null, } as Awaited>; const role = { id: "role_1", assignToNewUsers: true, isDefault: true } as Awaited>[number]; const tenantScopedRole = { id: "role_tenant", assignToNewUsers: true, isDefault: false } as Awaited>[number]; const getAppConfigurationMock = vi.mocked(getAppConfiguration); const queueTransactionalEmailMock = vi.mocked(queueTransactionalEmail); const sendEmailMock = vi.mocked(sendEmail); const welcomeParseMock = vi.mocked(EmailTemplates.WELCOME_EMAIL.parse); const getUserMock = vi.mocked(getUser); const getUserByEmailMock = vi.mocked(getUserByEmail); const registerMock = vi.mocked(register); const emitUserCreatedHookMock = vi.mocked(emitUserCreatedHook); const acceptWorkspaceInviteMock = vi.mocked(acceptWorkspaceInvite); const getWorkspaceInviteByTokenMock = vi.mocked(getWorkspaceInviteByToken); const getDbClientMock = vi.mocked(getDbClient); const createTenantUserMock = vi.mocked(createTenantUser); const getInvitationTenantIdentityMock = vi.mocked(getInvitationTenantIdentity); const getTenantUserByIdsMock = vi.mocked(getTenantUserByIds); const getAllRolesMock = vi.mocked(getAllRoles); const createUserSessionMock = vi.mocked(createUserSession); const getUserInfoMock = vi.mocked(getUserInfo); const setLoggedUserMock = vi.mocked(setLoggedUser); const validateCSRFTokenMock = vi.mocked(validateCSRFToken); const eventsCreateMock = vi.mocked(EventsService.create); const loadRequiredWebConfigMock = vi.mocked(loadRequiredWebConfig); const beginAlternativeLoginMfaMock = vi.mocked(beginAlternativeLoginMfa); const claimReservedTenantWithShkDefaultsMock = vi.mocked(claimReservedTenantWithShkDefaults); const eventsCreateIdempotentMock = vi.mocked(EventsService.createIdempotentTenantEvent); const hashPasswordMock = vi.mocked(hashPassword); const checkAuthRateLimitMock = vi.mocked(checkAuthRateLimit); let eventRlsContexts: Array> = []; let transactionInvite = { ...workspaceInvite!, tokenHash: hashWorkspaceInviteToken("invite-token"), }; let transactionMembership: { tenantId: string; userId: string; status: number } | null = null; let registeredUserIds = new Set(); let transactionTail: Promise = Promise.resolve(); const transactionClient = { tenantUserInvitation: { findFirst: vi.fn(async () => ({ ...transactionInvite })), findMany: vi.fn(async () => [{ ...transactionInvite }]), create: vi.fn(), update: vi.fn(), updateMany: vi.fn(async ({ where, data }: { where: Record; data: Record }) => { if ( transactionInvite.pending !== true || transactionInvite.status !== "pending" || where.createdUserId !== transactionInvite.createdUserId || where.tokenHash !== transactionInvite.tokenHash ) { return { count: 0 }; } transactionInvite = { ...transactionInvite, ...data }; return { count: 1 }; }), }, } as unknown as WorkspaceInviteClient; async function runFakeTransaction(callback: (transaction: WorkspaceInviteClient) => Promise): Promise { const previous = transactionTail; let release!: () => void; transactionTail = new Promise((resolve) => { release = resolve; }); await previous; const inviteBefore = { ...transactionInvite }; const membershipBefore = transactionMembership ? { ...transactionMembership } : null; const registeredUsersBefore = new Set(registeredUserIds); try { return await callback(transactionClient); } catch (error) { transactionInvite = inviteBefore; transactionMembership = membershipBefore; registeredUserIds = registeredUsersBefore; throw error; } finally { release(); } } async function postInvitation(intent = "set-password") { const form = new FormData(); form.set("intent", intent); form.set("password", "password"); form.set("password-confirm", "password"); form.set("csrf", "csrf-token"); return action({ request: new Request("https://example.com/invitation/invite-token", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(form as unknown as Record), }), params: { id: "invite-token" }, context: {}, } as unknown as Parameters[0]); } async function readJson(response: unknown) { expect(response).toBeInstanceOf(Response); return (response as Response).json(); } function configureOwnerInvitation({ status = "pending", acceptedByUserId = null, createdUserId = null, active = false, deactivatedReason = "pending_owner", }: { status?: "pending" | "accepted" | "expired" | "revoked"; acceptedByUserId?: string | null; createdUserId?: string | null; active?: boolean; deactivatedReason?: string | null; } = {}) { getWorkspaceInviteByTokenMock.mockResolvedValue({ ...workspaceInvite!, type: 0, status, pending: status === "pending", acceptedByUserId, createdUserId, acceptedAt: status === "accepted" ? new Date("2026-07-15T11:05:00.000Z") : null, } as Awaited>); getInvitationTenantIdentityMock.mockImplementation(async () => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1" }); return { id: "tenant_1", name: "Example Co", slug: "example-co", active, deactivatedReason }; }); } function configureAuthenticatedExistingUser(userId = "existing_user_1") { const existingUser = { id: userId, email: "invitee@example.com", firstName: "Ada", lastName: "Lovelace", locale: "en", defaultTenantId: null, createdAt: new Date("2026-07-01T10:00:00.000Z"), } as Awaited>; getUserByEmailMock.mockResolvedValue(existingUser); getUserMock.mockImplementation(async (requestedUserId) => requestedUserId === userId ? (existingUser as Awaited>) : ({ id: "from_user_1", email: "owner@example.com" } as Awaited>) ); getUserInfoMock.mockResolvedValue({ userId, lng: "en", lightOrDarkMode: "light" } as Awaited>); return existingUser; } describe("invitation action transactional welcome email", () => { beforeEach(() => { vi.clearAllMocks(); transactionInvite = { ...workspaceInvite!, tokenHash: hashWorkspaceInviteToken("invite-token") }; transactionMembership = null; registeredUserIds = new Set(); transactionTail = Promise.resolve(); getAppConfigurationMock.mockResolvedValue(appConfiguration); queueTransactionalEmailMock.mockResolvedValue({ enqueued: true, jobId: "job_1" }); getWorkspaceInviteByTokenMock.mockResolvedValue(workspaceInvite); getDbClientMock.mockReturnValue({ $transaction: vi.fn((callback: (transaction: WorkspaceInviteClient) => Promise) => runFakeTransaction(callback)), } as unknown as ReturnType); getTenantUserByIdsMock.mockImplementation(async (_tenantId, userId) => transactionMembership?.userId === userId ? (transactionMembership as Awaited>) : null ); getUserMock.mockResolvedValue({ id: "from_user_1", email: "owner@example.com" } as Awaited>); getUserByEmailMock.mockResolvedValue(null); registerMock.mockImplementation(async (input) => { const createdAt = new Date("2026-07-15T11:00:00.000Z"); const createdUser = { id: "user_1", email: "invitee@example.com", passwordHash: "hash", firstName: "Ada", lastName: "Lovelace", avatar: "", phone: "", active: true, defaultTenantId: null, locale: "en", createdAt, }; return runFakeTransaction(async (transaction) => { registeredUserIds.add(createdUser.id); await input.transactionalMutation?.(transaction as never, createdUser as never); return { id: createdUser.id, email: createdUser.email, locale: createdUser.locale, defaultTenantId: null, createdAt }; }); }); hashPasswordMock.mockResolvedValue("$argon2id$prepared-owner-password"); checkAuthRateLimitMock.mockResolvedValue({ allowed: true }); claimReservedTenantWithShkDefaultsMock.mockImplementation( async (input) => ({ tenant: { id: "tenant_1", name: "Example Co", slug: "example-co", active: true, deactivatedReason: null, }, user: { id: input.userId, email: "invitee@example.com", firstName: "Ada", lastName: "Lovelace", locale: "en", createdAt: new Date("2026-07-15T11:00:00.000Z"), defaultTenantId: "tenant_1", }, replayed: false, }) as Awaited> ); getAllRolesMock.mockResolvedValue([role] as Awaited>); createTenantUserMock.mockImplementation(async ({ tenantId, userId }) => { transactionMembership = { tenantId, userId, status: 1 }; return { id: "tenant_user_1" } as Awaited>; }); eventRlsContexts = []; eventsCreateMock.mockImplementation(async () => { eventRlsContexts.push(getRlsExecutionContext()); return {} as Awaited>; }); eventsCreateIdempotentMock.mockImplementation(async () => { eventRlsContexts.push(getRlsExecutionContext()); return {} as Awaited>; }); getUserInfoMock.mockResolvedValue({ lng: "en", lightOrDarkMode: "light" } as Awaited>); setLoggedUserMock.mockImplementation( async (user) => ({ userId: user.id, defaultTenantId: "tenant_1", defaultTenant: { id: "tenant_1", name: "Example Co", slug: "example-co", active: true, deactivatedReason: null }, }) as Awaited> ); getInvitationTenantIdentityMock.mockImplementation(async () => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1" }); return { id: "tenant_1", name: "Example Co", slug: "example-co", active: true, deactivatedReason: null }; }); createUserSessionMock.mockResolvedValue( new Response(null, { status: 302, headers: { Location: "/example-co/dashboard" } }) as Awaited> ); beginAlternativeLoginMfaMock.mockResolvedValue({ required: false }); loadRequiredWebConfigMock.mockReturnValue({ routing: { adminAppHost: "admin.example.test", apiHost: "api.example.test", appBaseDomain: "example.test", protocol: "https", webAppHost: "app.example.test", }, } as ReturnType); }); it("precomputes the accepted-invitation sign-in path in the loader", async () => { getUserByEmailMock.mockResolvedValueOnce({ id: "existing_user_1", email: "invitee@example.com", passwordHash: "must-never-reach-hydration", totpSecretEncrypted: "must-never-reach-hydration", } as Awaited>); const response = await loader({ request: new Request("https://example.com/invitation/invite-token"), params: { id: "invite-token" }, context: {}, } as unknown as Parameters[0]); expect(response).toMatchObject({ appRootPath: "https://app.example.test/", existingUser: { id: "existing_user_1" }, invitation: expect.objectContaining({ email: "invitee@example.com", tenant: { name: "Example Co" }, }), }); expect(JSON.stringify(response)).not.toContain("passwordHash"); expect(JSON.stringify(response)).not.toContain("totpSecretEncrypted"); expect(JSON.stringify(response)).not.toContain("themeConfig"); expect(getInvitationTenantIdentityMock).toHaveBeenCalledWith("tenant_1"); expect(checkAuthRateLimitMock).toHaveBeenCalledWith({ request: expect.any(Request), action: "invitation-view", identifier: "invite-token", limit: 30, identifierLimit: 120, clientLimit: 300, windowMs: 15 * 60 * 1000, }); expect(headers()).toEqual({ "Cache-Control": "no-store", "Referrer-Policy": "no-referrer" }); }); it("fails closed before the loader lookup when the invitation throttle denies or its store is unavailable", async () => { checkAuthRateLimitMock.mockResolvedValueOnce({ allowed: false, retryAfterSeconds: 47 }); const response = await loader({ request: new Request("https://example.com/invitation/invite-token"), params: { id: "invite-token" }, context: {}, } as unknown as Parameters[0]); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(429); expect((response as Response).headers.get("Retry-After")).toBe("47"); expect((response as Response).headers.get("Cache-Control")).toBe("no-store"); await expect((response as Response).json()).resolves.toMatchObject({ invitation: null, existingUser: null }); expect(getWorkspaceInviteByTokenMock).not.toHaveBeenCalled(); expect(getInvitationTenantIdentityMock).not.toHaveBeenCalled(); expect(getUserByEmailMock).not.toHaveBeenCalled(); }); it("fails closed before CSRF and invitation lookup when the action throttle denies", async () => { checkAuthRateLimitMock.mockResolvedValueOnce({ allowed: false, retryAfterSeconds: 61 }); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(429); expect((response as Response).headers.get("Retry-After")).toBe("61"); await expect((response as Response).json()).resolves.toEqual({ error: "auth:invitation.errors.invalid" }); expect(checkAuthRateLimitMock).toHaveBeenCalledWith({ request: expect.any(Request), action: "invitation-accept", identifier: "invite-token", limit: 10, identifierLimit: 30, clientLimit: 100, windowMs: 15 * 60 * 1000, }); expect(validateCSRFTokenMock).not.toHaveBeenCalled(); expect(getWorkspaceInviteByTokenMock).not.toHaveBeenCalled(); expect(registerMock).not.toHaveBeenCalled(); }); it("renders an accepted owner invitation as replayable only for the same authenticated owner", async () => { configureOwnerInvitation({ status: "accepted", acceptedByUserId: "existing_user_1", active: true, deactivatedReason: null, }); configureAuthenticatedExistingUser(); const response = await loader({ request: new Request("https://example.com/invitation/invite-token"), params: { id: "invite-token" }, context: {}, } as unknown as Parameters[0]); expect(response).toMatchObject({ invitation: expect.objectContaining({ pending: true }), existingUser: { id: "existing_user_1" }, }); expect(getUserByEmailMock).not.toHaveBeenCalled(); getUserInfoMock.mockResolvedValueOnce({ userId: "different_user", lng: "en", lightOrDarkMode: "light" } as Awaited>); getUserByEmailMock.mockResolvedValueOnce(null); const deniedReplay = await loader({ request: new Request("https://example.com/invitation/invite-token"), params: { id: "invite-token" }, context: {}, } as unknown as Parameters[0]); expect(deniedReplay).toMatchObject({ invitation: null, existingUser: null }); expect(JSON.stringify(deniedReplay)).not.toContain("invitee@example.com"); expect(JSON.stringify(deniedReplay)).not.toContain("Example Co"); getWorkspaceInviteByTokenMock.mockResolvedValueOnce({ ...workspaceInvite!, pending: false, status: "accepted", acceptedAt: new Date("2026-07-15T11:05:00.000Z"), acceptedByUserId: "member_1", } as Awaited>); const acceptedMember = await loader({ request: new Request("https://example.com/invitation/invite-token"), params: { id: "invite-token" }, context: {}, } as unknown as Parameters[0]); expect(acceptedMember).toMatchObject({ invitation: null, existingUser: null }); expect(JSON.stringify(acceptedMember)).not.toContain("invitee@example.com"); expect(JSON.stringify(acceptedMember)).not.toContain("Example Co"); }); it("enqueues welcome email only after persisting a new invited user", async () => { const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect(validateCSRFTokenMock).toHaveBeenCalledOnce(); const [csrfRequest, csrfOptions] = validateCSRFTokenMock.mock.calls[0]!; expect(csrfRequest.method).toBe("POST"); expect(csrfOptions?.formData?.get("csrf")).toBe("csrf-token"); expect((response as Response).status).toBe(302); expect(registerMock).toHaveBeenCalledWith({ email: "invitee@example.com", password: "password", firstName: "Ada", lastName: "Lovelace", locale: "en", request: expect.any(Request), transactionalMutation: expect.any(Function), }); expect(createTenantUserMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1", type: 2 }, [role]); expect(welcomeParseMock).toHaveBeenCalledWith({ appConfiguration, data: { action_url: "https://example.com/login", name: "Ada", }, t: expect.any(Function), locale: "en", }); expect(queueTransactionalEmailMock).toHaveBeenCalledWith({ to: "invitee@example.com", alias: "welcome", tenantId: "tenant_1", userId: "user_1", idempotencyKey: "invitation:invitation_1:welcome", subject: "Welcome to Example", body: "

Welcome Ada at https://example.com/login

", data: { action_url: "https://example.com/login", name: "Ada", }, }); expect(acceptWorkspaceInviteMock).toHaveBeenCalledWith( { tenantId: "tenant_1", inviteId: "invitation_1", token: "invite-token", acceptedByUserId: "user_1", createdUserId: "user_1", bindCreatedUserId: true, }, transactionClient ); expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(acceptWorkspaceInviteMock.mock.invocationCallOrder[0]); expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(createTenantUserMock.mock.invocationCallOrder[0]); expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(eventsCreateIdempotentMock.mock.invocationCallOrder[0]); expect(eventsCreateIdempotentMock).toHaveBeenCalledWith( expect.objectContaining({ idempotencyKey: "invitation:invitation_1:accepted", data: expect.objectContaining({ newUser: true, invitation: { id: "invitation_1" } }), }) ); expect(eventRlsContexts).toEqual([expect.objectContaining({ tenantId: "tenant_1", userId: "user_1" })]); expect(createUserSessionMock).toHaveBeenCalledWith(expect.objectContaining({ userId: "user_1", lng: "en" }), "/example-co/dashboard", { request: expect.any(Request), rotate: true, }); expect(transactionInvite).toMatchObject({ pending: false, status: "accepted", acceptedByUserId: "user_1", createdUserId: "user_1" }); expect(transactionMembership).toEqual({ tenantId: "tenant_1", userId: "user_1", status: 1 }); expect(registeredUserIds).toEqual(new Set(["user_1"])); expect(sendEmailMock).not.toHaveBeenCalled(); }); it("rolls user, invite, and membership back together when membership creation fails, then remains retryable", async () => { createTenantUserMock.mockRejectedValueOnce(new Error("membership unavailable")); await expect(postInvitation()).rejects.toThrow("membership unavailable"); expect(transactionInvite).toMatchObject({ pending: true, status: "pending", acceptedByUserId: null, createdUserId: null }); expect(transactionMembership).toBeNull(); expect(registeredUserIds).toEqual(new Set()); expect(eventsCreateIdempotentMock).not.toHaveBeenCalled(); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); const retry = await postInvitation(); expect(retry).toBeInstanceOf(Response); expect((retry as Response).status).toBe(302); expect(transactionInvite).toMatchObject({ pending: false, status: "accepted", acceptedByUserId: "user_1", createdUserId: "user_1" }); expect(transactionMembership).toEqual({ tenantId: "tenant_1", userId: "user_1", status: 1 }); expect(registeredUserIds).toEqual(new Set(["user_1"])); expect(eventsCreateIdempotentMock).toHaveBeenCalledTimes(1); expect(queueTransactionalEmailMock).toHaveBeenCalledTimes(1); }); it("commits exactly one complete membership when the same fresh invite is accepted concurrently", async () => { const results = await Promise.all([postInvitation(), postInvitation()]); const statuses = results.map((result) => (result as Response).status).sort((left, right) => left - right); expect(statuses).toEqual([302, 400]); expect(transactionInvite).toMatchObject({ pending: false, status: "accepted", acceptedByUserId: "user_1", createdUserId: "user_1" }); expect(transactionMembership).toEqual({ tenantId: "tenant_1", userId: "user_1", status: 1 }); expect(registeredUserIds).toEqual(new Set(["user_1"])); expect(eventsCreateIdempotentMock).toHaveBeenCalledTimes(1); expect(queueTransactionalEmailMock).toHaveBeenCalledTimes(1); }); it("generates a server-only throwaway password for magic-link invitations", async () => { const response = await postInvitation("magic-link"); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(registerMock).toHaveBeenCalledWith( expect.objectContaining({ email: "invitee@example.com", password: "generated-magic-link-password", }) ); }); it("does not issue a full invitation session when TOTP is enabled", async () => { beginAlternativeLoginMfaMock.mockResolvedValue({ required: true, setCookie: "hivegrid_session=pending; HttpOnly", }); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect((response as Response).headers.get("Location")).toBe("/login-mfa"); expect((response as Response).headers.get("Set-Cookie")).toContain("hivegrid_session=pending"); expect(beginAlternativeLoginMfaMock).toHaveBeenCalledWith({ request: expect.any(Request), userId: "user_1", redirectTo: "/example-co/dashboard", primaryMethod: "invitation", }); expect(setLoggedUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it("does not grant tenant-specific app roles from other tenants to invited users", async () => { getAllRolesMock.mockResolvedValue([role, tenantScopedRole] as Awaited>); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect(createTenantUserMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1", type: 2 }, [role]); }); it("accepts existing-user invitations without enqueueing a welcome email", async () => { const existingUser = { id: "existing_user_1", email: "invitee@example.com", firstName: "Ada", lastName: "Lovelace" } as Awaited< ReturnType >; getUserByEmailMock.mockResolvedValue(existingUser); getUserMock.mockImplementation(async (userId) => userId === "existing_user_1" ? (existingUser as Awaited>) : ({ id: "from_user_1", email: "owner@example.com" } as never) ); getUserInfoMock.mockResolvedValue({ userId: "existing_user_1", lng: "en", lightOrDarkMode: "light" } as Awaited>); const response = await postInvitation(); expect(response).toEqual({ invitationAccepted: true }); expect(registerMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).toHaveBeenCalledWith( { tenantId: "tenant_1", inviteId: "invitation_1", token: "invite-token", acceptedByUserId: "existing_user_1", }, transactionClient ); expect(createTenantUserMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "existing_user_1", type: 2 }, [role]); expect(eventRlsContexts).toEqual([expect.objectContaining({ tenantId: "tenant_1", userId: "existing_user_1" })]); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); expect(sendEmailMock).not.toHaveBeenCalled(); }); it("fails closed before accepting when the invited existing user already has an inactive membership", async () => { configureAuthenticatedExistingUser(); transactionMembership = { tenantId: "tenant_1", userId: "existing_user_1", status: 0 }; const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(400); await expect(readJson(response)).resolves.toEqual({ error: "auth:invitation.errors.invalid" }); expect(transactionInvite).toMatchObject({ pending: true, status: "pending", acceptedByUserId: null }); expect(createTenantUserMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).not.toHaveBeenCalled(); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); }); it("claims an inactive pending-owner reservation for a newly registered owner before every external side effect", async () => { configureOwnerInvitation(); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(getWorkspaceInviteByTokenMock.mock.invocationCallOrder[0]).toBeLessThan(getInvitationTenantIdentityMock.mock.invocationCallOrder[0]); expect(getInvitationTenantIdentityMock).toHaveBeenCalledWith("tenant_1", { allowedInactiveReason: "pending_owner", }); expect(registerMock).not.toHaveBeenCalled(); expect(hashPasswordMock).toHaveBeenCalledWith("password"); const claimInput = claimReservedTenantWithShkDefaultsMock.mock.calls[0]?.[0]; expect(claimInput).toEqual({ tenantId: "tenant_1", userId: expect.stringMatching(/^[a-f0-9-]{36}$/u), t: expect.any(Function), createUser: { id: expect.stringMatching(/^[a-f0-9-]{36}$/u), email: "invitee@example.com", passwordHash: "$argon2id$prepared-owner-password", firstName: "Ada", lastName: "Lovelace", locale: "en", }, claim: { kind: "workspace-invite", inviteId: "invitation_1", token: "invite-token", createdUserId: expect.stringMatching(/^[a-f0-9-]{36}$/u), }, }); expect(claimInput?.createUser?.id).toBe(claimInput?.userId); expect(claimInput?.claim.createdUserId).toBe(claimInput?.userId); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(createTenantUserMock).not.toHaveBeenCalled(); expect(getUserMock).not.toHaveBeenCalled(); expect(emitUserCreatedHookMock).toHaveBeenCalledWith(expect.objectContaining({ id: claimInput?.userId, defaultTenantId: "tenant_1" })); expect(eventsCreateMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).toHaveBeenCalledWith( expect.objectContaining({ idempotencyKey: "invitation:invitation_1:accepted", data: expect.objectContaining({ newUser: true, fromUser: null }), }) ); expect(queueTransactionalEmailMock).toHaveBeenCalledWith( expect.objectContaining({ idempotencyKey: "invitation:invitation_1:welcome", userId: claimInput?.userId }) ); expect(setLoggedUserMock).toHaveBeenCalledWith(expect.objectContaining({ id: claimInput?.userId, defaultTenantId: "tenant_1" })); expect(createUserSessionMock).toHaveBeenCalledWith(expect.objectContaining({ userId: claimInput?.userId }), "/example-co/dashboard", { request: expect.any(Request), rotate: true, }); const claimOrder = claimReservedTenantWithShkDefaultsMock.mock.invocationCallOrder[0]!; expect(emitUserCreatedHookMock.mock.invocationCallOrder[0]).toBeGreaterThan(claimOrder); expect(eventsCreateIdempotentMock.mock.invocationCallOrder[0]).toBeGreaterThan(claimOrder); expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(claimOrder); expect(createUserSessionMock.mock.invocationCallOrder[0]).toBeGreaterThan(claimOrder); }); it("keeps magic-link owner creation inside the same atomic claim transaction", async () => { configureOwnerInvitation(); const response = await postInvitation("magic-link"); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(registerMock).not.toHaveBeenCalled(); expect(hashPasswordMock).toHaveBeenCalledWith("generated-magic-link-password"); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledWith( expect.objectContaining({ createUser: expect.objectContaining({ passwordHash: "$argon2id$prepared-owner-password" }), claim: expect.objectContaining({ createdUserId: expect.any(String) }), }) ); }); it("claims an inactive pending-owner reservation for an authenticated existing owner without creating membership twice", async () => { configureOwnerInvitation(); configureAuthenticatedExistingUser(); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "existing_user_1", t: expect.any(Function), claim: { kind: "workspace-invite", inviteId: "invitation_1", token: "invite-token" }, }); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(createTenantUserMock).not.toHaveBeenCalled(); expect(getUserMock).not.toHaveBeenCalledWith("from_user_1"); expect(emitUserCreatedHookMock).not.toHaveBeenCalled(); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).toHaveBeenCalledTimes(1); expect(setLoggedUserMock).toHaveBeenCalledWith(expect.objectContaining({ id: "existing_user_1", defaultTenantId: "tenant_1" })); expect(createUserSessionMock).toHaveBeenCalledWith(expect.objectContaining({ userId: "existing_user_1" }), "/example-co/dashboard", { request: expect.any(Request), rotate: true, }); expect(createUserSessionMock.mock.calls[0]?.[0]).not.toHaveProperty("defaultTenantId"); }); it("fails closed without side effects when the atomic new-owner claim loses the invite race", async () => { configureOwnerInvitation(); claimReservedTenantWithShkDefaultsMock.mockRejectedValueOnce(new WorkspaceInviteError("invite_not_found")); const response = await postInvitation(); expect((response as Response).status).toBe(400); expect(await readJson(response)).toEqual({ error: "auth:invitation.errors.invalid" }); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledOnce(); expect(emitUserCreatedHookMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).not.toHaveBeenCalled(); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it("does not rotate an owner session unless membership resolution selects the claimed tenant", async () => { configureOwnerInvitation(); configureAuthenticatedExistingUser(); setLoggedUserMock.mockResolvedValueOnce({ userId: "existing_user_1", defaultTenantId: "another_tenant", defaultTenant: { id: "another_tenant", name: "Other", slug: "other", active: true, deactivatedReason: null }, } as Awaited>); const response = await postInvitation(); expect((response as Response).status).toBe(400); expect(await readJson(response)).toEqual({ error: "auth:invitation.errors.invalid" }); expect(setLoggedUserMock).toHaveBeenCalledWith(expect.objectContaining({ defaultTenantId: "tenant_1" })); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it("keeps a pending owner invitation on an active tenant on the normal membership path", async () => { configureOwnerInvitation({ active: true, deactivatedReason: null }); configureAuthenticatedExistingUser(); await expect(postInvitation()).resolves.toEqual({ invitationAccepted: true }); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).toHaveBeenCalledWith( { tenantId: "tenant_1", inviteId: "invitation_1", token: "invite-token", acceptedByUserId: "existing_user_1", }, transactionClient ); expect(createTenantUserMock).toHaveBeenCalledTimes(1); expect(eventsCreateMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).toHaveBeenCalledTimes(1); }); it("does not resolve an inactive tenant for a normal member invitation", async () => { getInvitationTenantIdentityMock.mockResolvedValueOnce(null); const response = await postInvitation(); expect((response as Response).status).toBe(400); expect(getInvitationTenantIdentityMock).toHaveBeenCalledWith("tenant_1"); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(registerMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); }); it("replays an accepted owner claim only for the same authenticated existing owner", async () => { configureOwnerInvitation({ status: "accepted", acceptedByUserId: "existing_user_1", active: true, deactivatedReason: null, }); configureAuthenticatedExistingUser(); claimReservedTenantWithShkDefaultsMock.mockResolvedValueOnce({ tenant: { id: "tenant_1", active: true }, user: { id: "existing_user_1" }, replayed: true, } as Awaited>); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledWith( expect.objectContaining({ userId: "existing_user_1", claim: { kind: "workspace-invite", inviteId: "invitation_1", token: "invite-token" }, }) ); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(createTenantUserMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).toHaveBeenCalledWith(expect.objectContaining({ idempotencyKey: "invitation:invitation_1:accepted" })); }); it("replays the created-user owner claim with the exact durable marker and idempotent side effects", async () => { configureOwnerInvitation({ status: "accepted", acceptedByUserId: "existing_user_1", createdUserId: "existing_user_1", active: true, deactivatedReason: null, }); configureAuthenticatedExistingUser(); claimReservedTenantWithShkDefaultsMock.mockResolvedValueOnce({ tenant: { id: "tenant_1", active: true }, user: { id: "existing_user_1" }, replayed: true, } as Awaited>); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledWith( expect.objectContaining({ userId: "existing_user_1", claim: { kind: "workspace-invite", inviteId: "invitation_1", token: "invite-token", createdUserId: "existing_user_1", }, }) ); expect(emitUserCreatedHookMock).toHaveBeenCalledWith(expect.objectContaining({ id: "existing_user_1", defaultTenantId: "tenant_1" })); expect(eventsCreateIdempotentMock).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ newUser: true }) })); expect(queueTransactionalEmailMock).toHaveBeenCalledWith(expect.objectContaining({ idempotencyKey: "invitation:invitation_1:welcome" })); }); it("still rotates the owner session when post-commit hook, event, and welcome dispatch all fail", async () => { configureOwnerInvitation({ status: "accepted", acceptedByUserId: "existing_user_1", createdUserId: "existing_user_1", active: true, deactivatedReason: null, }); configureAuthenticatedExistingUser(); claimReservedTenantWithShkDefaultsMock.mockResolvedValueOnce({ tenant: { id: "tenant_1", active: true }, user: { id: "existing_user_1" }, replayed: true, } as Awaited>); emitUserCreatedHookMock.mockRejectedValueOnce(new Error("hook unavailable")); eventsCreateIdempotentMock.mockRejectedValueOnce(new Error("event unavailable")); queueTransactionalEmailMock.mockRejectedValueOnce(new Error("queue unavailable")); const response = await postInvitation(); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect((response as Response).headers.get("Location")).toBe("/example-co/dashboard"); expect(emitUserCreatedHookMock).toHaveBeenCalledOnce(); expect(eventsCreateIdempotentMock).toHaveBeenCalledOnce(); expect(queueTransactionalEmailMock).toHaveBeenCalledOnce(); expect(setLoggedUserMock).toHaveBeenCalledWith(expect.objectContaining({ defaultTenantId: "tenant_1" })); expect(createUserSessionMock).toHaveBeenCalledWith(expect.objectContaining({ userId: "existing_user_1" }), "/example-co/dashboard", { request: expect.any(Request), rotate: true, }); }); it("fails closed for an accepted owner token when acceptedBy does not match the authenticated user", async () => { configureOwnerInvitation({ status: "accepted", acceptedByUserId: "different_user", active: true, deactivatedReason: null, }); configureAuthenticatedExistingUser(); const response = await postInvitation(); expect((response as Response).status).toBe(400); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).not.toHaveBeenCalled(); }); it("retries a rolled-back atomic new-owner claim without a session or stranded user", async () => { configureOwnerInvitation(); claimReservedTenantWithShkDefaultsMock.mockRejectedValueOnce(new WorkspaceInviteError("invite_not_found")); const failed = await postInvitation(); expect((failed as Response).status).toBe(400); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledTimes(1); expect(emitUserCreatedHookMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).not.toHaveBeenCalled(); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); const retried = await postInvitation(); expect(retried).toBeInstanceOf(Response); expect((retried as Response).status).toBe(302); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).toHaveBeenCalledTimes(2); const firstAttempt = claimReservedTenantWithShkDefaultsMock.mock.calls[0]?.[0]; const secondAttempt = claimReservedTenantWithShkDefaultsMock.mock.calls[1]?.[0]; expect(firstAttempt?.createUser?.id).toBe(firstAttempt?.userId); expect(secondAttempt?.createUser?.id).toBe(secondAttempt?.userId); expect(secondAttempt?.userId).not.toBe(firstAttempt?.userId); expect(getUserInfoMock).toHaveBeenLastCalledWith(expect.any(Request)); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(createTenantUserMock).not.toHaveBeenCalled(); expect(eventsCreateIdempotentMock).toHaveBeenCalledTimes(1); expect(emitUserCreatedHookMock).toHaveBeenCalledTimes(1); expect(queueTransactionalEmailMock).toHaveBeenCalledTimes(1); }); it("rejects an authenticated user whose identity does not match the invited email", async () => { getUserInfoMock.mockResolvedValue({ userId: "attacker_1", lng: "en", lightOrDarkMode: "light" } as Awaited>); getUserMock.mockResolvedValueOnce({ id: "attacker_1", email: "attacker@example.com" } as Awaited>); const response = await postInvitation(); expect((response as Response).status).toBe(400); await expect(readJson(response)).resolves.toEqual({ error: "auth:invitation.errors.signInAsInvitedUser" }); expect(registerMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(eventsCreateMock).not.toHaveBeenCalled(); }); it("keeps expired owner and accepted member invitations finalized and side-effect free", async () => { configureOwnerInvitation({ status: "expired", active: false, deactivatedReason: "pending_owner" }); const expiredOwner = await postInvitation(); expect((expiredOwner as Response).status).toBe(400); await expect(readJson(expiredOwner)).resolves.toEqual({ error: "auth:invitation.errors.expired" }); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); vi.clearAllMocks(); getWorkspaceInviteByTokenMock.mockResolvedValue({ ...workspaceInvite!, pending: false, status: "accepted", acceptedByUserId: "existing_user_1", } as Awaited>); getInvitationTenantIdentityMock.mockResolvedValue({ id: "tenant_1", name: "Example Co", slug: "example-co", active: true, deactivatedReason: null, }); getUserInfoMock.mockResolvedValue({ userId: "existing_user_1", lng: "en" } as Awaited>); const acceptedMember = await postInvitation(); expect((acceptedMember as Response).status).toBe(400); expect(getUserMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); }); it("returns 400 for invalid invitations without enqueueing", async () => { getWorkspaceInviteByTokenMock.mockResolvedValue(null); const response = await postInvitation(); expect((response as Response).status).toBe(400); await expect(readJson(response)).resolves.toEqual({ error: "auth:invitation.errors.invalid" }); expect(getInvitationTenantIdentityMock).not.toHaveBeenCalled(); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(createTenantUserMock).not.toHaveBeenCalled(); expect(queueTransactionalEmailMock).not.toHaveBeenCalled(); expect(sendEmailMock).not.toHaveBeenCalled(); }); it("fails closed when the verified invite cannot read its tenant-safe projection", async () => { getInvitationTenantIdentityMock.mockResolvedValueOnce(null); const response = await postInvitation(); expect((response as Response).status).toBe(400); await expect(readJson(response)).resolves.toEqual({ error: "auth:invitation.errors.invalid" }); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); expect(eventsCreateMock).not.toHaveBeenCalled(); }); it("rejects a forged invitation POST before reading or mutating invitation state", async () => { validateCSRFTokenMock.mockRejectedValueOnce(new Error("CSRF tokens do not match")); await expect(postInvitation()).rejects.toThrow("CSRF tokens do not match"); expect(getWorkspaceInviteByTokenMock).not.toHaveBeenCalled(); expect(registerMock).not.toHaveBeenCalled(); expect(claimReservedTenantWithShkDefaultsMock).not.toHaveBeenCalled(); expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled(); }); });