// @vitest-environment node import { beforeEach, describe, expect, it, vi } from "vitest"; import { getRlsExecutionContext, runWithRlsContext, runWithRlsTransaction } from "@hivegrid/db/rls-context.server"; import { TenantUserJoined } from "~/application/enums/tenants/TenantUserJoined"; import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus"; import type { Tenant } from "@hivegrid/db/prisma-browser"; vi.mock("~/utils/db.server", () => ({ db: { tenant: { count: vi.fn(), create: vi.fn(), findFirst: vi.fn(), findMany: vi.fn(), findUnique: vi.fn(), findUniqueOrThrow: vi.fn(), update: vi.fn(), delete: vi.fn(), }, tenantUser: { count: vi.fn(), create: vi.fn(), delete: vi.fn(), deleteMany: vi.fn(), findFirst: vi.fn(), findFirstOrThrow: vi.fn(), findMany: vi.fn(), }, userRole: { deleteMany: vi.fn(), }, groupUser: { deleteMany: vi.fn(), }, $transaction: vi.fn(), }, dbRead: { tenant: { findMany: vi.fn(), }, }, })); vi.mock("../helpers/RowFiltersHelper", () => ({ default: { getFiltersCondition: vi.fn(), }, })); vi.mock("../cache.server", () => ({ cachified: vi.fn((options: { getFreshValue: () => unknown }) => options.getFreshValue()), clearCacheKey: vi.fn(), clearCacheKeyPrefix: vi.fn(), })); vi.mock("../services/tenantService", () => ({ normalizeTenantSlug: (value: string) => value .trim() .toLowerCase() .replace(/[^a-z0-9]+/g, "-") .replace(/^-|-$/g, ""), isReservedTenantSlug: (value: string) => value === "admin", })); vi.mock("./permissions/userRoles.db.server", () => ({ createUserRole: vi.fn(), })); vi.mock("./tenantSubscriptions.db.server", () => ({ createTenantSubscription: vi.fn(), })); vi.mock("~/modules/plugins/services/.server/pluginHookPublisher", () => ({ emitPluginHookFireAndForget: vi.fn(), })); import { db, dbRead } from "~/utils/db.server"; import RowFiltersHelper from "../helpers/RowFiltersHelper"; import { cachified, clearCacheKey, clearCacheKeyPrefix } from "../cache.server"; import { createUserRole } from "./permissions/userRoles.db.server"; import { createTenantSubscription } from "./tenantSubscriptions.db.server"; import { TENANT_SNAPSHOT_SAFETY_TTL_SECONDS } from "./tenant-cache.server"; import { emitPluginHookFireAndForget } from "~/modules/plugins/services/.server/pluginHookPublisher"; import { adminGetAllActiveTenantSimple, adminGetAllTenants, adminGetAllTenantsIdsAndNames, adminGetAllTenantsWithUsage, createTenant, createTenantUser, TenantSlugCollisionError, emitTenantCreatedHook, deleteTenant, deleteTenantUser, getAllTenantUsers, getMyTenants, getInvitationTenantIdentity, getTenant, getTenantByIdOrSlug, getTenantBySlug, getTenantMember, getTenantSessionIdentityForUser, getTenantSimple, getTenantUser, getTenantUserByIds, getTenantUserSimple, getTenantUserType, getTenantUsers, getTenantUsersCount, getTenantUsersInTenantIds, getTenantWithProfile, getTenantWithUsers, getTenantsInIds, requireTenant, updateTenant, updateTenantAnrede, updateTenantDeactivated, } from "./tenants.db.server"; const dbMock = vi.mocked(db); const dbReadMock = vi.mocked(dbRead); function adapterPgUniqueConstraintError( constraint: unknown, meta: Record = {}, originalMessage = "duplicate key value violates unique constraint" ): Error { return Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { modelName: "Tenant", ...meta, driverAdapterError: { name: "DriverAdapterError", cause: { originalCode: "23505", originalMessage, kind: "UniqueConstraintViolation", constraint, }, }, }, }); } describe("tenants db wrapper", () => { beforeEach(() => { vi.clearAllMocks(); vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) => options.getFreshValue()) as never); dbMock.$transaction.mockImplementation((async (operations: Promise[] | ((tx: typeof db) => Promise)) => { if (Array.isArray(operations)) { return await Promise.all(operations); } return await operations(db); }) as never); vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue(undefined); }); it("runs minimal tenant-scoped relation probes before paginating heavy hydration", async () => { const baseWhere = { name: { contains: "acme" } }; vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue(baseWhere as never); vi.mocked(dbMock.tenant.findMany) .mockResolvedValueOnce([{ id: "tenant_1" }, { id: "tenant_2" }, { id: "tenant_3" }] as never) .mockResolvedValueOnce([{ id: "tenant_3" }] as never); vi.mocked(dbMock.tenant.findFirst).mockImplementation(async ({ where }: { where: { id: string; OR: unknown[] } }) => { expect(getRlsExecutionContext()?.tenantId).toBe(where.id); expect(where.OR).toEqual([{ users: { some: { userId: "user_1" } } }]); return { id: where.id } as never; }); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce({ id: "tenant_2", users: [] } as never); const result = await adminGetAllTenantsWithUsage( { query: "", properties: [{ name: "userId", value: "user_1" }], } as never, { page: 2, pageSize: 1 } ); expect(dbMock.tenant.findMany).toHaveBeenNthCalledWith(1, { select: { id: true }, orderBy: { createdAt: "desc" } }); expect(dbMock.tenant.findMany).toHaveBeenNthCalledWith(2, { where: baseWhere, select: { id: true } }); expect(result.items).toEqual([expect.objectContaining({ id: "tenant_2" })]); expect(result.pagination).toEqual({ page: 2, pageSize: 1, totalItems: 3, totalPages: 3 }); expect(dbMock.tenant.findFirst).toHaveBeenCalledTimes(2); expect(dbMock.tenant.findUnique).toHaveBeenCalledTimes(1); expect(dbMock.tenant.count).not.toHaveBeenCalled(); }); it("paginates root tenant ids before tenant-scoped hydration when no relation filter is active", async () => { const rootWhere = { name: { contains: "acme" } }; vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue(rootWhere as never); vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_2" }, { id: "tenant_3" }] as never); vi.mocked(dbMock.tenant.count).mockResolvedValueOnce(12); vi.mocked(dbMock.tenant.findUnique).mockImplementation(async ({ where }: { where: { id: string } }) => { expect(getRlsExecutionContext()?.tenantId).toBe(where.id); return { id: where.id, users: [] } as never; }); const result = await adminGetAllTenantsWithUsage( { query: "", properties: [ { name: "name", value: "acme" }, { name: "userId", manual: true }, ], } as never, { page: 2, pageSize: 2 } ); expect(dbMock.tenant.findMany).toHaveBeenCalledWith({ skip: 2, take: 2, where: rootWhere, select: { id: true }, orderBy: { createdAt: "desc" }, }); expect(result.items.map((tenant) => tenant.id)).toEqual(["tenant_2", "tenant_3"]); expect(result.pagination).toEqual({ page: 2, pageSize: 2, totalItems: 12, totalPages: 6 }); const hydrationArgs = vi.mocked(dbMock.tenant.findUnique).mock.calls[0]?.[0]; expect(hydrationArgs).toMatchObject({ where: { id: "tenant_2" }, select: { users: { select: { user: { select: { email: true } } } }, _count: { select: { events: true } }, }, }); expect(hydrationArgs).not.toHaveProperty("include"); expect(JSON.stringify(hydrationArgs)).not.toMatch(/inboundAddresses|features|tiers/); }); it("uses unfiltered, unpaginated defaults when no admin list options are supplied", async () => { vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([] as never); vi.mocked(dbMock.tenant.count).mockResolvedValueOnce(0); await expect(adminGetAllTenantsWithUsage()).resolves.toEqual({ items: [], pagination: { page: 1, pageSize: 10, totalItems: 0, totalPages: 0 }, }); expect(dbMock.tenant.findMany).toHaveBeenCalledWith({ skip: undefined, take: undefined, where: {}, select: { id: true }, orderBy: { createdAt: "desc" }, }); expect(dbMock.tenant.count).toHaveBeenCalledWith({ where: {} }); }); it("uses read and write clients for the basic tenant listing helpers", async () => { vi.mocked(dbMock.tenant.findMany).mockResolvedValue([] as never); vi.mocked(dbReadMock.tenant.findMany).mockResolvedValue([] as never); await getTenantsInIds(["tenant_1", "tenant_2"]); await adminGetAllTenants(); await adminGetAllTenantsIdsAndNames(); await adminGetAllActiveTenantSimple(); expect(dbMock.tenant.findMany).toHaveBeenNthCalledWith(1, expect.objectContaining({ where: { id: { in: ["tenant_1", "tenant_2"] } } })); expect(dbMock.tenant.findMany).toHaveBeenNthCalledWith(2, { select: { id: true }, orderBy: { createdAt: "desc" }, }); expect(dbReadMock.tenant.findMany).toHaveBeenNthCalledWith(1, { select: { id: true, name: true, slug: true }, }); expect(dbReadMock.tenant.findMany).toHaveBeenNthCalledWith( 2, expect.objectContaining({ where: { active: true }, orderBy: { name: "asc" }, }) ); }); it("hydrates the complete admin tenant list inside each tenant RLS context", async () => { vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_2" }, { id: "tenant_1" }] as never); vi.mocked(dbMock.tenant.findUnique).mockImplementation(async ({ where }: { where: { id: string } }) => { expect(getRlsExecutionContext()).toEqual({ userId: "operator_1", tenantId: where.id }); return { id: where.id, users: [{ userId: `user_${where.id}` }], } as never; }); const result = await runWithRlsContext({ userId: "operator_1" }, () => adminGetAllTenants()); expect(result).toEqual([ expect.objectContaining({ id: "tenant_2", users: [{ userId: "user_tenant_2" }] }), expect.objectContaining({ id: "tenant_1", users: [{ userId: "user_tenant_1" }] }), ]); expect(dbMock.tenant.findUnique).toHaveBeenCalledTimes(2); expect(getRlsExecutionContext()).toBeNull(); }); it("wraps cached tenant identity lookups with stable cache keys", async () => { vi.mocked(dbMock.tenant.findUnique).mockResolvedValue({ id: "tenant_1" } as never); vi.mocked(dbMock.tenant.findFirst).mockResolvedValue({ id: "tenant_1" } as never); await getTenant("tenant_1"); await getTenantSimple("tenant_1"); await getTenantByIdOrSlug("acme"); expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenant:tenant_1" })); expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenantSimple:tenant_1" })); expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenantIdOrSlug:acme" })); expect(dbMock.tenant.findFirst).toHaveBeenCalledWith({ where: { OR: [{ id: "acme" }, { slug: "acme" }] }, include: { subscription: true }, }); }); it("queries direct tenant identity variants without cache wrappers", async () => { vi.mocked(dbMock.tenant.findUnique).mockResolvedValue({ id: "tenant_1" } as never); await getTenantBySlug("acme"); await getTenantWithProfile("tenant_1"); await getTenantWithUsers("tenant_1"); expect(dbMock.tenant.findUnique).toHaveBeenNthCalledWith(1, { where: { slug: "acme" } }); expect(dbMock.tenant.findUnique).toHaveBeenNthCalledWith(2, { where: { id: "tenant_1" } }); expect(dbMock.tenant.findUnique).toHaveBeenNthCalledWith(3, { where: { id: "tenant_1" }, include: { users: true } }); }); it("resolves route and login tenant identities only through the authenticated user's active membership", async () => { vi.mocked(dbMock.tenantUser.findFirst).mockImplementationOnce(async () => { expect(getRlsExecutionContext()).toMatchObject({ userId: "user_1" }); return { tenant: { id: "tenant_1", name: "Acme", slug: "acme", active: true, deactivatedReason: null }, } as never; }); await expect(getTenantSessionIdentityForUser({ userId: "user_1", tenant: "acme" })).resolves.toEqual({ id: "tenant_1", name: "Acme", slug: "acme", active: true, deactivatedReason: null, }); expect(dbMock.tenantUser.findFirst).toHaveBeenCalledWith({ where: { userId: "user_1", status: TenantUserStatus.ACTIVE, tenant: { OR: [{ id: "acme" }, { slug: "acme" }], active: true }, }, select: { tenant: { select: { id: true, name: true, slug: true, active: true, deactivatedReason: true } }, }, orderBy: { tenant: { name: "asc" } }, }); expect(cachified).not.toHaveBeenCalled(); expect(getRlsExecutionContext()).toBeNull(); }); it("rejects blank session identities and resolves an optional inactive tenant inside an existing user context", async () => { await expect(getTenantSessionIdentityForUser({ userId: " " })).resolves.toBeNull(); await expect(getTenantSessionIdentityForUser({ userId: "user_1", tenant: " " })).resolves.toBeNull(); expect(dbMock.tenantUser.findFirst).not.toHaveBeenCalled(); vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValueOnce(null); await expect( runWithRlsContext({ userId: "user_1" }, () => getTenantSessionIdentityForUser({ userId: "user_1", allowInactiveTenant: true })) ).resolves.toBeNull(); expect(dbMock.tenantUser.findFirst).toHaveBeenCalledWith({ where: { userId: "user_1", status: TenantUserStatus.ACTIVE, tenant: {}, }, select: { tenant: { select: { id: true, name: true, slug: true, active: true, deactivatedReason: true } }, }, orderBy: { tenant: { name: "asc" } }, }); expect(getRlsExecutionContext()).toBeNull(); }); it("fails closed for invitation tenant projections outside the verified capability context", async () => { await expect(getInvitationTenantIdentity("tenant_1")).resolves.toBeNull(); await expect(runWithRlsContext({ tenantId: "tenant_2" }, () => getInvitationTenantIdentity("tenant_1"))).resolves.toBeNull(); expect(dbMock.tenant.findFirst).not.toHaveBeenCalled(); vi.mocked(dbMock.tenant.findFirst).mockResolvedValueOnce({ id: "tenant_1", name: "Acme", slug: "acme", active: true, deactivatedReason: null, } as never); await expect(runWithRlsContext({ tenantId: "tenant_1" }, () => getInvitationTenantIdentity("tenant_1"))).resolves.toEqual({ id: "tenant_1", name: "Acme", slug: "acme", active: true, deactivatedReason: null, }); expect(dbMock.tenant.findFirst).toHaveBeenCalledWith({ where: { id: "tenant_1", active: true }, select: { id: true, name: true, slug: true, active: true, deactivatedReason: true }, }); }); it("reads only the explicitly allowed inactive reservation after the invite bound its tenant context", async () => { vi.mocked(dbMock.tenant.findFirst).mockResolvedValueOnce({ id: "tenant_1", name: "Acme", slug: "acme", active: false, deactivatedReason: "pending_owner", } as never); await expect( runWithRlsContext({ tenantId: "tenant_1" }, () => getInvitationTenantIdentity("tenant_1", { allowedInactiveReason: "pending_owner" })) ).resolves.toMatchObject({ id: "tenant_1", active: false, deactivatedReason: "pending_owner" }); expect(dbMock.tenant.findFirst).toHaveBeenCalledWith({ where: { id: "tenant_1", OR: [{ active: true }, { active: false, deactivatedReason: "pending_owner" }], }, select: { id: true, name: true, slug: true, active: true, deactivatedReason: true }, }); }); it("does not broaden invitation visibility for an arbitrary inactive reason at runtime", async () => { vi.mocked(dbMock.tenant.findFirst).mockResolvedValueOnce(null); await runWithRlsContext({ tenantId: "tenant_1" }, () => getInvitationTenantIdentity("tenant_1", { allowedInactiveReason: "billing" as never })); expect(dbMock.tenant.findFirst).toHaveBeenCalledWith({ where: { id: "tenant_1", active: true }, select: { id: true, name: true, slug: true, active: true, deactivatedReason: true }, }); }); it("uses the free-text query as a user filter when no base filter exists", async () => { vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_1" }, { id: "tenant_2" }] as never); vi.mocked(dbMock.tenant.findFirst) .mockResolvedValueOnce({ id: "tenant_1" } as never) .mockResolvedValueOnce({ id: "tenant_2" } as never); vi.mocked(dbMock.tenant.findUnique) .mockResolvedValueOnce({ id: "tenant_1", users: [{ userId: "user_query" }] } as never) .mockResolvedValueOnce({ id: "tenant_2", users: [] } as never); const result = await adminGetAllTenantsWithUsage({ query: "user_query", properties: [], } as never); expect(dbMock.tenant.findMany).toHaveBeenCalledWith({ select: { id: true }, orderBy: { createdAt: "desc" } }); expect(result.items.map((tenant) => tenant.id)).toEqual(["tenant_1", "tenant_2"]); expect(result.pagination).toEqual({ page: 1, pageSize: 10, totalItems: 2, totalPages: 1 }); }); it("filters by user and skips tenants that disappear before hydration", async () => { vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_1" }, { id: "tenant_2" }] as never); vi.mocked(dbMock.tenant.findFirst) .mockResolvedValueOnce({ id: "tenant_1" } as never) .mockResolvedValueOnce({ id: "tenant_2" } as never); vi.mocked(dbMock.tenant.findUnique) .mockResolvedValueOnce(null) .mockResolvedValueOnce({ id: "tenant_2", users: [] } as never); const result = await adminGetAllTenantsWithUsage({ query: "user_query", properties: [] } as never); expect(result.items.map((tenant) => tenant.id)).toEqual(["tenant_2"]); expect(result.pagination.totalItems).toBe(2); expect(dbMock.tenant.findFirst).toHaveBeenCalledTimes(2); }); it("throws a descriptive error when requireTenant cannot resolve a tenant", async () => { vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(null); await expect(requireTenant("tenant_missing")).rejects.toThrow("Tenant not found: tenant_missing"); }); it("returns the resolved tenant when requireTenant finds one", async () => { vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce({ id: "tenant_1" } as never); await expect(requireTenant("tenant_1")).resolves.toEqual({ id: "tenant_1" }); expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenant:tenant_1" })); }); it("returns null early for tenant-with-users and tenant-user lookups without ids", async () => { await expect(getTenantWithUsers()).resolves.toBeNull(); await expect(getTenantUser()).resolves.toBeNull(); expect(dbMock.tenant.findUnique).not.toHaveBeenCalled(); expect(dbMock.tenantUser.findFirst).not.toHaveBeenCalled(); }); it("returns active member tenants and active tenant-user counts", async () => { vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_1" }] as never); vi.mocked(dbMock.tenantUser.count).mockResolvedValueOnce(7); await expect(getMyTenants("user_1")).resolves.toEqual([{ id: "tenant_1" }]); await expect(getTenantUsersCount("tenant_1")).resolves.toBe(7); expect(dbMock.tenant.findMany).toHaveBeenCalledWith( expect.objectContaining({ where: { active: true, users: { some: { userId: "user_1", status: TenantUserStatus.ACTIVE } } }, orderBy: { name: "asc" }, }) ); expect(dbMock.tenantUser.count).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", status: TenantUserStatus.ACTIVE, user: { active: true } }, }); }); it("scopes tenant users to active members and tenant-local role includes by default", async () => { vi.mocked(dbMock.tenantUser.findMany).mockResolvedValueOnce([{ id: "tu_1" }] as never); await expect(getTenantUsers("tenant_1")).resolves.toEqual([{ id: "tu_1" }]); expect(dbMock.tenantUser.findMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", status: TenantUserStatus.ACTIVE, user: { active: true } }, include: { user: { include: { roles: { where: { tenantId: "tenant_1" }, include: { role: true } }, }, }, }, }); }); it("skips the active-member status filter when inactive members are requested", async () => { vi.mocked(dbMock.tenantUser.findMany).mockResolvedValueOnce([] as never); await getTenantUsers("tenant_1", { includeInactive: true }); expect(dbMock.tenantUser.findMany).toHaveBeenCalledWith(expect.objectContaining({ where: { tenantId: "tenant_1" } })); }); it("returns an empty member list without touching the database when tenant id is blank", async () => { await expect(getTenantUsers(null)).resolves.toEqual([]); expect(dbMock.tenantUser.findMany).not.toHaveBeenCalled(); }); it("adds tenant scope to tenant-user lookup only when a tenant id is provided", async () => { vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValue({ id: "tu_1" } as never); await getTenantUser("tu_1"); await getTenantUser("tu_1", "tenant_1"); expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(1, expect.objectContaining({ where: { id: "tu_1" } })); expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(2, expect.objectContaining({ where: { id: "tu_1", tenantId: "tenant_1" } })); }); it("queries bulk and admin tenant-user projections with tenant-safe includes", async () => { vi.mocked(dbMock.tenantUser.findMany).mockResolvedValue([] as never); await getTenantUsersInTenantIds(["tenant_1", "tenant_2"]); await getAllTenantUsers(); expect(dbMock.tenantUser.findMany).toHaveBeenNthCalledWith(1, { where: { tenantId: { in: ["tenant_1", "tenant_2"] } }, include: { tenant: true, user: { select: expect.any(Object) }, }, }); expect(dbMock.tenantUser.findMany).toHaveBeenNthCalledWith(2, { include: { user: { include: { roles: { include: { role: true } }, }, }, }, }); }); it("queries tenant-user membership by composite identity and active member predicates", async () => { vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValue({ id: "tu_1" } as never); await getTenantUserByIds("tenant_1", "user_1"); await getTenantMember("user_1", "tenant_1"); await getTenantUserType("user_1", "tenant_1"); expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(1, expect.objectContaining({ where: { tenantId: "tenant_1", userId: "user_1" } })); expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith( 2, expect.objectContaining({ where: { userId: "user_1", tenantId: "tenant_1", status: TenantUserStatus.ACTIVE, tenant: { active: true } }, }) ); expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(3, { where: { userId: "user_1", tenantId: "tenant_1", status: TenantUserStatus.ACTIVE, tenant: { active: true } }, select: { status: true, type: true }, }); }); it("caches tenant-user simple lookups and converts missing rows to null", async () => { vi.mocked(dbMock.tenantUser.findFirstOrThrow).mockRejectedValueOnce(new Error("not found")); await expect(getTenantUserSimple({ tenantId: "tenant_1", userId: "user_1" })).resolves.toBeNull(); expect(cachified).toHaveBeenCalledWith( expect.objectContaining({ key: "tenantUserSimple:tenant_1:user_1", ttl: TENANT_SNAPSHOT_SAFETY_TTL_SECONDS * 1_000, }) ); expect(dbMock.tenantUser.findFirstOrThrow).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", userId: "user_1", status: TenantUserStatus.ACTIVE, tenant: { active: true } }, select: { id: true, type: true }, }); }); it("updates tenant profile data and all slug/id cache keys", async () => { vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "new-slug" } as never); await updateTenant({ id: "tenant_1", slug: "old-slug" } as never, { name: "Acme", icon: "icon", slug: "new-slug" }); expect(dbMock.tenant.update).toHaveBeenCalledWith({ where: { id: "tenant_1" }, data: { name: "Acme", icon: "icon", slug: "new-slug", }, }); expect(clearCacheKey).toHaveBeenCalledWith("tenant:old-slug"); expect(clearCacheKey).toHaveBeenCalledWith("tenant:tenant_1"); expect(clearCacheKey).toHaveBeenCalledWith("tenantIdOrSlug:old-slug"); expect(clearCacheKey).toHaveBeenCalledWith("tenantSimple:tenant_1"); }); it("updates the tenant Anrede (du/Sie) without evicting unrelated API-key auth caches", async () => { vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "acme" } as never); await updateTenantAnrede("tenant_1", "du"); expect(dbMock.tenant.update).toHaveBeenCalledWith({ where: { id: "tenant_1" }, data: { anrede: "du" }, }); expect(clearCacheKey).toHaveBeenCalledWith("tenant:acme"); expect(clearCacheKey).toHaveBeenCalledWith("tenant:tenant_1"); expect(clearCacheKey).toHaveBeenCalledWith("tenantIdOrSlug:tenant_1"); expect(clearCacheKey).toHaveBeenCalledWith("tenantIdOrSlug:acme"); expect(clearCacheKey).toHaveBeenCalledWith("tenantSimple:tenant_1"); expect(clearCacheKeyPrefix).not.toHaveBeenCalledWith("apiKeyHash:"); }); it("creates tenants inactive when requested and emits the tenant-created plugin hook", async () => { const createdAt = new Date("2026-05-25T12:00:00.000Z"); let tenantContext: string | undefined; vi.mocked(dbMock.tenant.create).mockImplementationOnce(async () => { tenantContext = getRlsExecutionContext()?.tenantId; return { id: "tenant_1", slug: "acme", createdAt } as never; }); await createTenant({ name: "Acme", icon: "icon", active: false, slug: "acme" }); expect(dbMock.tenant.create).toHaveBeenCalledWith({ data: { id: expect.any(String), name: "Acme", slug: "acme", icon: "icon", active: false, inboundAddresses: { create: [{ address: "acme" }] }, }, }); expect(tenantContext).toBe(dbMock.tenant.create.mock.calls[0][0].data.id); expect(createTenantSubscription).not.toHaveBeenCalled(); expect(emitPluginHookFireAndForget).toHaveBeenCalledWith( expect.objectContaining({ name: "tenant.created" }), { tenantId: "tenant_1", slug: "acme", ownerEmail: null, plan: null, createdAt: "2026-05-25T12:00:00.000Z", }, { tenantId: "tenant_1", dispatchKey: "tenant:tenant_1:created" } ); }); it("defaults new tenants active and creates a subscription when a customer id is present", async () => { vi.mocked(dbMock.tenant.create).mockResolvedValueOnce({ id: "tenant_1", slug: "acme", createdAt: new Date("2026-05-25T12:00:00.000Z"), } as never); await createTenant({ name: "Acme", subscriptionCustomerId: "cus_1" }); expect(dbMock.tenant.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ active: true }) })); expect(createTenantSubscription).toHaveBeenCalledWith("tenant_1", "cus_1"); }); it("uses deterministic safe fallbacks for empty and reserved tenant identifiers", async () => { const createdAt = new Date("2026-07-15T08:00:00.000Z"); vi.mocked(dbMock.tenant.create) .mockResolvedValueOnce({ id: "tenant_1", slug: "workspace", createdAt } as never) .mockResolvedValueOnce({ id: "tenant_2", slug: "acme", createdAt } as never) .mockResolvedValueOnce({ id: "tenant_3", slug: "acme1", createdAt } as never); await createTenant({ name: "!!!" }); await createTenant({ name: "Acme", slug: "!!!" }); await createTenant({ name: "Acme", slug: "admin" }); expect(dbMock.tenant.create).toHaveBeenNthCalledWith(1, { data: expect.objectContaining({ slug: "workspace" }) }); expect(dbMock.tenant.create).toHaveBeenNthCalledWith(2, { data: expect.objectContaining({ slug: "acme" }) }); expect(dbMock.tenant.create).toHaveBeenNthCalledWith(3, { data: expect.objectContaining({ slug: "acme1" }) }); }); it("runs required tenant setup in the same tenant-scoped transaction and does not emit a hook after rollback", async () => { vi.mocked(dbMock.tenant.create).mockImplementationOnce( async ({ data }: { data: { id: string } }) => ({ id: data.id, slug: "acme", createdAt: new Date("2026-05-25T12:00:00.000Z"), }) as never ); const setup = vi.fn(async (tenant: Tenant, tx: unknown) => { expect(getRlsExecutionContext()?.tenantId).toBe(tenant.id); expect(tx).toBe(db); throw new Error("provisioning failed"); }); await expect(createTenant({ name: "Acme", setup })).rejects.toThrow("provisioning failed"); expect(setup).toHaveBeenCalledTimes(1); expect(dbMock.$transaction).toHaveBeenCalledTimes(1); expect(clearCacheKey).toHaveBeenCalledWith("tenant:acme"); expect(emitPluginHookFireAndForget).not.toHaveBeenCalled(); }); it("binds the owner identity before the transaction, returns the setup-updated tenant, and keeps activation as the final setup write", async () => { const createdAt = new Date("2026-07-15T08:00:00.000Z"); const callOrder: string[] = []; vi.mocked(dbMock.$transaction).mockImplementationOnce((async (callback: (tx: typeof db) => Promise) => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: expect.any(String), userId: "user_owner" }); callOrder.push("transaction"); return await callback(db); }) as never); vi.mocked(dbMock.tenant.create).mockImplementationOnce(async ({ data }: { data: { id: string } }) => { callOrder.push("create-inactive"); return { id: data.id, slug: "acme", active: false, deactivatedReason: "bootstrap_pending", createdAt } as never; }); vi.mocked(dbMock.tenant.update).mockImplementationOnce(async () => { callOrder.push("activate"); return { id: "tenant_1", active: true } as never; }); vi.mocked(dbMock.tenant.findUniqueOrThrow).mockImplementationOnce(async () => { callOrder.push("reload-final"); return { id: "tenant_1", slug: "acme", active: true, deactivatedReason: null, createdAt, } as never; }); const result = await createTenant({ name: "Acme", active: false, deactivatedReason: "bootstrap_pending", rlsUserId: "user_owner", setup: async (tenant, tx) => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: tenant.id, userId: "user_owner" }); expect(tx).toBe(db); await tx.tenant.update({ where: { id: tenant.id }, data: { active: true, deactivatedReason: null }, }); }, }); expect(dbMock.tenant.create).toHaveBeenCalledWith({ data: expect.objectContaining({ active: false, deactivatedReason: "bootstrap_pending" }), }); expect(callOrder).toEqual(["transaction", "create-inactive", "activate", "reload-final"]); expect(result).toMatchObject({ active: true, deactivatedReason: null }); expect(emitPluginHookFireAndForget).toHaveBeenCalledWith( expect.objectContaining({ name: "tenant.created" }), expect.objectContaining({ tenantId: "tenant_1" }), expect.objectContaining({ tenantId: "tenant_1" }) ); }); it("uses a tenant returned by setup without an extra reload", async () => { const createdAt = new Date("2026-07-15T08:00:00.000Z"); vi.mocked(dbMock.tenant.create).mockResolvedValueOnce({ id: "tenant_1", slug: "acme", active: false, createdAt, } as never); vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "acme", active: true, createdAt, } as never); const result = await createTenant({ name: "Acme", active: false, setup: async (tenant, tx) => await tx.tenant.update({ where: { id: tenant.id }, data: { active: true }, }), }); expect(result).toMatchObject({ id: "tenant_1", active: true }); expect(dbMock.tenant.findUniqueOrThrow).not.toHaveBeenCalled(); }); it("isolates an existing matching user from the old tenant and transaction for create and post-commit hook", async () => { const createdAt = new Date("2026-07-15T08:00:00.000Z"); const oldTransaction = {}; vi.mocked(dbMock.$transaction).mockImplementationOnce((async (callback: (tx: typeof db) => Promise) => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: expect.any(String), userId: "user_owner" }); expect(getRlsExecutionContext()?.tenantId).not.toBe("tenant_old"); expect(getRlsExecutionContext()?.transaction).toBeUndefined(); return await callback(db); }) as never); vi.mocked(dbMock.tenant.create).mockImplementationOnce( async ({ data }: { data: { id: string } }) => ({ id: data.id, slug: "acme", active: true, createdAt, }) as never ); vi.mocked(emitPluginHookFireAndForget).mockImplementationOnce(async () => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: expect.any(String), userId: "user_owner" }); expect(getRlsExecutionContext()?.tenantId).not.toBe("tenant_old"); expect(getRlsExecutionContext()?.transaction).toBeUndefined(); }); await runWithRlsContext({ tenantId: "tenant_old", userId: "user_owner" }, () => runWithRlsTransaction(oldTransaction, () => createTenant({ name: "Acme", rlsUserId: "user_owner" })) ); expect(emitPluginHookFireAndForget).toHaveBeenCalledTimes(1); }); it("isolates a matching user-only transaction before tenant creation and the post-commit hook", async () => { const createdAt = new Date("2026-07-15T08:00:00.000Z"); const oldTransaction = {}; vi.mocked(dbMock.$transaction).mockImplementationOnce((async (callback: (tx: typeof db) => Promise) => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: expect.any(String), userId: "user_owner" }); expect(getRlsExecutionContext()?.transaction).toBeUndefined(); return await callback(db); }) as never); vi.mocked(dbMock.tenant.create).mockImplementationOnce( async ({ data }: { data: { id: string } }) => ({ id: data.id, slug: "acme", active: true, createdAt, }) as never ); vi.mocked(emitPluginHookFireAndForget).mockImplementationOnce(async () => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: expect.any(String), userId: "user_owner" }); expect(getRlsExecutionContext()?.transaction).toBeUndefined(); }); await runWithRlsContext({ userId: "user_owner" }, () => runWithRlsTransaction(oldTransaction, () => createTenant({ name: "Acme", rlsUserId: "user_owner" })) ); expect(emitPluginHookFireAndForget).toHaveBeenCalledTimes(1); }); it("suppresses the tenant-created hook for ownerless reservations", async () => { const createdAt = new Date("2026-07-15T08:00:00.000Z"); vi.mocked(dbMock.tenant.create).mockResolvedValueOnce({ id: "tenant_reserved", slug: "reserved", active: false, deactivatedReason: "pending_owner", createdAt, } as never); await createTenant({ name: "Reserved", active: false, deactivatedReason: "pending_owner", emitCreatedHook: false, }); expect(emitPluginHookFireAndForget).not.toHaveBeenCalled(); }); it("exports the tenant-created hook for an owner claim", async () => { const tenant = { id: "tenant_reserved", slug: "reserved", createdAt: new Date("2026-07-15T08:00:00.000Z"), } as Tenant; await emitTenantCreatedHook(tenant, "user_owner"); expect(emitPluginHookFireAndForget).toHaveBeenCalledWith( expect.objectContaining({ name: "tenant.created" }), expect.objectContaining({ tenantId: "tenant_reserved" }), { tenantId: "tenant_reserved", dispatchKey: "tenant:tenant_reserved:created" } ); }); it("retries globally unique tenant identifiers without needing cross-tenant reads", async () => { const createdAt = new Date("2026-05-25T12:00:00.000Z"); vi.mocked(dbMock.tenant.create) .mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { target: ["slug"] } })) .mockResolvedValueOnce({ id: "tenant_2", slug: "acme1", createdAt } as never); await expect(createTenant({ name: "Acme" })).resolves.toMatchObject({ id: "tenant_2", slug: "acme1" }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(2); expect(dbMock.tenant.create.mock.calls[0][0].data).toMatchObject({ slug: "acme", inboundAddresses: { create: [{ address: "acme" }] }, }); expect(dbMock.tenant.create.mock.calls[1][0].data).toMatchObject({ slug: "acme1", inboundAddresses: { create: [{ address: "acme" }] }, }); expect(clearCacheKey).not.toHaveBeenCalledWith("tenant:acme"); }); it("rejects a colliding user-selected slug instead of silently suffixing it", async () => { vi.mocked(dbMock.tenant.create).mockRejectedValueOnce( Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { target: ["slug"] }, }) ); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toBeInstanceOf(TenantSlugCollisionError); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); expect(dbMock.tenant.create).toHaveBeenCalledWith({ data: expect.objectContaining({ slug: "chosen" }) }); }); it("classifies an adapter-pg slug field collision for an explicit tenant slug", async () => { vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(adapterPgUniqueConstraintError({ fields: ["slug"] })); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toBeInstanceOf(TenantSlugCollisionError); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("classifies an adapter-pg constraint name for an explicit tenant slug", async () => { vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(adapterPgUniqueConstraintError({ name: "Tenant_slug_key" })); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toBeInstanceOf(TenantSlugCollisionError); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("uses the exact PostgreSQL constraint name when adapter-pg omits its parsed constraint", async () => { vi.mocked(dbMock.tenant.create).mockRejectedValueOnce( adapterPgUniqueConstraintError(undefined, {}, 'duplicate key value violates unique constraint "Tenant_slug_key"') ); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toBeInstanceOf(TenantSlugCollisionError); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("fails closed when an unparsed adapter-pg message does not name an exact known constraint", async () => { const collision = adapterPgUniqueConstraintError(undefined, {}, 'duplicate key value violates unique constraint "Other_slug_key"'); vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(collision); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toMatchObject({ name: "TenantIdentifierCollisionError", cause: collision, }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("keeps a user-selected slug while retrying an inbound-address collision", async () => { const createdAt = new Date("2026-05-25T12:00:00.000Z"); vi.mocked(dbMock.tenant.create) .mockRejectedValueOnce( Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { target: "TenantInboundAddress_address_key" }, }) ) .mockResolvedValueOnce({ id: "tenant_2", slug: "chosen", createdAt } as never); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).resolves.toMatchObject({ slug: "chosen", }); expect(dbMock.tenant.create.mock.calls[0][0].data).toMatchObject({ slug: "chosen", inboundAddresses: { create: [{ address: "acme" }] }, }); expect(dbMock.tenant.create.mock.calls[1][0].data).toMatchObject({ slug: "chosen", inboundAddresses: { create: [{ address: "acme1" }] }, }); }); it("only suffixes the inbound address for an adapter-pg address field collision", async () => { const createdAt = new Date("2026-05-25T12:00:00.000Z"); vi.mocked(dbMock.tenant.create) .mockRejectedValueOnce(adapterPgUniqueConstraintError({ fields: ["address"] })) .mockResolvedValueOnce({ id: "tenant_2", slug: "chosen", createdAt } as never); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).resolves.toMatchObject({ slug: "chosen", }); expect(dbMock.tenant.create.mock.calls[0][0].data).toMatchObject({ slug: "chosen", inboundAddresses: { create: [{ address: "acme" }] }, }); expect(dbMock.tenant.create.mock.calls[1][0].data).toMatchObject({ slug: "chosen", inboundAddresses: { create: [{ address: "acme1" }] }, }); }); it("allocates a new tenant id for an adapter-pg id field collision", async () => { const createdAt = new Date("2026-05-25T12:00:00.000Z"); vi.mocked(dbMock.tenant.create) .mockRejectedValueOnce(adapterPgUniqueConstraintError({ fields: ["id"] })) .mockResolvedValueOnce({ id: "tenant_2", slug: "acme", createdAt } as never); await expect(createTenant({ name: "Acme" })).resolves.toMatchObject({ id: "tenant_2" }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(2); expect(dbMock.tenant.create.mock.calls[0][0].data.id).not.toBe(dbMock.tenant.create.mock.calls[1][0].data.id); expect(dbMock.tenant.create.mock.calls[1][0].data).toMatchObject({ slug: "acme", inboundAddresses: { create: [{ address: "acme" }] }, }); }); it("fails closed for an unknown unique constraint instead of rewriting identifiers", async () => { const collision = Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { target: ["unexpectedUniqueField"] }, }); vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(collision); await expect(createTenant({ name: "Acme" })).rejects.toMatchObject({ name: "TenantIdentifierCollisionError", cause: collision, }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("fails closed for an unknown adapter-pg constraint even when legacy metadata names a slug", async () => { const collision = adapterPgUniqueConstraintError({ fields: ["billingAddress"] }, { target: ["slug"] }); vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(collision); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toMatchObject({ name: "TenantIdentifierCollisionError", cause: collision, }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("fails closed when adapter-pg constraint fields and name disagree", async () => { const collision = adapterPgUniqueConstraintError({ fields: ["slug"], name: "TenantInboundAddress_address_key", }); vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(collision); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toMatchObject({ name: "TenantIdentifierCollisionError", cause: collision, }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it.each([ [ "a non-unique driver error", () => Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { driverAdapterError: { cause: { kind: "ForeignKeyConstraintViolation", constraint: "Tenant_slug_key" } } }, }), ], [ "an invalid original PostgreSQL code", () => Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { driverAdapterError: { cause: { kind: "UniqueConstraintViolation", originalCode: "23503", originalMessage: 'duplicate key value violates unique constraint "Tenant_slug_key"', }, }, }, }), ], ["an empty driver constraint record", () => adapterPgUniqueConstraintError({})], ["empty driver constraint fields", () => adapterPgUniqueConstraintError({ fields: [] })], ["a non-string driver constraint name", () => adapterPgUniqueConstraintError({ name: 42 })], ["a malformed legacy target", () => Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { target: [] } })], ])("fails closed for %s", async (_label, createCollision) => { const collision = createCollision(); vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(collision); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toMatchObject({ name: "TenantIdentifierCollisionError", cause: collision, }); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); }); it("classifies a direct adapter-pg constraint string", async () => { vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(adapterPgUniqueConstraintError("Tenant_slug_key")); await expect(createTenant({ name: "Acme", slug: "chosen", rejectSlugCollision: true })).rejects.toBeInstanceOf(TenantSlugCollisionError); }); it("replays setup for a visible preallocated tenant instead of creating a duplicate", async () => { const tenantId = "7ee71103-e2be-5a5d-921c-b2d6d22c9435"; const existing = { id: tenantId, slug: "acme", active: true, createdAt: new Date("2026-07-15T08:00:00.000Z"), } as Tenant; vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" })); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(existing as never); const setup = vi.fn(async (tenant: Tenant) => tenant); const validateExistingReplay = vi.fn(async () => undefined); await expect( createTenant({ name: "Acme", tenantId, rlsUserId: "user_owner", setup, validateExistingReplay, }) ).resolves.toBe(existing); expect(dbMock.tenant.create).toHaveBeenCalledTimes(1); expect(dbMock.tenant.create).toHaveBeenCalledWith({ data: expect.objectContaining({ id: tenantId }) }); expect(dbMock.tenant.findUnique).toHaveBeenCalledWith({ where: { id: tenantId } }); expect(validateExistingReplay).toHaveBeenCalledWith(existing, db); expect(setup).toHaveBeenCalledWith(existing, db); expect(clearCacheKey).not.toHaveBeenCalledWith("tenant:acme"); expect(emitPluginHookFireAndForget).not.toHaveBeenCalled(); }); it("never runs setup when a preallocated tenant fails replay validation", async () => { const tenantId = "7ee71103-e2be-5a5d-921c-b2d6d22c9435"; const existing = { id: tenantId, slug: "foreign", active: true, createdAt: new Date("2026-07-15T08:00:00.000Z"), } as Tenant; vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" })); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(existing as never); const setup = vi.fn(); await expect( createTenant({ name: "Acme", tenantId, rlsUserId: "user_owner", setup, validateExistingReplay: async () => { throw new Error("invalid creation replay"); }, }) ).rejects.toThrow("invalid creation replay"); expect(setup).not.toHaveBeenCalled(); expect(emitPluginHookFireAndForget).not.toHaveBeenCalled(); }); it("fails closed when a colliding preallocated tenant is not visible", async () => { const collision = Object.assign(new Error("Unique constraint failed"), { code: "P2002" }); vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(collision); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(null); await expect( createTenant({ name: "Acme", tenantId: "7ee71103-e2be-5a5d-921c-b2d6d22c9435", rlsUserId: "user_owner", validateExistingReplay: async () => undefined, }) ).rejects.toMatchObject({ name: "TenantIdentifierCollisionError", cause: collision }); }); it("requires explicit replay validation for an existing preallocated tenant", async () => { const existing = { id: "7ee71103-e2be-5a5d-921c-b2d6d22c9435", slug: "acme" } as Tenant; vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" })); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(existing as never); await expect(createTenant({ name: "Acme", tenantId: existing.id, rlsUserId: "user_owner" })).rejects.toThrow( "Preallocated tenant replay requires explicit validation" ); }); it("returns a validated preallocated tenant without rerunning optional setup", async () => { const existing = { id: "7ee71103-e2be-5a5d-921c-b2d6d22c9435", slug: "acme" } as Tenant; vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" })); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(existing as never); await expect(createTenant({ name: "Acme", tenantId: existing.id, rlsUserId: "user_owner", validateExistingReplay: async () => undefined })).resolves.toBe( existing ); }); it("reloads a validated preallocated tenant when replay setup returns no row", async () => { const existing = { id: "7ee71103-e2be-5a5d-921c-b2d6d22c9435", slug: "acme", active: false } as Tenant; const activated = { ...existing, active: true } as Tenant; vi.mocked(dbMock.tenant.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" })); vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(existing as never); vi.mocked(dbMock.tenant.findUniqueOrThrow).mockResolvedValueOnce(activated as never); await expect( createTenant({ name: "Acme", tenantId: existing.id, rlsUserId: "user_owner", validateExistingReplay: async () => undefined, setup: async () => undefined, }) ).resolves.toBe(activated); }); it("creates tenant users as active invited members and assigns each requested role", async () => { vi.mocked(dbMock.tenantUser.create).mockResolvedValueOnce({ id: "tu_1", tenantId: "tenant_1", userId: "user_1" } as never); await createTenantUser({ tenantId: "tenant_1", userId: "user_1", type: 0 }, [{ id: "role_admin" }, { id: "role_member" }] as never); expect(dbMock.tenantUser.create).toHaveBeenCalledWith({ data: { tenantId: "tenant_1", userId: "user_1", type: 0, joined: TenantUserJoined.JOINED_BY_INVITATION, status: TenantUserStatus.ACTIVE, }, }); expect(createUserRole).toHaveBeenCalledWith("user_1", "role_admin", "tenant_1"); expect(createUserRole).toHaveBeenCalledWith("user_1", "role_member", "tenant_1"); }); it("does not delete cross-tenant membership when a tenant-scoped delete misses", async () => { vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValueOnce(null); await expect(deleteTenantUser("tu_1", "tenant_1")).resolves.toEqual({ count: 0 }); expect(dbMock.tenantUser.deleteMany).not.toHaveBeenCalled(); expect(dbMock.$transaction).not.toHaveBeenCalled(); }); it("deletes tenant-scoped membership, roles, groups, and user-role cache together", async () => { vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValueOnce({ tenantId: "tenant_1", userId: "user_1" } as never); vi.mocked(dbMock.tenantUser.deleteMany).mockResolvedValueOnce({ count: 1 } as never); vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 2 } as never); vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 3 } as never); await expect(deleteTenantUser("tu_1", "tenant_1")).resolves.toEqual({ count: 1 }); expect(dbMock.tenantUser.deleteMany).toHaveBeenCalledWith({ where: { id: "tu_1", tenantId: "tenant_1" } }); expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", userId: "user_1" } }); expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { userId: "user_1", group: { tenantId: "tenant_1" } }, }); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1"); }); it("cleans role and group links after an unscoped tenant-user delete when the deleted row has a tenant", async () => { vi.mocked(dbMock.tenantUser.delete).mockResolvedValueOnce({ id: "tu_1", tenantId: "tenant_1", userId: "user_1" } as never); vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 2 } as never); vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 3 } as never); await deleteTenantUser("tu_1"); expect(dbMock.$transaction).toHaveBeenCalledTimes(1); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1"); }); it("returns an unscoped tenant-user delete without cleanup when the deleted row has no tenant", async () => { vi.mocked(dbMock.tenantUser.delete).mockResolvedValueOnce({ id: "tu_1", tenantId: null, userId: "user_1" } as never); await expect(deleteTenantUser("tu_1")).resolves.toEqual({ id: "tu_1", tenantId: null, userId: "user_1" }); expect(dbMock.$transaction).not.toHaveBeenCalled(); expect(clearCacheKey).not.toHaveBeenCalledWith("userRoles:user_1:null"); }); it("deletes tenants with dependent records included", async () => { vi.mocked(dbMock.tenant.delete).mockResolvedValueOnce({ id: "tenant_1", slug: "acme" } as never); await deleteTenant("tenant_1"); expect(dbMock.tenant.delete).toHaveBeenCalledWith({ where: { id: "tenant_1" }, include: { subscription: true, users: true, invitations: true, logs: true, apiKeys: true, userRoles: true, }, }); }); it("updates deactivation state and clears tenant identity cache keys", async () => { vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "acme" } as never); await updateTenantDeactivated("tenant_1", { active: false, deactivatedReason: "billing" }); expect(dbMock.tenant.update).toHaveBeenCalledWith({ where: { id: "tenant_1" }, data: { active: false, deactivatedReason: "billing" }, }); expect(clearCacheKey).toHaveBeenCalledWith("tenant:acme"); expect(clearCacheKey).toHaveBeenCalledWith("tenant:tenant_1"); expect(clearCacheKey).toHaveBeenCalledWith("tenantIdOrSlug:acme"); expect(clearCacheKey).toHaveBeenCalledWith("tenantSimple:tenant_1"); }); });