Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/domain/tenant-bootstrap/tenantBootstrapService.server.test.ts
T

2114 lines
85 KiB
TypeScript

import { createHash } from "node:crypto";
import type { Tenant, User } from "@hivegrid/db/prisma-browser";
import { CatalogError, foundationErrors } from "@hivegrid/foundation";
import { getRlsExecutionContext, runWithRlsContext } from "@hivegrid/db/rls-context.server";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
import type { TenantRlsClient } from "~/utils/db/.server/tenantRls.server";
import { SHK_V2_TENANT_BOOTSTRAP_CONFIG, SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST } from "./shk-v2.config";
import {
SHK_FIRST_STEPS,
SHK_FIRST_STEPS_CHECKLIST_CODE,
SHK_FIRST_STEPS_CHECKLIST_ID,
TENANT_PENDING_OWNER_REASON,
} from "./tenantBootstrap.constants";
const dependencyMocks = vi.hoisted(() => ({
hashPassword: vi.fn(),
verifyPassword: vi.fn(),
createTenant: vi.fn(),
emitTenantCreatedHook: vi.fn(),
dbTransaction: vi.fn(),
dbUserFindUnique: vi.fn(),
invalidateUserSnapshot: vi.fn(),
publishTenantInvalidation: vi.fn(),
emitUserCreatedHook: vi.fn(),
seedForms: vi.fn(),
prepareForms: vi.fn(),
seedCustomFields: vi.fn(),
seedAcceptance: vi.fn(),
seedProject: vi.fn(),
getWorkspaceInviteByToken: vi.fn(),
acceptWorkspaceInvite: vi.fn(),
hashWorkspaceInviteToken: vi.fn(() => "a".repeat(64)),
resolveUserEmailRlsIdentity: vi.fn(),
findRegistrationBillingPreferenceCapability: vi.fn(),
issueReservedOwnerInvitationWithTx: vi.fn(),
}));
vi.mock("~/utils/auth/passwordHasher.server", () => ({
hashPassword: dependencyMocks.hashPassword,
verifyPassword: dependencyMocks.verifyPassword,
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
createTenant: dependencyMocks.createTenant,
emitTenantCreatedHook: dependencyMocks.emitTenantCreatedHook,
}));
vi.mock("~/utils/db.server", () => ({
db: {
$transaction: dependencyMocks.dbTransaction,
user: { findUnique: dependencyMocks.dbUserFindUnique },
},
}));
vi.mock("~/utils/db/user-snapshot-cache.server", () => ({ invalidateUserSnapshot: dependencyMocks.invalidateUserSnapshot }));
vi.mock("~/utils/db/tenant-cache.server", () => ({ publishTenantInvalidation: dependencyMocks.publishTenantInvalidation }));
vi.mock("~/utils/db/users.db.server", () => ({ emitUserCreatedHook: dependencyMocks.emitUserCreatedHook }));
vi.mock("~/modules/forms/services/shkFormTemplates.server", () => ({
prepareShkFormTemplates: dependencyMocks.prepareForms,
seedShkFormTemplatesWithTx: dependencyMocks.seedForms,
}));
vi.mock("~/utils/integrations/crm/customFieldService.server", () => ({
seedShkCustomFieldTemplateWithTx: dependencyMocks.seedCustomFields,
}));
vi.mock("~/utils/integrations/projects/auftragService.server", () => ({
ensureDefaultAcceptanceFormTemplateWithTx: dependencyMocks.seedAcceptance,
ensureDefaultProjectTemplateWithTx: dependencyMocks.seedProject,
}));
vi.mock("@hivegrid/db/workspace-invites.server", () => ({
getWorkspaceInviteByToken: dependencyMocks.getWorkspaceInviteByToken,
acceptWorkspaceInvite: dependencyMocks.acceptWorkspaceInvite,
hashWorkspaceInviteToken: dependencyMocks.hashWorkspaceInviteToken,
WorkspaceInviteError: class WorkspaceInviteError extends Error {},
}));
vi.mock("@hivegrid/db/rls-resolvers.server", () => ({
resolveUserEmailRlsIdentity: dependencyMocks.resolveUserEmailRlsIdentity,
}));
vi.mock("@hivegrid/db/pretenant-security.server", () => ({
findRegistrationBillingPreferenceCapability: dependencyMocks.findRegistrationBillingPreferenceCapability,
}));
vi.mock("./ownerInvitationIssuance.server", () => ({
issueReservedOwnerInvitationWithTx: dependencyMocks.issueReservedOwnerInvitationWithTx,
}));
import {
bootstrapShkV2TenantWithTx,
claimReservedTenantWithShkDefaults,
createOwnedTenantWithShkDefaults,
createSignupTenantWithShkDefaults,
deriveSignupTenantId,
deriveSignupUserId,
deriveTenantCreationId,
deriveTenantReservationId,
isExactOwnedTenantCreationReplay,
reserveTenantWithoutOwner,
SHK_V2_BOOTSTRAP_SCOPE,
} from "./tenantBootstrapService.server";
const FIXED_NOW = new Date("2026-07-15T10:00:00.000Z");
const CREATION_REQUEST_KEY = "d7077797-054b-497a-b1ce-8e4f36257a96";
const OWNER_INVITATION_DRAFT = {
issuanceKey: "41adac34-7b0d-47f0-9bb5-74dd67104dcb",
email: "owner@heizkraft.example",
firstName: "Mara",
lastName: "König",
fromUserId: "operator_1",
token: "o".repeat(43),
mail: { subject: "Einladung", html: `https://app.example.test/invitation/${"o".repeat(43)}` },
};
const translate = (key: string) => `translated:${key}`;
const preparedFormTemplates = [];
function tenantRow(overrides: Partial<Tenant> = {}): Tenant {
return {
id: "tenant_1",
createdAt: FIXED_NOW,
updatedAt: FIXED_NOW,
slug: "heizkraft",
name: "Heizkraft GmbH",
icon: null,
logo: null,
subscriptionId: null,
active: false,
deactivatedReason: TENANT_PENDING_OWNER_REASON,
theme: null,
themeConfig: null,
anrede: "du",
...overrides,
};
}
function userRow(overrides: Partial<User> = {}): User {
return {
id: "user_1",
createdAt: FIXED_NOW,
updatedAt: FIXED_NOW,
email: "owner@heizkraft.example",
passwordHash: "hash",
firstName: "Mara",
lastName: "König",
avatar: "",
phone: "",
defaultTenantId: "tenant_1",
verifyToken: null,
verifyTokenCreatedAt: null,
locale: "de",
lightOrDarkMode: null,
totpSecretEncrypted: null,
totpPendingSecretEncrypted: null,
totpEnabledAt: null,
totpPendingCreatedAt: null,
mfaRecoveryCodeHashes: null,
mfaRecoveryCodesGeneratedAt: null,
mfaRecoveryCodeLastUsedAt: null,
active: false,
pendingDeletion: false,
scheduledDeletionAt: null,
deletionRequestedAt: null,
pseudonymized: false,
pseudonymizedAt: null,
deletionRequestId: null,
...overrides,
};
}
type FakeTx = ReturnType<typeof buildFakeTx>;
function buildFakeTx(markerOverrides: Record<string, unknown> = {}, storedMarker: Record<string, unknown> | null = null) {
const calls: string[] = [];
const record = <T>(name: string, value: T) => {
calls.push(name);
return Promise.resolve(value);
};
const permissionKeys = [...new Set(SHK_V2_TENANT_BOOTSTRAP_CONFIG.tenantRoles.flatMap((role) => role.permissionKeys))];
const tenantRoles = SHK_V2_TENANT_BOOTSTRAP_CONFIG.tenantRoles.map((role, index) => ({ id: `role_${index}`, name: role.name }));
const pipelines = SHK_V2_TENANT_BOOTSTRAP_CONFIG.salesPipelines.map((pipeline, index) => ({ id: `pipeline_${index}`, name: pipeline.name }));
const onboardingSteps = SHK_FIRST_STEPS.map((step) => ({ ...step }));
const tx = {
calls,
$queryRaw: vi.fn(() => record("user.lock", [userRow({ active: true })])),
idempotencyKey: {
upsert: vi.fn((args: { create: Record<string, unknown> }) => record("marker.acquire", { ...args.create, ...markerOverrides })),
findUnique: vi.fn(() => record("marker.find", storedMarker)),
update: vi.fn(() => record("marker.complete", {})),
},
role: {
findMany: vi.fn(() => record("role.admin.find", [{ id: "role_admin" }])),
createManyAndReturn: vi.fn(() => record("role.tenant.createManyAndReturn", tenantRoles)),
},
tenantUser: {
upsert: vi.fn(() => record("membership.upsert", {})),
findFirst: vi.fn(() => record("membership.findOwner", { id: "membership_1" })),
findMany: vi.fn(() => record("membership.findExisting", [])),
},
tenantUserInvitation: {
updateMany: vi.fn(() => record("invitation.bindCreatedUser", { count: 1 })),
},
user: {
create: vi.fn(() => record("user.create", userRow())),
update: vi.fn((args: { data: { active?: boolean; defaultTenantId?: string } }) =>
record(
args.data.active ? "user.activate" : "user.defaultTenant",
userRow({ active: args.data.active ?? true, defaultTenantId: args.data.defaultTenantId ?? "tenant_1" })
)
),
findUnique: vi.fn(() => record("user.find", userRow())),
findMany: vi.fn(() => record("user.findMatches", [userRow()])),
},
userRole: {
deleteMany: vi.fn(() => record("userRole.prune", { count: 0 })),
createMany: vi.fn(() => record("userRole.admin", { count: 1 })),
},
tenantType: { findMany: vi.fn(() => record("tenantType.findMany", [])) },
permission: {
findMany: vi.fn(() =>
record(
"permission.findMany",
permissionKeys.map((name, index) => ({ id: `permission_${index}`, name }))
)
),
},
rolePermission: { createMany: vi.fn(() => record("rolePermission.createMany", { count: permissionKeys.length })) },
pipeline: {
createManyAndReturn: vi.fn(() => record("pipeline.createManyAndReturn", pipelines)),
},
pipelineStage: { createMany: vi.fn(() => record("pipelineStage.createMany", { count: 15 })) },
lostReason: { createMany: vi.fn(() => record("lostReason.createMany", { count: 5 })) },
onboarding: {
findUnique: vi.fn(() =>
record("onboarding.find", {
id: SHK_FIRST_STEPS_CHECKLIST_ID,
title: SHK_FIRST_STEPS_CHECKLIST_CODE,
type: "page",
realtime: false,
active: true,
canBeDismissed: true,
height: null,
steps: onboardingSteps,
})
),
},
onboardingSession: { upsert: vi.fn(() => record("onboardingSession.upsert", { id: "session_1" })) },
onboardingSessionStep: { createMany: vi.fn(() => record("onboardingSessionStep.createMany", { count: 4 })) },
automationTemplate: { createMany: vi.fn(() => record("automationTemplate.createMany", { count: 3 })) },
portal: { upsert: vi.fn(() => record("portal.scaffold", { id: "portal_1" })) },
tenantProductConfiguration: {
upsert: vi.fn((args: { create: Record<string, unknown> }) => record("billingPreference.upsert", args.create)),
findUnique: vi.fn(() =>
record("billingPreference.find", {
signupSubscriptionPriceId: "price_swarm_monthly",
signupOfficeSeatQuantity: 5,
signupFieldSeatQuantity: 15,
})
),
},
tenant: {
findUnique: vi.fn(() => record("tenant.find", tenantRow())),
findUniqueOrThrow: vi.fn(() => record("tenant.findFinal", tenantRow({ active: true, deactivatedReason: null }))),
update: vi.fn((args: { data: { active?: boolean } }) =>
record(args.data.active ? "tenant.activate" : "tenant.update", tenantRow({ active: Boolean(args.data.active), deactivatedReason: null }))
),
},
};
return tx;
}
function asTenantTx(fake: FakeTx): TenantRlsClient {
return fake as unknown as TenantRlsClient;
}
beforeEach(() => {
vi.clearAllMocks();
dependencyMocks.hashPassword.mockResolvedValue("prepared_hash");
dependencyMocks.verifyPassword.mockResolvedValue({ valid: true });
dependencyMocks.dbUserFindUnique.mockResolvedValue({ passwordHash: "hash" });
dependencyMocks.emitUserCreatedHook.mockResolvedValue(undefined);
dependencyMocks.emitTenantCreatedHook.mockResolvedValue(undefined);
dependencyMocks.invalidateUserSnapshot.mockResolvedValue(undefined);
dependencyMocks.publishTenantInvalidation.mockResolvedValue(undefined);
dependencyMocks.seedForms.mockImplementation((_tx: unknown, _input: unknown) => Promise.resolve({ upserted: 2 }));
dependencyMocks.prepareForms.mockReturnValue(preparedFormTemplates);
dependencyMocks.seedCustomFields.mockImplementation((_tx: unknown, _input: unknown) => Promise.resolve({ created: 0 }));
dependencyMocks.seedAcceptance.mockImplementation((_tx: unknown, _tenantId: string) => Promise.resolve({ id: "acceptance_1" }));
dependencyMocks.seedProject.mockImplementation((_tx: unknown, _tenantId: string) => Promise.resolve({ id: "project_template_1" }));
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValue({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
firstName: "Mara",
lastName: "König",
type: TenantUserType.OWNER,
status: "pending",
createdUserId: null,
acceptedByUserId: null,
});
dependencyMocks.acceptWorkspaceInvite.mockResolvedValue({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
acceptedByUserId: "user_1",
});
dependencyMocks.resolveUserEmailRlsIdentity.mockImplementation(async (_email: string, client?: unknown) =>
client ? { resourceId: "user_1", userId: "user_1" } : null
);
dependencyMocks.findRegistrationBillingPreferenceCapability.mockResolvedValue(null);
dependencyMocks.issueReservedOwnerInvitationWithTx.mockResolvedValue({ invitationId: "invite_owner", replayed: false });
});
describe("bootstrapShkV2TenantWithTx", () => {
it("batches the configured defaults and activates the tenant as the final write", async () => {
const fake = buildFakeTx();
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
now: FIXED_NOW,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).resolves.toEqual({ replayed: false, tenant: tenantRow({ active: true, deactivatedReason: null }) });
expect(fake.role.createManyAndReturn).toHaveBeenCalledWith(expect.objectContaining({ skipDuplicates: true }));
expect(fake.role.createManyAndReturn.mock.calls[0]?.[0].data).toHaveLength(5);
expect(fake.userRole.createMany).toHaveBeenCalledWith({
data: [{ tenantId: "tenant_1", userId: "user_1", roleId: "role_admin" }],
skipDuplicates: true,
});
expect(fake.pipeline.createManyAndReturn.mock.calls[0]?.[0].data).toHaveLength(3);
expect(fake.pipelineStage.createMany.mock.calls[0]?.[0].data).toHaveLength(15);
expect(fake.lostReason.createMany.mock.calls[0]?.[0].data).toHaveLength(5);
expect(fake.onboarding.findUnique).toHaveBeenCalledWith({
where: { id: SHK_FIRST_STEPS_CHECKLIST_ID },
select: {
id: true,
title: true,
type: true,
realtime: true,
active: true,
canBeDismissed: true,
height: true,
steps: { select: { id: true, order: true, block: true } },
},
});
expect(fake.onboardingSessionStep.createMany).toHaveBeenCalledWith({
data: SHK_FIRST_STEPS.map((step) => ({ onboardingSessionId: "session_1", stepId: step.id })),
skipDuplicates: true,
});
expect(fake.automationTemplate.createMany).toHaveBeenCalledWith(
expect.objectContaining({
data: expect.arrayContaining([
expect.objectContaining({ name: "shk.order-thank-you.v1", isPublished: false, flowData: expect.objectContaining({ nodes: [] }) }),
expect.objectContaining({ name: "shk.kwp-project-routing.v1", isPublished: false, flowData: expect.objectContaining({ nodes: [] }) }),
expect.objectContaining({ name: "shk.follow-up-reminder.v1", isPublished: false, flowData: expect.objectContaining({ nodes: [] }) }),
]),
})
);
expect(fake.portal.upsert).toHaveBeenCalledWith({
where: { tenantId: "tenant_1" },
create: {
tenantId: "tenant_1",
createdByUserId: "user_1",
subdomain: "heizkraft",
title: "Heizkraft GmbH",
isPublished: false,
metadata: { provisioningSource: "tenant_bootstrap_v1" },
},
update: {},
select: { id: true },
});
expect(fake.calls.indexOf("portal.scaffold")).toBeLessThan(fake.calls.indexOf("marker.complete"));
expect(fake.calls.at(-2)).toBe("marker.complete");
expect(fake.calls.at(-1)).toBe("tenant.activate");
expect(fake.calls.length).toBeLessThanOrEqual(26);
});
it("returns a completed marker without mutating an existing tenant", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_2",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).resolves.toEqual({ replayed: true });
expect(fake.calls).toEqual(["marker.acquire"]);
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it("fails closed when a completed tenant has another config digest", async () => {
const fake = buildFakeTx({ requestHash: "different", responseStatus: 201 });
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it("never completes the marker or activates when a default fails", async () => {
const fake = buildFakeTx();
dependencyMocks.seedForms.mockRejectedValueOnce(new Error("form-default-failed"));
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).rejects.toThrow("form-default-failed");
expect(fake.idempotencyKey.update).not.toHaveBeenCalled();
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it("never completes the marker or activates when the portal scaffold cannot be created", async () => {
const fake = buildFakeTx();
fake.portal.upsert.mockRejectedValueOnce(new Error("portal-subdomain-conflict"));
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).rejects.toThrow("portal-subdomain-conflict");
expect(fake.idempotencyKey.update).not.toHaveBeenCalled();
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it("never completes the marker or activates when the signup billing preference cannot be persisted", async () => {
const fake = buildFakeTx();
fake.tenantProductConfiguration.upsert.mockRejectedValueOnce(new Error("preference-write-failed"));
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
billingPreference: {
selectedSubscriptionPriceId: "price_swarm_monthly",
selectedOfficeSeatQuantity: 5,
selectedFieldSeatQuantity: 15,
},
})
).rejects.toThrow("preference-write-failed");
expect(fake.idempotencyKey.update).not.toHaveBeenCalled();
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it("fails closed when the global checklist does not have the exact canonical step identities", async () => {
const fake = buildFakeTx();
fake.onboarding.findUnique.mockResolvedValueOnce({
id: SHK_FIRST_STEPS_CHECKLIST_ID,
title: SHK_FIRST_STEPS_CHECKLIST_CODE,
type: "page",
realtime: false,
active: true,
canBeDismissed: true,
height: null,
steps: SHK_FIRST_STEPS.map((step, index) => (index === 0 ? { ...step, id: "generated-duplicate-step" } : { ...step })),
});
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.onboardingSession.upsert).not.toHaveBeenCalled();
expect(fake.idempotencyKey.update).not.toHaveBeenCalled();
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it.each([
["type", "modal"],
["realtime", true],
["canBeDismissed", false],
["height", "md"],
] as const)("fails closed when the global checklist %s drifts", async (field, value) => {
const fake = buildFakeTx();
fake.onboarding.findUnique.mockResolvedValueOnce({
id: SHK_FIRST_STEPS_CHECKLIST_ID,
title: SHK_FIRST_STEPS_CHECKLIST_CODE,
type: "page",
realtime: false,
active: true,
canBeDismissed: true,
height: null,
steps: SHK_FIRST_STEPS.map((step) => ({ ...step })),
[field]: value,
});
await expect(
bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.onboardingSession.upsert).not.toHaveBeenCalled();
expect(fake.idempotencyKey.update).not.toHaveBeenCalled();
expect(fake.tenant.update).not.toHaveBeenCalled();
});
it("uses the permanent tenant-scoped marker contract", async () => {
const fake = buildFakeTx();
await bootstrapShkV2TenantWithTx(asTenantTx(fake), {
tenantId: "tenant_1",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
userId: "user_1",
attemptId: "attempt_1",
t: translate,
configDigest: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
preparedFormTemplates,
});
expect(fake.idempotencyKey.upsert).toHaveBeenCalledWith(
expect.objectContaining({
where: {
idempotency_key_partition_scope_key: {
partitionKey: "tenant:tenant_1",
scope: SHK_V2_BOOTSTRAP_SCOPE,
key: "shk-v2",
},
},
create: expect.objectContaining({
tenantId: "tenant_1",
requestHash: expect.stringMatching(/^[a-f0-9]{64}$/),
}),
})
);
});
});
describe("tenant bootstrap entry functions", () => {
it("derives a domain-separated tenant id and replays the same completed creation request", async () => {
const owner = userRow({ defaultTenantId: null });
const firstTx = buildFakeTx();
let firstTenantId = "";
dependencyMocks.createTenant.mockImplementationOnce(async (input: { tenantId: string; setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
firstTenantId = input.tenantId;
await input.setup(tenantRow({ id: input.tenantId }), asTenantTx(firstTx));
return tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
});
const first = await runWithRlsContext({ userId: owner.id }, () =>
createOwnedTenantWithShkDefaults({
user: owner,
name: "Heizkraft GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
);
expect(firstTenantId).toBe(deriveTenantCreationId(owner.id, CREATION_REQUEST_KEY));
expect(firstTenantId).not.toBe(CREATION_REQUEST_KEY);
expect(firstTenantId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
expect(first.replayed).toBe(false);
expect(dependencyMocks.createTenant).toHaveBeenNthCalledWith(1, expect.objectContaining({ emitCreatedHook: false }));
const completedBody = firstTx.idempotencyKey.update.mock.calls[0]?.[0].data.responseBody;
expect(firstTx.idempotencyKey.upsert.mock.calls[0]?.[0].create).toMatchObject({
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseBody: {
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash: expect.stringMatching(/^[a-f0-9]{64}$/),
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
},
},
});
const storedMarker = {
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: completedBody,
};
const replayTx = buildFakeTx({ responseStatus: 201, responseBody: completedBody }, storedMarker);
dependencyMocks.createTenant.mockImplementationOnce(
async (input: {
tenantId: string;
validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void>;
setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<void>;
}) => {
const existing = tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
await input.validateExistingReplay(existing, asTenantTx(replayTx));
await input.setup(existing, asTenantTx(replayTx));
return existing;
}
);
const replay = await runWithRlsContext({ userId: owner.id }, () =>
createOwnedTenantWithShkDefaults({
user: owner,
name: "Heizkraft GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
);
expect(replay).toMatchObject({ tenant: { id: firstTenantId }, replayed: true });
expect(replayTx.calls).toEqual(["membership.findOwner", "marker.find", "marker.acquire"]);
expect(dependencyMocks.publishTenantInvalidation).toHaveBeenCalledTimes(2);
expect(dependencyMocks.emitTenantCreatedHook).toHaveBeenCalledTimes(2);
expect(dependencyMocks.emitTenantCreatedHook).toHaveBeenLastCalledWith(expect.objectContaining({ id: firstTenantId }), owner.id);
});
it("fails closed for a changed creation payload or another authenticated user", async () => {
const owner = userRow({ defaultTenantId: null });
const firstTx = buildFakeTx();
dependencyMocks.createTenant.mockImplementationOnce(async (input: { tenantId: string; setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
await input.setup(tenantRow({ id: input.tenantId }), asTenantTx(firstTx));
return tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
});
await runWithRlsContext({ userId: owner.id }, () =>
createOwnedTenantWithShkDefaults({
user: owner,
name: "Heizkraft GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
);
const completedBody = firstTx.idempotencyKey.update.mock.calls[0]?.[0].data.responseBody;
const replayTx = buildFakeTx({}, { requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST, responseStatus: 201, responseBody: completedBody });
dependencyMocks.createTenant.mockImplementationOnce(
async (input: { tenantId: string; validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
await input.validateExistingReplay(tenantRow({ id: input.tenantId, active: true, deactivatedReason: null }), asTenantTx(replayTx));
return tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
}
);
await expect(
runWithRlsContext({ userId: owner.id }, () =>
createOwnedTenantWithShkDefaults({
user: owner,
name: "Changed GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
dependencyMocks.createTenant.mockClear();
await expect(
runWithRlsContext({ userId: "user_foreign" }, () =>
createOwnedTenantWithShkDefaults({
user: owner,
name: "Heizkraft GmbH",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.createTenant).not.toHaveBeenCalled();
});
it("classifies only a completed marker with the exact owner payload as a replay", async () => {
const tenantId = deriveTenantCreationId("user_1", CREATION_REQUEST_KEY);
const payloadHash = createHash("sha256")
.update(
JSON.stringify({
contract: "tenant-creation-request/v1",
userId: "user_1",
key: CREATION_REQUEST_KEY,
name: "Heizkraft GmbH",
slug: "heizkraft",
})
)
.digest("hex");
const marker = {
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: {
state: "completed",
templateKey: SHK_V2_TENANT_BOOTSTRAP_CONFIG.templateKey,
schemaVersion: SHK_V2_TENANT_BOOTSTRAP_CONFIG.schemaVersion,
completedAt: FIXED_NOW.toISOString(),
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash,
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
},
},
};
const fake = buildFakeTx({}, marker);
fake.tenant.findUnique.mockResolvedValue(tenantRow({ id: tenantId, active: true, deactivatedReason: null }));
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
isExactOwnedTenantCreationReplay({
userId: "user_1",
name: "Heizkraft GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
})
)
).resolves.toBe(true);
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
isExactOwnedTenantCreationReplay({
userId: "user_1",
name: "Changed GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
})
)
).resolves.toBe(false);
dependencyMocks.dbTransaction.mockClear();
await expect(
runWithRlsContext({ userId: "user_foreign" }, () =>
isExactOwnedTenantCreationReplay({
userId: "user_1",
name: "Heizkraft GmbH",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
})
)
).resolves.toBe(false);
expect(dependencyMocks.dbTransaction).not.toHaveBeenCalled();
});
it("replays an exact signup creation request with deterministic identities and no password material in its marker", async () => {
const email = " OWNER@Heizkraft.Example ";
const normalizedEmail = "owner@heizkraft.example";
const password = "correct horse battery staple";
const expectedUserId = deriveSignupUserId(normalizedEmail, CREATION_REQUEST_KEY);
const expectedTenantId = deriveSignupTenantId(normalizedEmail, CREATION_REQUEST_KEY);
const createdUser = userRow({
id: expectedUserId,
email: normalizedEmail,
defaultTenantId: expectedTenantId,
active: true,
});
const firstTx = buildFakeTx();
firstTx.user.create.mockImplementationOnce((args: { data: Record<string, unknown> }) =>
Promise.resolve(userRow({ ...(args.data as Partial<User>), createdAt: FIXED_NOW, updatedAt: FIXED_NOW }))
);
firstTx.tenant.update.mockResolvedValueOnce(tenantRow({ id: expectedTenantId, active: true, deactivatedReason: null }));
dependencyMocks.createTenant.mockImplementationOnce(
async (input: { tenantId: string; setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<Tenant | undefined> }) => {
expect(input.tenantId).toBe(expectedTenantId);
const pendingTenant = tenantRow({ id: input.tenantId });
return (await input.setup(pendingTenant, asTenantTx(firstTx))) ?? pendingTenant;
}
);
const first = await createSignupTenantWithShkDefaults({
email,
password,
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
billingPreference: {
selectedSubscriptionPriceId: "price_swarm_monthly",
selectedOfficeSeatQuantity: 5,
selectedFieldSeatQuantity: 15,
},
t: translate,
});
expect(first).toMatchObject({
tenant: { id: expectedTenantId, active: true },
user: { id: expectedUserId, email: normalizedEmail, defaultTenantId: expectedTenantId },
replayed: false,
});
expect(firstTx.user.create).toHaveBeenCalledWith({
data: expect.objectContaining({
id: expectedUserId,
email: normalizedEmail,
passwordHash: "prepared_hash",
defaultTenantId: expectedTenantId,
}),
});
const completedBody = firstTx.idempotencyKey.update.mock.calls[0]?.[0].data.responseBody;
expect(completedBody).toMatchObject({
state: "completed",
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash: expect.stringMatching(/^[a-f0-9]{64}$/),
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
signup: { normalizedEmail, userId: expectedUserId },
},
});
expect(JSON.stringify(completedBody)).not.toContain(password);
expect(JSON.stringify(completedBody)).not.toContain("prepared_hash");
expect(firstTx.tenantProductConfiguration.upsert).toHaveBeenCalledWith({
where: { tenantId: expectedTenantId },
create: {
tenantId: expectedTenantId,
signupSubscriptionPriceId: "price_swarm_monthly",
signupOfficeSeatQuantity: 5,
signupFieldSeatQuantity: 15,
},
update: {
signupSubscriptionPriceId: "price_swarm_monthly",
signupOfficeSeatQuantity: 5,
signupFieldSeatQuantity: 15,
},
});
expect(firstTx.calls.indexOf("billingPreference.upsert")).toBeLessThan(firstTx.calls.indexOf("marker.complete"));
expect(dependencyMocks.resolveUserEmailRlsIdentity).toHaveBeenCalledWith(normalizedEmail);
expect(dependencyMocks.hashPassword).toHaveBeenCalledTimes(1);
expect(dependencyMocks.verifyPassword).not.toHaveBeenCalled();
const replayTx = buildFakeTx(
{},
{
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: completedBody,
}
);
replayTx.$queryRaw.mockResolvedValue([createdUser]);
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.hashPassword.mockClear();
dependencyMocks.verifyPassword.mockClear();
const replayOrder: string[] = [];
dependencyMocks.dbUserFindUnique.mockImplementationOnce(async (args: { where: { id: string }; select: { passwordHash: boolean } }) => {
replayOrder.push("password.read");
expect(args).toEqual({ where: { id: expectedUserId }, select: { passwordHash: true } });
expect(getRlsExecutionContext()).toMatchObject({ userId: expectedUserId });
expect(getRlsExecutionContext()?.tenantId).toBeUndefined();
expect(getRlsExecutionContext()?.transaction).toBeUndefined();
return { passwordHash: "hash" };
});
dependencyMocks.verifyPassword.mockImplementationOnce(async () => {
replayOrder.push("password.verify");
expect(getRlsExecutionContext()).toMatchObject({ userId: expectedUserId });
expect(getRlsExecutionContext()?.transaction).toBeUndefined();
return { valid: true };
});
dependencyMocks.createTenant.mockImplementationOnce(
async (input: {
tenantId: string;
validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void>;
setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<Tenant | undefined>;
}) => {
replayOrder.push("transaction.start");
const existingTenant = tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
await input.validateExistingReplay(existingTenant, asTenantTx(replayTx));
const result = (await input.setup(existingTenant, asTenantTx(replayTx))) ?? existingTenant;
replayOrder.push("transaction.commit");
return result;
}
);
const replay = await createSignupTenantWithShkDefaults({
email,
password,
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
billingPreference: {
selectedSubscriptionPriceId: "price_swarm_monthly",
selectedOfficeSeatQuantity: 5,
selectedFieldSeatQuantity: 15,
},
t: translate,
});
expect(replay).toMatchObject({
tenant: { id: expectedTenantId },
user: { id: expectedUserId, email: normalizedEmail },
replayed: true,
});
expect(replayTx.user.create).not.toHaveBeenCalled();
expect(replayTx.idempotencyKey.upsert).not.toHaveBeenCalled();
expect(replayTx.tenantProductConfiguration.findUnique).toHaveBeenCalledWith({
where: { tenantId: expectedTenantId },
select: {
signupSubscriptionPriceId: true,
signupOfficeSeatQuantity: true,
signupFieldSeatQuantity: true,
},
});
expect(replayTx.$queryRaw).toHaveBeenCalledOnce();
expect(dependencyMocks.hashPassword).not.toHaveBeenCalled();
expect(replayOrder).toEqual(["password.read", "password.verify", "transaction.start", "transaction.commit"]);
expect(dependencyMocks.verifyPassword).toHaveBeenCalledTimes(1);
expect(dependencyMocks.verifyPassword).toHaveBeenCalledWith(password, "hash");
expect(dependencyMocks.findRegistrationBillingPreferenceCapability).not.toHaveBeenCalled();
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.createTenant.mockClear();
dependencyMocks.hashPassword.mockClear();
dependencyMocks.verifyPassword.mockClear();
dependencyMocks.verifyPassword.mockResolvedValueOnce({ valid: false });
await expect(
createSignupTenantWithShkDefaults({
email,
password: "wrong password",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(dependencyMocks.hashPassword).not.toHaveBeenCalled();
expect(dependencyMocks.verifyPassword).toHaveBeenCalledTimes(1);
expect(dependencyMocks.createTenant).not.toHaveBeenCalled();
});
it("replays a completed v1 signup after the v2 deploy only when its registration-bound billing preference matches", async () => {
const normalizedEmail = "owner@heizkraft.example";
const password = "correct horse battery staple";
const expectedUserId = deriveSignupUserId(normalizedEmail, CREATION_REQUEST_KEY);
const expectedTenantId = deriveSignupTenantId(normalizedEmail, CREATION_REQUEST_KEY);
const billingPreference = {
selectedSubscriptionPriceId: "price_swarm_monthly",
selectedOfficeSeatQuantity: 5,
selectedFieldSeatQuantity: 15,
} as const;
const payloadHash = createHash("sha256")
.update(
JSON.stringify({
contract: "signup-creation-request/v1",
key: CREATION_REQUEST_KEY,
normalizedEmail,
company: "Heizkraft GmbH",
firstName: "Mara",
lastName: "König",
avatarURL: null,
locale: "de",
slug: "heizkraft",
})
)
.digest("hex");
const replayTx = buildFakeTx(
{},
{
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: {
state: "completed",
templateKey: SHK_V2_TENANT_BOOTSTRAP_CONFIG.templateKey,
schemaVersion: SHK_V2_TENANT_BOOTSTRAP_CONFIG.schemaVersion,
completedAt: FIXED_NOW.toISOString(),
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash,
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
signup: { normalizedEmail, userId: expectedUserId },
},
},
}
);
replayTx.$queryRaw.mockResolvedValueOnce([
userRow({ id: expectedUserId, email: normalizedEmail, defaultTenantId: expectedTenantId, active: true }),
]);
replayTx.tenantProductConfiguration.findUnique.mockResolvedValueOnce(null);
dependencyMocks.findRegistrationBillingPreferenceCapability.mockResolvedValueOnce(billingPreference);
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.createTenant.mockImplementationOnce(
async (input: { tenantId: string; validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
const existingTenant = tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
await input.validateExistingReplay(existingTenant, asTenantTx(replayTx));
return existingTenant;
}
);
await expect(
createSignupTenantWithShkDefaults({
email: normalizedEmail,
password,
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
billingPreference,
t: translate,
})
).resolves.toMatchObject({ tenant: { id: expectedTenantId }, user: { id: expectedUserId }, replayed: true });
expect(dependencyMocks.findRegistrationBillingPreferenceCapability).toHaveBeenCalledWith(
expectedTenantId,
expectedUserId,
replayTx
);
expect(replayTx.idempotencyKey.update).not.toHaveBeenCalled();
expect(replayTx.tenantProductConfiguration.upsert).not.toHaveBeenCalled();
});
it("fails closed when a completed v1 signup receives different v2 billing preferences", async () => {
const normalizedEmail = "owner@heizkraft.example";
const expectedUserId = deriveSignupUserId(normalizedEmail, CREATION_REQUEST_KEY);
const expectedTenantId = deriveSignupTenantId(normalizedEmail, CREATION_REQUEST_KEY);
const payloadHash = createHash("sha256")
.update(
JSON.stringify({
contract: "signup-creation-request/v1",
key: CREATION_REQUEST_KEY,
normalizedEmail,
company: "Heizkraft GmbH",
firstName: "Mara",
lastName: "König",
avatarURL: null,
locale: "de",
slug: "heizkraft",
})
)
.digest("hex");
const replayTx = buildFakeTx(
{},
{
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: {
state: "completed",
templateKey: SHK_V2_TENANT_BOOTSTRAP_CONFIG.templateKey,
schemaVersion: SHK_V2_TENANT_BOOTSTRAP_CONFIG.schemaVersion,
completedAt: FIXED_NOW.toISOString(),
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash,
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
signup: { normalizedEmail, userId: expectedUserId },
},
},
}
);
replayTx.$queryRaw.mockResolvedValueOnce([
userRow({ id: expectedUserId, email: normalizedEmail, defaultTenantId: expectedTenantId, active: true }),
]);
replayTx.tenantProductConfiguration.findUnique.mockResolvedValueOnce(null);
dependencyMocks.findRegistrationBillingPreferenceCapability.mockResolvedValueOnce({
selectedSubscriptionPriceId: "price_swarm_monthly",
selectedOfficeSeatQuantity: 5,
selectedFieldSeatQuantity: 15,
});
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.createTenant.mockImplementationOnce(
async (input: { tenantId: string; validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
const existingTenant = tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
await input.validateExistingReplay(existingTenant, asTenantTx(replayTx));
return existingTenant;
}
);
await expect(
createSignupTenantWithShkDefaults({
email: normalizedEmail,
password: "correct horse battery staple",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
billingPreference: {
selectedSubscriptionPriceId: "price_colony_monthly",
selectedOfficeSeatQuantity: 10,
selectedFieldSeatQuantity: 30,
},
t: translate,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(dependencyMocks.findRegistrationBillingPreferenceCapability).toHaveBeenCalledOnce();
expect(replayTx.idempotencyKey.update).not.toHaveBeenCalled();
expect(replayTx.tenantProductConfiguration.upsert).not.toHaveBeenCalled();
});
it("fails closed when the password hash changes after verification but before the replay row lock", async () => {
const normalizedEmail = "owner@heizkraft.example";
const password = "correct horse battery staple";
const expectedUserId = deriveSignupUserId(normalizedEmail, CREATION_REQUEST_KEY);
const expectedTenantId = deriveSignupTenantId(normalizedEmail, CREATION_REQUEST_KEY);
const input = {
email: normalizedEmail,
password,
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
} as const;
const payloadHash = createHash("sha256")
.update(
JSON.stringify({
contract: "signup-creation-request/v2",
key: CREATION_REQUEST_KEY,
normalizedEmail,
company: input.company,
firstName: input.firstName,
lastName: input.lastName,
avatarURL: null,
locale: input.locale,
slug: input.slug,
billingPreference: null,
})
)
.digest("hex");
const replayTx = buildFakeTx(
{},
{
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: {
state: "completed",
templateKey: SHK_V2_TENANT_BOOTSTRAP_CONFIG.templateKey,
schemaVersion: SHK_V2_TENANT_BOOTSTRAP_CONFIG.schemaVersion,
completedAt: FIXED_NOW.toISOString(),
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash,
tenantName: input.company,
tenantSlug: input.slug,
signup: { normalizedEmail, userId: expectedUserId },
},
},
}
);
replayTx.$queryRaw.mockResolvedValueOnce([
userRow({
id: expectedUserId,
email: normalizedEmail,
passwordHash: "rotated_hash",
defaultTenantId: expectedTenantId,
active: true,
}),
]);
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
const order: string[] = [];
dependencyMocks.dbUserFindUnique.mockImplementationOnce(async () => {
order.push("password.read");
return { passwordHash: "verified_hash" };
});
dependencyMocks.verifyPassword.mockImplementationOnce(async () => {
order.push("password.verify");
return { valid: true };
});
dependencyMocks.createTenant.mockImplementationOnce(
async (createInput: { tenantId: string; validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
order.push("transaction.start");
await createInput.validateExistingReplay(tenantRow({ id: createInput.tenantId, active: true, deactivatedReason: null }), asTenantTx(replayTx));
order.push("transaction.commit");
return tenantRow({ id: createInput.tenantId, active: true, deactivatedReason: null });
}
);
await expect(createSignupTenantWithShkDefaults(input)).rejects.toMatchObject<CatalogError>({
code: foundationErrors.idempotencyConflict.code,
});
expect(order).toEqual(["password.read", "password.verify", "transaction.start"]);
expect(dependencyMocks.verifyPassword).toHaveBeenCalledWith(password, "verified_hash");
expect(replayTx.$queryRaw).toHaveBeenCalledOnce();
expect(replayTx.tenantUser.findFirst).toHaveBeenCalledOnce();
expect(replayTx.idempotencyKey.findUnique).toHaveBeenCalledOnce();
});
it("fails closed when a signup replay changes its bound payload or creation key", async () => {
const normalizedEmail = "owner@heizkraft.example";
const expectedUserId = deriveSignupUserId(normalizedEmail, CREATION_REQUEST_KEY);
const expectedTenantId = deriveSignupTenantId(normalizedEmail, CREATION_REQUEST_KEY);
const markerBody = {
state: "completed",
templateKey: SHK_V2_TENANT_BOOTSTRAP_CONFIG.templateKey,
schemaVersion: SHK_V2_TENANT_BOOTSTRAP_CONFIG.schemaVersion,
completedAt: FIXED_NOW.toISOString(),
creationRequest: {
key: CREATION_REQUEST_KEY,
payloadHash: "intentionally-not-the-changed-payload-hash",
tenantName: "Heizkraft GmbH",
tenantSlug: "heizkraft",
signup: { normalizedEmail, userId: expectedUserId },
},
};
const replayTx = buildFakeTx(
{},
{
requestHash: SHK_V2_TENANT_BOOTSTRAP_CONFIG_DIGEST,
responseStatus: 201,
responseBody: markerBody,
}
);
replayTx.$queryRaw.mockResolvedValueOnce([userRow({ id: expectedUserId, email: normalizedEmail, defaultTenantId: expectedTenantId, active: true })]);
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.createTenant.mockImplementationOnce(
async (input: { tenantId: string; validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
await input.validateExistingReplay(tenantRow({ id: input.tenantId, active: true, deactivatedReason: null }), asTenantTx(replayTx));
return tenantRow({ id: input.tenantId, active: true, deactivatedReason: null });
}
);
await expect(
createSignupTenantWithShkDefaults({
email: normalizedEmail,
password: "password",
firstName: "Changed",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
slug: "heizkraft",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(dependencyMocks.hashPassword).not.toHaveBeenCalled();
expect(dependencyMocks.verifyPassword).toHaveBeenCalledTimes(1);
expect(dependencyMocks.verifyPassword).toHaveBeenCalledWith("password", "hash");
const anotherKey = "b79f4743-b5ee-48df-9287-10f24b2aedbf";
expect(deriveSignupTenantId(normalizedEmail, anotherKey)).not.toBe(expectedTenantId);
expect(deriveSignupUserId(normalizedEmail, anotherKey)).not.toBe(expectedUserId);
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.createTenant.mockClear();
dependencyMocks.hashPassword.mockClear();
dependencyMocks.verifyPassword.mockClear();
await expect(
createSignupTenantWithShkDefaults({
email: normalizedEmail,
password: "password",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
creationRequestKey: anotherKey,
t: translate,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(dependencyMocks.createTenant).not.toHaveBeenCalled();
expect(dependencyMocks.hashPassword).not.toHaveBeenCalled();
expect(dependencyMocks.verifyPassword).not.toHaveBeenCalled();
});
it("never creates a user without a fresh hash when only the expected identity exists", async () => {
const normalizedEmail = "owner@heizkraft.example";
const expectedUserId = deriveSignupUserId(normalizedEmail, CREATION_REQUEST_KEY);
const fake = buildFakeTx();
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce({ resourceId: expectedUserId, userId: expectedUserId });
dependencyMocks.createTenant.mockImplementationOnce(async (input: { setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
await input.setup(tenantRow({ id: deriveSignupTenantId(normalizedEmail, CREATION_REQUEST_KEY) }), asTenantTx(fake));
return tenantRow();
});
await expect(
createSignupTenantWithShkDefaults({
email: normalizedEmail,
password: "correct horse battery staple",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(dependencyMocks.hashPassword).not.toHaveBeenCalled();
expect(dependencyMocks.verifyPassword).toHaveBeenCalledTimes(1);
expect(dependencyMocks.verifyPassword).toHaveBeenCalledWith("correct horse battery staple", "hash");
expect(fake.user.create).not.toHaveBeenCalled();
});
it("fails closed when a new-signup identity race reaches a unique constraint", async () => {
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce(null);
dependencyMocks.createTenant.mockRejectedValueOnce({ code: "P2002" });
await expect(
createSignupTenantWithShkDefaults({
email: "owner@heizkraft.example",
password: "correct horse battery staple",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
expect(dependencyMocks.hashPassword).toHaveBeenCalledTimes(1);
expect(dependencyMocks.verifyPassword).not.toHaveBeenCalled();
});
it("hashes before the transaction and emits the user hook only after commit", async () => {
const order: string[] = [];
const fake = buildFakeTx();
dependencyMocks.prepareForms.mockImplementation(() => {
order.push("forms.prepare");
return preparedFormTemplates;
});
dependencyMocks.hashPassword.mockImplementation(async () => {
order.push("hash");
return "prepared_hash";
});
dependencyMocks.createTenant.mockImplementation(async (input: { setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
order.push("transaction.start");
await input.setup(tenantRow(), asTenantTx(fake));
order.push("transaction.commit");
return tenantRow({ active: true, deactivatedReason: null });
});
dependencyMocks.emitUserCreatedHook.mockImplementation(async () => {
order.push("user.hook");
});
dependencyMocks.emitTenantCreatedHook.mockImplementation(async () => {
order.push("tenant.hook");
});
dependencyMocks.invalidateUserSnapshot.mockImplementation(async () => {
order.push("user-cache.invalidate");
});
dependencyMocks.publishTenantInvalidation.mockImplementation(async () => {
order.push("tenant-cache.invalidate");
});
const result = await createSignupTenantWithShkDefaults({
email: "owner@heizkraft.example",
password: "correct horse battery staple",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
locale: "de",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
});
expect(order).toEqual([
"forms.prepare",
"hash",
"transaction.start",
"transaction.commit",
"tenant-cache.invalidate",
"user-cache.invalidate",
"tenant.hook",
"user.hook",
]);
expect(result.tenant.active).toBe(true);
expect(dependencyMocks.createTenant).toHaveBeenCalledWith(
expect.objectContaining({ active: false, deactivatedReason: TENANT_PENDING_OWNER_REASON, rlsUserId: expect.any(String), emitCreatedHook: false })
);
expect(fake.user.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ active: true }) }));
});
it("creates and exactly replays an ownerless reservation without defaults or hooks", async () => {
const reservationRequestKey = "41adac34-7b0d-47f0-9bb5-74dd67104dcb";
const tenantId = deriveTenantReservationId("operator_1", reservationRequestKey);
const firstTx = buildFakeTx();
dependencyMocks.createTenant.mockImplementationOnce(
async (input: { tenantId: string; setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<Tenant> }) => {
expect(input.tenantId).toBe(tenantId);
const reserved = tenantRow({ id: tenantId });
return input.setup(reserved, asTenantTx(firstTx));
}
);
const first = await runWithRlsContext({ userId: "operator_1" }, () =>
reserveTenantWithoutOwner({
name: "Heizkraft GmbH",
operatorUserId: "operator_1",
reservationRequestKey,
ownerInvitation: OWNER_INVITATION_DRAFT,
})
);
expect(first.id).toBe(tenantId);
expect(dependencyMocks.createTenant).toHaveBeenNthCalledWith(
1,
expect.objectContaining({
tenantId,
name: "Heizkraft GmbH",
slug: undefined,
active: false,
deactivatedReason: TENANT_PENDING_OWNER_REASON,
rlsUserId: "operator_1",
emitCreatedHook: false,
setup: expect.any(Function),
validateExistingReplay: expect.any(Function),
})
);
const firstMarker = firstTx.idempotencyKey.upsert.mock.calls[0]?.[0].create;
expect(firstMarker).toMatchObject({
tenantId,
partitionKey: `tenant:${tenantId}`,
scope: "tenant-reservation",
key: reservationRequestKey,
requestHash: expect.stringMatching(/^[a-f0-9]{64}$/),
responseStatus: 201,
responseBody: { state: "reserved", tenantName: "Heizkraft GmbH", tenantSlug: "heizkraft" },
});
expect(dependencyMocks.issueReservedOwnerInvitationWithTx).toHaveBeenCalledWith(firstTx, {
tenantId,
...OWNER_INVITATION_DRAFT,
});
const replayTx = buildFakeTx({}, firstMarker);
dependencyMocks.createTenant.mockImplementationOnce(
async (input: {
validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void>;
setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<Tenant>;
}) => {
const reserved = tenantRow({ id: tenantId });
await input.validateExistingReplay(reserved, asTenantTx(replayTx));
return input.setup(reserved, asTenantTx(replayTx));
}
);
await expect(
runWithRlsContext({ userId: "operator_1" }, () =>
reserveTenantWithoutOwner({
name: "Heizkraft GmbH",
operatorUserId: "operator_1",
reservationRequestKey,
ownerInvitation: OWNER_INVITATION_DRAFT,
})
)
).resolves.toMatchObject({ id: tenantId, active: false, deactivatedReason: TENANT_PENDING_OWNER_REASON });
const claimedTenant = tenantRow({ id: tenantId, active: true, deactivatedReason: null });
const claimedReplayTx = buildFakeTx({}, firstMarker);
const issuanceCallsBeforeClaimedReplay = dependencyMocks.issueReservedOwnerInvitationWithTx.mock.calls.length;
dependencyMocks.createTenant.mockImplementationOnce(
async (input: {
validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void>;
setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<Tenant>;
}) => {
await input.validateExistingReplay(claimedTenant, asTenantTx(claimedReplayTx));
return input.setup(claimedTenant, asTenantTx(claimedReplayTx));
}
);
await expect(
runWithRlsContext({ userId: "operator_1" }, () =>
reserveTenantWithoutOwner({
name: "Heizkraft GmbH",
operatorUserId: "operator_1",
reservationRequestKey,
ownerInvitation: OWNER_INVITATION_DRAFT,
})
)
).resolves.toMatchObject({ id: tenantId, active: true, deactivatedReason: null });
expect(dependencyMocks.issueReservedOwnerInvitationWithTx).toHaveBeenCalledTimes(issuanceCallsBeforeClaimedReplay);
dependencyMocks.createTenant.mockImplementationOnce(async (input: { validateExistingReplay: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
const reserved = tenantRow({ id: tenantId });
await input.validateExistingReplay(reserved, asTenantTx(replayTx));
return reserved;
});
await expect(
runWithRlsContext({ userId: "operator_1" }, () =>
reserveTenantWithoutOwner({
name: "Changed GmbH",
operatorUserId: "operator_1",
reservationRequestKey,
ownerInvitation: OWNER_INVITATION_DRAFT,
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.idempotencyConflict.code });
dependencyMocks.createTenant.mockClear();
await expect(
runWithRlsContext({ userId: "operator_foreign" }, () =>
reserveTenantWithoutOwner({
name: "Heizkraft GmbH",
operatorUserId: "operator_1",
reservationRequestKey,
ownerInvitation: OWNER_INVITATION_DRAFT,
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.createTenant).not.toHaveBeenCalled();
expect(dependencyMocks.seedForms).not.toHaveBeenCalled();
});
it("rejects an owner invitation capability bound to a different reservation key", async () => {
await expect(
runWithRlsContext({ userId: "operator_1" }, () =>
reserveTenantWithoutOwner({
name: "Heizkraft GmbH",
operatorUserId: "operator_1",
reservationRequestKey: OWNER_INVITATION_DRAFT.issuanceKey,
ownerInvitation: { ...OWNER_INVITATION_DRAFT, issuanceKey: "54a4218a-e068-43e5-9bf2-87b704191ce0" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.createTenant).not.toHaveBeenCalled();
expect(dependencyMocks.issueReservedOwnerInvitationWithTx).not.toHaveBeenCalled();
});
it("continues post-commit work when tenant cache invalidation fails", async () => {
const fake = buildFakeTx();
dependencyMocks.createTenant.mockImplementation(async (input: { setup: (tenant: Tenant, tx: TenantRlsClient) => Promise<void> }) => {
await input.setup(tenantRow(), asTenantTx(fake));
return tenantRow({ active: true, deactivatedReason: null });
});
dependencyMocks.publishTenantInvalidation.mockRejectedValueOnce(new Error("redis unavailable"));
await expect(
createSignupTenantWithShkDefaults({
email: "owner@heizkraft.example",
password: "correct horse battery staple",
firstName: "Mara",
lastName: "König",
company: "Heizkraft GmbH",
creationRequestKey: CREATION_REQUEST_KEY,
t: translate,
})
).resolves.toMatchObject({ tenant: { active: true }, user: { id: "user_1" } });
expect(dependencyMocks.publishTenantInvalidation).toHaveBeenCalledWith("tenant_1", "heizkraft");
expect(dependencyMocks.invalidateUserSnapshot).toHaveBeenCalledTimes(1);
expect(dependencyMocks.emitTenantCreatedHook).toHaveBeenCalledTimes(1);
expect(dependencyMocks.emitUserCreatedHook).toHaveBeenCalledTimes(1);
});
it("claims a reservation under tenant and owner RLS and emits the tenant hook after commit", async () => {
const fake = buildFakeTx();
const order: string[] = [];
dependencyMocks.getWorkspaceInviteByToken.mockImplementationOnce(async () => {
order.push("claim.authorize");
return {
id: "invite_1",
tenantId: "tenant_1",
email: " OWNER@HEIZKRAFT.EXAMPLE ",
type: TenantUserType.OWNER,
status: "pending",
acceptedByUserId: null,
};
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => {
expect(getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1", userId: "user_1" });
order.push("transaction.start");
const result = await callback(asTenantTx(fake));
order.push("transaction.commit");
return result;
});
dependencyMocks.emitTenantCreatedHook.mockImplementation(async () => {
order.push("tenant.hook");
});
dependencyMocks.invalidateUserSnapshot.mockImplementation(async () => {
order.push("cache.invalidate");
});
dependencyMocks.publishTenantInvalidation.mockImplementation(async () => {
order.push("tenant-cache.invalidate");
});
const result = await runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
);
expect(result).toMatchObject({ tenant: { id: "tenant_1", active: true }, user: { id: "user_1" }, replayed: false });
expect(order).toEqual(["transaction.start", "claim.authorize", "transaction.commit", "tenant-cache.invalidate", "cache.invalidate", "tenant.hook"]);
expect(dependencyMocks.acceptWorkspaceInvite).toHaveBeenCalledWith(
{ tenantId: "tenant_1", inviteId: "invite_1", token: "valid-token", acceptedByUserId: "user_1" },
expect.anything()
);
expect(dependencyMocks.emitTenantCreatedHook).toHaveBeenCalledWith(expect.objectContaining({ id: "tenant_1", active: true }), "user_1");
});
it("creates the new owner, binds and accepts the invite, and bootstraps the tenant in one transaction", async () => {
const fake = buildFakeTx();
fake.user.create.mockImplementationOnce(async (args: { data: Partial<User> }) => {
fake.calls.push("user.create");
return userRow(args.data);
});
dependencyMocks.resolveUserEmailRlsIdentity.mockResolvedValueOnce(null);
dependencyMocks.acceptWorkspaceInvite.mockImplementationOnce(async () => {
fake.calls.push("invitation.accept");
return {
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
acceptedByUserId: "user_1",
createdUserId: "user_1",
};
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
const result = await runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
createUser: {
id: "user_1",
email: "owner@heizkraft.example",
passwordHash: "$argon2id$prepared-password-hash",
firstName: "Mara",
lastName: "König",
locale: "de",
},
claim: {
kind: "workspace-invite",
inviteId: "invite_1",
token: "valid-token",
createdUserId: "user_1",
},
})
);
expect(result).toMatchObject({
tenant: { id: "tenant_1", active: true },
user: { id: "user_1", active: true, defaultTenantId: "tenant_1" },
replayed: false,
});
expect(fake.user.create).toHaveBeenCalledWith({
data: {
id: "user_1",
email: "owner@heizkraft.example",
passwordHash: "$argon2id$prepared-password-hash",
firstName: "Mara",
lastName: "König",
avatar: "",
phone: "",
active: true,
locale: "de",
defaultTenantId: null,
},
});
expect(fake.tenantUserInvitation.updateMany).toHaveBeenCalledWith({
where: {
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
pending: true,
status: "pending",
tokenHash: expect.stringMatching(/^[a-f0-9]{64}$/u),
createdUserId: null,
acceptedAt: null,
revokedAt: null,
OR: [{ expiresAt: null }, { expiresAt: { gt: expect.any(Date) } }],
},
data: { createdUserId: "user_1" },
});
expect(dependencyMocks.acceptWorkspaceInvite).toHaveBeenCalledWith(
{
tenantId: "tenant_1",
inviteId: "invite_1",
token: "valid-token",
acceptedByUserId: "user_1",
createdUserId: "user_1",
},
expect.anything()
);
expect(fake.calls.indexOf("user.create")).toBeLessThan(fake.calls.indexOf("invitation.bindCreatedUser"));
expect(fake.calls.indexOf("invitation.bindCreatedUser")).toBeLessThan(fake.calls.indexOf("invitation.accept"));
expect(fake.calls.indexOf("invitation.accept")).toBeLessThan(fake.calls.indexOf("tenant.activate"));
expect(fake.user.update).toHaveBeenCalledWith({ where: { id: "user_1" }, data: { defaultTenantId: "tenant_1" } });
expect(dependencyMocks.emitUserCreatedHook).not.toHaveBeenCalled();
});
it("records the accepting user only when the owner claim created that account", async () => {
const fake = buildFakeTx();
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "pending",
createdUserId: "user_1",
acceptedByUserId: null,
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: {
kind: "workspace-invite",
inviteId: "invite_1",
token: "valid-token",
createdUserId: "user_1",
},
})
);
expect(dependencyMocks.acceptWorkspaceInvite).toHaveBeenCalledWith(
{
tenantId: "tenant_1",
inviteId: "invite_1",
token: "valid-token",
acceptedByUserId: "user_1",
createdUserId: "user_1",
},
expect.anything()
);
});
it("rejects a created-user claim unless registration already bound the exact durable invite marker", async () => {
const fake = buildFakeTx();
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: {
kind: "workspace-invite",
inviteId: "invite_1",
token: "valid-token",
createdUserId: "user_1",
},
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenant.findUnique).not.toHaveBeenCalled();
expect(fake.tenantUser.upsert).not.toHaveBeenCalled();
});
it("rejects a reservation claim without a matching authenticated user context", async () => {
await expect(
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.dbTransaction).not.toHaveBeenCalled();
});
it("does not inspect or mutate a reservation when the claim capability is rejected", async () => {
const fake = buildFakeTx();
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce(null);
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "invalid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.user.findMany).not.toHaveBeenCalled();
expect(fake.tenant.findUnique).not.toHaveBeenCalled();
expect(fake.idempotencyKey.upsert).not.toHaveBeenCalled();
});
it("rejects a member invitation before owner provisioning", async () => {
const fake = buildFakeTx();
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.MEMBER,
status: "pending",
acceptedByUserId: null,
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.user.findMany).not.toHaveBeenCalled();
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenantUser.upsert).not.toHaveBeenCalled();
expect(fake.userRole.createMany).not.toHaveBeenCalled();
});
it("rejects an invitation for another email before owner provisioning", async () => {
const fake = buildFakeTx();
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "other@heizkraft.example",
type: TenantUserType.OWNER,
status: "pending",
acceptedByUserId: null,
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.user.findMany).toHaveBeenCalledWith({
where: { email: { equals: "other@heizkraft.example", mode: "insensitive" } },
select: { id: true },
orderBy: { id: "asc" },
take: 2,
});
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenantUser.upsert).not.toHaveBeenCalled();
expect(fake.userRole.createMany).not.toHaveBeenCalled();
});
it("rejects a case-insensitive email identity when more than one user row matches", async () => {
const fake = buildFakeTx();
fake.user.findMany.mockResolvedValueOnce([{ id: "user_1" }, { id: "case_variant_user" }]);
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.resolveUserEmailRlsIdentity).toHaveBeenCalledWith("owner@heizkraft.example", expect.anything());
expect(fake.$queryRaw).not.toHaveBeenCalled();
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenant.findUnique).not.toHaveBeenCalled();
});
it("replays an already accepted invitation for the same existing owner without a created-user marker", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
createdUserId: null,
acceptedByUserId: "user_1",
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).resolves.toMatchObject({ replayed: true, tenant: { id: "tenant_1" }, user: { id: "user_1" } });
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.user.findMany).toHaveBeenCalledWith({
where: { email: { equals: "owner@heizkraft.example", mode: "insensitive" } },
select: { id: true },
orderBy: { id: "asc" },
take: 2,
});
expect(dependencyMocks.publishTenantInvalidation).toHaveBeenCalledWith("tenant_1", "heizkraft");
expect(dependencyMocks.emitTenantCreatedHook).toHaveBeenCalledWith(expect.objectContaining({ id: "tenant_1" }), "user_1");
});
it("replays an already accepted invitation for the same newly created owner with the matching marker", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
createdUserId: "user_1",
acceptedByUserId: "user_1",
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: {
kind: "workspace-invite",
inviteId: "invite_1",
token: "valid-token",
createdUserId: "user_1",
},
})
)
).resolves.toMatchObject({ replayed: true, user: { id: "user_1" } });
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.user.update).not.toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ active: true }) }));
});
it("rejects an accepted owner replay after the user was administratively deactivated", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
fake.$queryRaw.mockResolvedValueOnce([userRow({ active: false })]);
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
createdUserId: "user_1",
acceptedByUserId: "user_1",
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: {
kind: "workspace-invite",
inviteId: "invite_1",
token: "valid-token",
createdUserId: "user_1",
},
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.user.update).not.toHaveBeenCalled();
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenant.findUnique).not.toHaveBeenCalled();
});
it("rejects an accepted invitation replay when its created-user marker is omitted", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
createdUserId: "user_1",
acceptedByUserId: "user_1",
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.tenant.findUnique).not.toHaveBeenCalled();
expect(fake.tenantUser.upsert).not.toHaveBeenCalled();
});
it("rejects an accepted invitation replay for a different authenticated owner", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "owner@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
createdUserId: null,
acceptedByUserId: "user_2",
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenant.findUnique).not.toHaveBeenCalled();
});
it("rejects an accepted invitation replay when its email no longer matches the owner", async () => {
const fake = buildFakeTx({ responseStatus: 201, responseBody: { state: "completed", completedAt: FIXED_NOW.toISOString() } });
dependencyMocks.getWorkspaceInviteByToken.mockResolvedValueOnce({
id: "invite_1",
tenantId: "tenant_1",
email: "other@heizkraft.example",
type: TenantUserType.OWNER,
status: "accepted",
acceptedByUserId: "user_1",
});
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(dependencyMocks.acceptWorkspaceInvite).not.toHaveBeenCalled();
expect(fake.tenantUser.upsert).not.toHaveBeenCalled();
expect(fake.userRole.createMany).not.toHaveBeenCalled();
});
it("rejects a claim when the reservation already has another member", async () => {
const fake = buildFakeTx();
fake.tenantUser.findMany.mockResolvedValueOnce([{ userId: "user_other", type: 0, status: 2 }]);
dependencyMocks.dbTransaction.mockImplementation(async (callback: (tx: TenantRlsClient) => Promise<unknown>) => callback(asTenantTx(fake)));
await expect(
runWithRlsContext({ userId: "user_1" }, () =>
claimReservedTenantWithShkDefaults({
tenantId: "tenant_1",
userId: "user_1",
t: translate,
claim: { kind: "workspace-invite", inviteId: "invite_1", token: "valid-token" },
})
)
).rejects.toMatchObject<CatalogError>({ code: foundationErrors.notFound.code });
expect(fake.idempotencyKey.upsert).not.toHaveBeenCalled();
expect(fake.tenant.update).not.toHaveBeenCalled();
});
});