import { readFileSync } from "node:fs"; import path from "node:path"; import { describe, expect, it } from "vitest"; import { EXPECTED_FORCED_RLS_COUNT, EXPECTED_POLICY_DEFINITION_COUNT, EXPECTED_TENANT_RESOLVER_NAMES, FROZEN_BASELINE_MIGRATION_SHA256, GENERATED_POLICY_PATH, GENERATED_MIGRATION_PATH, GENERATED_RUNTIME_CONTRACT_PATH, inspectTenantPolicyContract, readPostCutoverMigrationSql, renderPostCutoverPolicyDeltaSql, renderRlsRuntimeContract, renderTenantPolicySql, sha256, } from "./generate-tenant-policy-contract.mjs"; import { APPEND_ONLY_TENANT_MODEL_CONTRACT, DERIVED_OWNERSHIP_CONTRACT, DIRECT_SCALAR_TENANT_REFERENCE_CONTRACT, DIRECT_WORKER_POLICY_CONTRACT, GLOBAL_GUARDED_EXTRA_MODELS, GLOBAL_GUARDED_MODEL_CONTRACT, GLOBAL_SHARED_POLICY_CONTRACT, PLATFORM_ADMIN_POLICY_CONTRACT, TENANT_RESOLVER_CONTRACT, } from "../prisma/tenant-policy-contract.mjs"; import { TENANT_SCOPE_GROUPS } from "../prisma/tenant-scope-manifest.mjs"; const root = process.cwd(); describe("tenant policy contract generator", () => { it("covers every model that requires tenant RLS", () => { const result = inspectTenantPolicyContract(root); expect(result.errors).toEqual([]); expect(result.ok).toBe(true); expect(result.definitions).toHaveLength(EXPECTED_POLICY_DEFINITION_COUNT); expect(new Set(result.definitions.map((definition) => definition.model)).size).toBe(EXPECTED_POLICY_DEFINITION_COUNT); expect(result.expectedDefinitionCount).toBe(EXPECTED_POLICY_DEFINITION_COUNT); expect(result.forcedRlsCount).toBe(EXPECTED_FORCED_RLS_COUNT); expect(result.definitions.filter((definition) => definition.forceRls === false).map(({ model }) => model)).toEqual([]); }); it("binds operator privileges to the app login role rather than the security definer", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); expect(sql).toContain("SELECT session_user = 'hivegrid_app'"); expect(sql).toContain('operator_admin."id" = NULLIF(current_setting'); expect(sql).toContain('operator_admin."status" = \'active\''); expect(sql).not.toContain('JOIN public."User" AS operator_user'); expect(sql).not.toContain("SELECT session_user = 'hivegrid_worker'"); expect(sql).not.toContain("SELECT current_user = 'hivegrid_app'"); }); it("projects consumed registration billing preferences only to the exact active tenant member", () => { const result = inspectTenantPolicyContract(root); const sql = renderTenantPolicySql(result); const registration = result.definitions.find((definition) => definition.model === "Registration"); expect(sql).toContain("hivegrid_find_registration_billing_preference"); expect(sql).toContain("p_tenant_id IS NOT DISTINCT FROM NULLIF(current_setting('app.tenant_id', true), '')"); expect(sql).toContain("p_user_id IS NOT DISTINCT FROM NULLIF(current_setting('app.user_id', true), '')"); expect(sql).toContain('membership."status" = 2'); expect(sql).toContain("REVOKE ALL ON FUNCTION public.hivegrid_find_registration_billing_preference(text,text)"); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_find_registration_billing_preference(text,text) TO hivegrid_app"); expect(registration?.readExpression).toContain("hivegrid_is_operator"); expect(registration?.readExpression).not.toContain("app.tenant_id"); }); it("keeps tenant discovery identity-scoped and tenant writes context-scoped", () => { const result = inspectTenantPolicyContract(root); const tenant = result.definitions.find((definition) => definition.model === "Tenant"); const membership = result.definitions.find((definition) => definition.model === "TenantUser"); expect(tenant?.commandExpressions.select).toContain('"membership"."userId"'); expect(tenant?.commandExpressions.select).toContain("public.hivegrid_is_operator()"); expect(tenant?.commandExpressions.select).toContain("current_user = 'hivegrid_worker'"); expect(tenant?.commandExpressions.insert).toContain("app.tenant_id"); expect(tenant?.commandExpressions.update).toContain("app.tenant_id"); expect(tenant?.commandExpressions.update).not.toContain("app.user_id"); expect(tenant?.commandExpressions.update).not.toContain("hivegrid_is_operator"); expect(membership?.commandExpressions.select).toContain('"userId"'); expect(membership?.commandExpressions.select).toContain("app.user_id"); expect(membership?.commandExpressions.select).not.toContain("hivegrid_is_operator"); expect(membership?.commandExpressions.insert).toContain("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(membership?.commandExpressions.insert).not.toContain("hivegrid_is_operator"); }); it("never turns operator identity into a tenant-child bypass", () => { const result = inspectTenantPolicyContract(root); const directChild = result.definitions.find((definition) => definition.model === "Kontakt"); const derivedChild = result.definitions.find((definition) => definition.model === "WorkflowBlock"); expect(directChild?.readExpression).toBe("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(directChild?.readExpression).not.toContain("app.user_id"); expect(directChild?.readExpression).not.toContain("hivegrid_is_operator"); expect(derivedChild?.readExpression).toContain("app.tenant_id"); expect(derivedChild?.readExpression).not.toContain("app.user_id"); expect(derivedChild?.readExpression).not.toContain("hivegrid_is_operator"); }); it("guards reviewed cross-module scalar references on insert and update", () => { const result = inspectTenantPolicyContract(root); const chat = result.definitions.find((definition) => definition.model === "TeamChat"); const chatGroupSource = result.definitions.find((definition) => definition.model === "TeamChatGroupSource"); const chatMember = result.definitions.find((definition) => definition.model === "TeamChatMember"); const chatMessage = result.definitions.find((definition) => definition.model === "TeamChatMessage"); const chatEvent = result.definitions.find((definition) => definition.model === "TeamChatEvent"); const connection = result.definitions.find((definition) => definition.model === "TelephonyConnection"); const binding = result.definitions.find((definition) => definition.model === "TelephonyUserBinding"); const call = result.definitions.find((definition) => definition.model === "TelephonyCallSession"); expect(Object.keys(DIRECT_SCALAR_TENANT_REFERENCE_CONTRACT).sort()).toEqual([ "KwpApiContractSnapshot.dataConnectionId", "KwpCapabilityState.dataConnectionId", "KwpErrorReport.dataConnectionId", "KwpMaterialPosition.dataConnectionId", "KwpMaterialPosition.projektId", "KwpProjectCatalogItem.dataConnectionId", "KwpProjectCatalogState.dataConnectionId", "KwpProjectRouting.dataConnectionId", "KwpProjectRouting.pipelineId", "KwpProjectRouting.stageId", "TeamChat.createdByUserId", "TeamChat.projektId", "TeamChatEvent.actorUserId", "TeamChatGroupSource.groupId", "TeamChatMember.joinedViaUserId", "TeamChatMember.userId", "TeamChatMessage.authorUserId", "TeamChatMessage.deletedByUserId", "TeamChatPinnedMessage.pinnedByUserId", "TeamChatReaction.userId", "TeamChatRead.userId", "TeamChatThread.createdByUserId", "TelephonyCallSession.manualOverrideUserId", "TelephonyCallSession.matchedKontaktId", "TelephonyCallSession.matchedLeadId", "TelephonyCallSession.matchedProjektId", "TelephonyCallSession.tenantUserId", "TelephonyConnection.dataConnectionId", "TelephonyUserBinding.tenantUserId", ]); for (const command of ["insert", "update"]) { expect(chat?.commandExpressions[command], command).toContain('FROM "Projekt"'); expect(chat?.commandExpressions[command], command).toContain('FROM "TenantUser"'); expect(chatMember?.commandExpressions[command], command).toContain('FROM "TenantUser"'); expect(chatMessage?.commandExpressions[command], command).toContain('FROM "TenantUser"'); expect(chatGroupSource?.commandExpressions[command], command).toContain('FROM "Group"'); expect(chatGroupSource?.commandExpressions[command], command).toContain( "\"scalar_owner_0\".\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')" ); if (command === "insert") { expect(chatEvent?.commandExpressions[command], command).toContain('FROM "TenantUser"'); } expect(connection?.commandExpressions[command], command).toContain('FROM "DataConnection"'); expect(connection?.commandExpressions[command], command).toContain("\"appId\" IN ('aircall', 'hallopetra')"); expect(binding?.commandExpressions[command], command).toContain('FROM "TenantUser"'); expect(call?.commandExpressions[command], command).toContain('FROM "Kontakt"'); expect(call?.commandExpressions[command], command).toContain('FROM "InboxLead"'); expect(call?.commandExpressions[command], command).toContain('FROM "Projekt"'); expect(call?.commandExpressions[command], command).toContain('FROM "TenantUser"'); expect(call?.commandExpressions[command], command).toContain('"matchedKontaktId" IS NULL'); } expect(connection?.commandExpressions.select).not.toContain('FROM "DataConnection"'); expect(connection?.commandExpressions.delete).not.toContain('FROM "DataConnection"'); expect(binding?.commandExpressions.delete).not.toContain('FROM "TenantUser"'); expect(call?.commandExpressions.select).not.toContain('FROM "Kontakt"'); expect(call?.commandExpressions.delete).not.toContain('FROM "Kontakt"'); expect(connection?.integrityChecks.map((check) => check.key)).toContain("TelephonyConnection.dataConnectionId"); expect(chat?.integrityChecks.map((check) => check.key)).toEqual(expect.arrayContaining(["TeamChat.createdByUserId", "TeamChat.projektId"])); expect(chatGroupSource?.integrityChecks.map((check) => check.key)).toContain("TeamChatGroupSource.groupId"); expect(chatMember?.integrityChecks.map((check) => check.key)).toEqual(expect.arrayContaining(["TeamChatMember.joinedViaUserId", "TeamChatMember.userId"])); expect(chatMessage?.integrityChecks.map((check) => check.key)).toEqual( expect.arrayContaining(["TeamChatMessage.authorUserId", "TeamChatMessage.deletedByUserId"]) ); expect(chatEvent?.integrityChecks.map((check) => check.key)).toContain("TeamChatEvent.actorUserId"); for (const command of ["insert", "update"]) { expect(chat?.commandExpressions[command], command).toContain('"TeamChat"."createdByUserId" IS NULL'); expect(chatMessage?.commandExpressions[command], command).toContain('"TeamChatMessage"."authorUserId" IS NULL'); } for (const command of ["insert", "update"]) { expect(chatMember?.commandExpressions[command], command).toContain('"TeamChatMember"."lastReadMessageId" IS NULL'); expect(chatMember?.commandExpressions[command], command).not.toContain( '"TeamChatMember"."lastReadMessageId" IS NULL AND "TeamChatMember"."tenantId" IS NULL' ); expect(chatMessage?.commandExpressions[command], command).toContain('"TeamChatMessage"."parentMessageId" IS NULL'); expect(chatMessage?.commandExpressions[command], command).not.toContain( '"TeamChatMessage"."parentMessageId" IS NULL AND "TeamChatMessage"."tenantId" IS NULL' ); expect(chatMessage?.commandExpressions[command], command).toContain('"owner_0"."chatId" = "TeamChatMessage"."chatId"'); } expect(binding?.integrityChecks.map((check) => check.key)).toContain("TelephonyUserBinding.tenantUserId"); expect(call?.integrityChecks.map((check) => check.key)).toEqual( expect.arrayContaining([ "TelephonyCallSession.tenantUserId", "TelephonyCallSession.manualOverrideUserId", "TelephonyCallSession.matchedKontaktId", "TelephonyCallSession.matchedLeadId", "TelephonyCallSession.matchedProjektId", ]) ); }); it("keeps the durable chat event ledger append-only with exact sequence access", () => { const result = inspectTenantPolicyContract(root); const chatEvent = result.definitions.find((definition) => definition.model === "TeamChatEvent"); const sql = renderTenantPolicySql(result); const runtimeContract = renderRlsRuntimeContract(result); expect(chatEvent?.commandRoles).toEqual({ select: ["hivegrid_app", "hivegrid_worker"], insert: ["hivegrid_app", "hivegrid_worker"], update: [], delete: [], }); expect(chatEvent?.commandExpressions.update).toBe("false"); expect(chatEvent?.commandExpressions.delete).toBe("false"); expect(chatEvent?.sequenceGrants).toEqual([ { name: "TeamChatEvent_sequence_seq", privilege: "USAGE", roles: ["hivegrid_app", "hivegrid_worker"], }, ]); expect(sql).toContain('CREATE POLICY "hg_TeamChatEvent_select" ON "TeamChatEvent"'); expect(sql).toContain('CREATE POLICY "hg_TeamChatEvent_insert" ON "TeamChatEvent"'); expect(sql).not.toContain('CREATE POLICY "hg_TeamChatEvent_update" ON "TeamChatEvent"'); expect(sql).not.toContain('CREATE POLICY "hg_TeamChatEvent_delete" ON "TeamChatEvent"'); expect(sql).toContain('DROP POLICY IF EXISTS "hg_TeamChatEvent_update" ON "TeamChatEvent";'); expect(sql).toContain('DROP POLICY IF EXISTS "hg_TeamChatEvent_delete" ON "TeamChatEvent";'); expect(sql).toContain('REVOKE ALL PRIVILEGES ON "TeamChatEvent" FROM PUBLIC, hivegrid_app, hivegrid_worker;'); expect(sql).toContain('GRANT SELECT, INSERT ON "TeamChatEvent" TO hivegrid_app;'); expect(sql).toContain('GRANT SELECT, INSERT ON "TeamChatEvent" TO hivegrid_worker;'); expect(sql).toContain('REVOKE ALL PRIVILEGES ON SEQUENCE "TeamChatEvent_sequence_seq" FROM PUBLIC, hivegrid_app, hivegrid_worker, hivegrid_authentik_jit;'); expect(sql).toContain('GRANT USAGE ON SEQUENCE "TeamChatEvent_sequence_seq" TO hivegrid_app, hivegrid_worker;'); expect(sql).not.toMatch(/GRANT\s+USAGE\s+ON\s+ALL\s+SEQUENCES/i); expect(runtimeContract).toContain('{ name: "hg_TeamChatEvent_select", command: "r", roles: ["hivegrid_app","hivegrid_worker"] }'); expect(runtimeContract).toContain('{ name: "hg_TeamChatEvent_insert", command: "a", roles: ["hivegrid_app","hivegrid_worker"] }'); expect(runtimeContract).not.toContain('{ name: "hg_TeamChatEvent_update"'); expect(runtimeContract).not.toContain('{ name: "hg_TeamChatEvent_delete"'); expect(runtimeContract).toContain('{ name: "TeamChatEvent_sequence_seq", privileges: ["USAGE"], roles: ["hivegrid_app","hivegrid_worker"] }'); }); it("fails closed when the append-only chat event contract is missing or widened", () => { const missing = inspectTenantPolicyContract(root, { appendOnlyTenantContract: {} }); expect(missing.ok).toBe(false); expect(missing.errors).toContain("append-only tenant model contract is missing TeamChatEvent"); const widened = inspectTenantPolicyContract(root, { appendOnlyTenantContract: { TeamChatEvent: { ...APPEND_ONLY_TENANT_MODEL_CONTRACT.TeamChatEvent, commands: { select: "tenant-only", insert: "tenant-only", update: "tenant-only", delete: "none" }, }, }, }); expect(widened.ok).toBe(false); expect(widened.errors).toContain("TeamChatEvent append-only contract must allow tenant-only SELECT and INSERT while denying UPDATE and DELETE"); const broadSequence = inspectTenantPolicyContract(root, { appendOnlyTenantContract: { TeamChatEvent: { ...APPEND_ONLY_TENANT_MODEL_CONTRACT.TeamChatEvent, sequence: { name: "TeamChatEvent_sequence_seq", privilege: "ALL", roles: ["hivegrid_app", "hivegrid_worker"] }, }, }, }); expect(broadSequence.ok).toBe(false); expect(broadSequence.errors).toContain( "TeamChatEvent append-only contract must grant only USAGE on TeamChatEvent_sequence_seq to hivegrid_app and hivegrid_worker" ); }); it("separates global platform RBAC from tenant role assignments", () => { const result = inspectTenantPolicyContract(root); const role = result.definitions.find((definition) => definition.model === "Role"); const rolePermission = result.definitions.find((definition) => definition.model === "RolePermission"); const userRole = result.definitions.find((definition) => definition.model === "UserRole"); expect(role?.commandExpressions.insert).toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); expect(rolePermission?.commandExpressions.insert).toContain('public.hivegrid_is_operator() AND "owner_0"."tenantId" IS NULL'); for (const command of ["insert", "update", "delete"]) { const expression = userRole?.commandExpressions[command]; expect(expression, command).toContain('"assignment_role"."type" = \'app\''); expect(expression, command).toContain('"assignment_role"."type" = \'admin\''); expect(expression, command).toContain("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(expression, command).toContain("public.hivegrid_is_operator()"); expect(userRole?.commandRoles[command], command).toEqual(["hivegrid_app"]); } expect(userRole?.commandExpressions.select).toContain("current_user = 'hivegrid_worker'"); expect(userRole?.commandExpressions.select).toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); }); it("keeps app outbox access immutable and exact while the worker remains global", () => { const result = inspectTenantPolicyContract(root); const outbox = result.definitions.find((definition) => definition.model === "OutboxEvent"); for (const command of ["select", "insert"]) { const expression = outbox?.commandExpressions[command]; expect(expression, command).toContain("current_user = 'hivegrid_app'"); expect(expression, command).toContain("current_user = 'hivegrid_worker'"); expect(expression, command).toContain("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(expression, command).toContain("\"eventType\" = 'workflow.trigger.event'"); expect(expression, command).toContain("jsonb_typeof(\"payload\") = 'object'"); expect(expression, command).toContain("NULLIF(BTRIM(\"payload\" ->> 'userId'), '')"); expect(expression, command).toContain("NULLIF(current_setting('app.user_id', true), '') IS NOT NULL"); } expect(outbox?.commandExpressions.update).toBe("current_user = 'hivegrid_worker'"); expect(outbox?.commandExpressions.delete).toBe("current_user = 'hivegrid_worker'"); expect(outbox?.commandRoles.update).toEqual(["hivegrid_worker"]); expect(outbox?.commandRoles.delete).toEqual(["hivegrid_worker"]); }); it("renders only an operator-checked aggregate capability for global outbox health", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_admin_outbox_counts()"); expect(sql).toContain("session_user <> 'hivegrid_app' OR NOT public.hivegrid_is_operator()"); expect(sql).toContain("COUNT(*) FILTER (WHERE outbox.\"status\" IN ('PENDING', 'PROCESSING'))"); expect(sql).toContain("REVOKE ALL ON FUNCTION public.hivegrid_admin_outbox_counts() FROM PUBLIC, hivegrid_app, hivegrid_worker, hivegrid_authentik_jit;"); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_admin_outbox_counts() TO hivegrid_app;"); expect(sql).not.toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_admin_outbox_counts() TO hivegrid_worker;"); }); it("keeps the plugin audit retention exception explicit and worker-only", () => { expect(Object.keys(DIRECT_WORKER_POLICY_CONTRACT)).toEqual([ "KwpApiContractSnapshot", "KwpCapabilityState", "KwpErrorReport", "PluginCapabilityUse", ]); const result = inspectTenantPolicyContract(root); const capabilityUse = result.definitions.find((definition) => definition.model === "PluginCapabilityUse"); expect(capabilityUse?.readExpression).toContain("current_user = 'hivegrid_worker'"); expect(capabilityUse?.writeExpression).toContain("current_user = 'hivegrid_worker'"); expect(capabilityUse?.readExpression).toContain("app.tenant_id"); expect(capabilityUse?.readExpression).not.toContain("current_user = 'hivegrid_app'"); }); it("gives operators read-only cross-tenant visibility into redacted KWP contract alarms", () => { const result = inspectTenantPolicyContract(root); for (const model of ["KwpApiContractSnapshot", "KwpCapabilityState", "KwpErrorReport"]) { const definition = result.definitions.find((candidate) => candidate.model === model); expect(definition?.commandExpressions.select, `${model}.select`).toContain("public.hivegrid_is_operator()"); for (const command of ["insert", "update", "delete"]) { expect(definition?.commandExpressions[command], `${model}.${command}`).not.toContain("hivegrid_is_operator"); expect(definition?.commandExpressions[command], `${model}.${command}`).toContain("app.tenant_id"); } } }); it("keeps webhook delivery tenant-bound while supporting the reviewed platform inbox", () => { const result = inspectTenantPolicyContract(root); const attempt = result.definitions.find((definition) => definition.model === "EventWebhookAttempt"); expect(attempt?.readExpression).toContain("public.hivegrid_is_operator()"); expect(attempt?.readExpression).toContain("current_user = 'hivegrid_worker'"); expect(attempt?.writeExpression).toContain("current_user = 'hivegrid_worker'"); expect(attempt?.writeExpression).toContain('"tenantId" IS NULL'); expect(attempt?.writeExpression).toContain("public.hivegrid_is_operator()"); }); it("gives the retention worker all-chain access while platform rows require an operator", () => { const result = inspectTenantPolicyContract(root); const auditEvent = result.definitions.find((definition) => definition.model === "AuditEvent"); const chainHead = result.definitions.find((definition) => definition.model === "AuditChainHead"); for (const definition of [auditEvent, chainHead]) { expect(definition?.readExpression).toContain("current_user = 'hivegrid_worker'"); expect(definition?.writeExpression).toContain("current_user = 'hivegrid_worker'"); expect(definition?.writeExpression).toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); } expect(auditEvent?.readExpression).toContain("OR public.hivegrid_is_operator()"); expect(auditEvent?.readExpression).not.toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); expect(chainHead?.readExpression).toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); const checkpoint = result.definitions.find((definition) => definition.model === "AuditChainCheckpoint"); expect(checkpoint?.readExpression).toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); expect(checkpoint?.writeExpression).not.toContain("hivegrid_is_operator"); expect(checkpoint?.writeExpression).toContain("current_user = 'hivegrid_worker'"); }); it("keeps cross-tenant admin audit readers read-only", () => { const result = inspectTenantPolicyContract(root); const log = result.definitions.find((definition) => definition.model === "Log"); const auditEvent = result.definitions.find((definition) => definition.model === "AuditEvent"); const apiKeyLog = result.definitions.find((definition) => definition.model === "ApiKeyLog"); for (const definition of [log, auditEvent, apiKeyLog]) { expect(definition?.commandExpressions.select, definition?.model).toContain("public.hivegrid_is_operator()"); expect(definition?.commandExpressions.select, definition?.model).not.toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); } for (const definition of [log, apiKeyLog]) { for (const command of ["insert", "update", "delete"]) { expect(definition?.commandExpressions[command], `${definition?.model}.${command}`).not.toContain("hivegrid_is_operator"); } } for (const command of ["insert", "update", "delete"]) { expect(auditEvent?.commandExpressions[command], `AuditEvent.${command}`).toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); } }); it("separates tenant idempotency rows from explicitly system-owned worker rows", () => { const result = inspectTenantPolicyContract(root); const idempotency = result.definitions.find((definition) => definition.model === "IdempotencyKey"); const checkout = result.definitions.find((definition) => definition.model === "CheckoutSessionStatus"); expect(idempotency?.scope).toBe("tenant-or-global"); expect(idempotency?.readExpression).toContain("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(idempotency?.readExpression).toContain("current_user = 'hivegrid_worker'"); expect(idempotency?.readExpression).toContain('"tenantId" IS NULL'); expect(idempotency?.readExpression).toContain('"systemOwned" = true'); expect(idempotency?.readExpression).toContain("NULLIF(current_setting('app.tenant_id', true), '') IS NULL"); expect(idempotency?.writeExpression).toBe(idempotency?.readExpression); expect(checkout?.scope).toBe("tenant-required"); expect(checkout?.readExpression).toBe("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(checkout?.writeExpression).toBe(checkout?.readExpression); }); it("keeps tenantless email-sequence operations worker and platform-operator scoped", () => { const result = inspectTenantPolicyContract(root); const sequence = result.definitions.find((definition) => definition.model === "EmailSequence"); const run = result.definitions.find((definition) => definition.model === "EmailSequenceRun"); const delivery = result.definitions.find((definition) => definition.model === "EmailSequenceStepDelivery"); for (const definition of [sequence, run, delivery]) { expect(definition?.readExpression).toContain("current_user = 'hivegrid_worker'"); expect(definition?.readExpression).toContain("public.hivegrid_is_operator()"); } expect(sequence?.writeExpression).toContain("public.hivegrid_is_operator()"); expect(sequence?.writeExpression).not.toContain("current_user = 'hivegrid_worker'"); expect(run?.writeExpression).toContain("current_user = 'hivegrid_worker'"); expect(run?.writeExpression).toContain("public.hivegrid_is_operator()"); expect(delivery?.writeExpression).toContain("current_user = 'hivegrid_worker'"); expect(delivery?.writeExpression).toContain("public.hivegrid_is_operator()"); expect(run?.readExpression).toContain("OR public.hivegrid_is_operator()"); expect(delivery?.readExpression).toContain("OR public.hivegrid_is_operator()"); }); it("keeps KB authoring operator-only while exposing only capability-bound published content", () => { const result = inspectTenantPolicyContract(root); const knowledgeBaseModels = [ "KnowledgeBase", "KnowledgeBaseCategory", "KnowledgeBaseCategorySection", "KnowledgeBaseArticle", "KnowledgeBaseRelatedArticle", "KnowledgeBaseViews", "KnowledgeBaseArticleViews", "KnowledgeBaseArticleUpvotes", "KnowledgeBaseArticleDownvotes", ]; for (const model of knowledgeBaseModels) { const definition = result.definitions.find((entry) => entry.model === model); expect(definition?.readExpression, model).toContain("public.hivegrid_is_operator()"); expect(definition?.writeExpression, model).toContain("public.hivegrid_is_operator()"); expect(definition?.readExpression, model).toContain('"tenantId" IS NULL'); expect(definition?.writeExpression, model).toContain('"tenantId" IS NULL'); expect(definition?.readExpression, model).toContain("app.public_knowledge_base_id"); expect(definition?.readExpression, model).toContain("current_user = 'hivegrid_app'"); } const byModel = Object.fromEntries(knowledgeBaseModels.map((model) => [model, result.definitions.find((entry) => entry.model === model)])); expect(byModel.KnowledgeBase?.readExpression).toContain('"KnowledgeBase"."enabled" = true'); expect(byModel.KnowledgeBase?.writeExpression).not.toContain("app.public_knowledge_base_id"); expect(byModel.KnowledgeBaseArticle?.readExpression).toContain('"KnowledgeBaseArticle"."publishedAt" IS NOT NULL'); expect(byModel.KnowledgeBaseArticle?.readExpression).toContain('"owner_0"."enabled" = true'); expect(byModel.KnowledgeBaseArticle?.writeExpression).not.toContain("app.public_knowledge_base_id"); expect(byModel.KnowledgeBaseRelatedArticle?.readExpression.match(/"publishedAt" IS NOT NULL/g)).toHaveLength(2); for (const model of ["KnowledgeBaseViews", "KnowledgeBaseArticleViews", "KnowledgeBaseArticleUpvotes", "KnowledgeBaseArticleDownvotes"]) { expect(byModel[model]?.writeExpression, model).toContain("app.public_knowledge_base_id"); expect(byModel[model]?.writeExpression, model).toContain("current_user = 'hivegrid_app'"); } for (const model of ["KnowledgeBaseArticleViews", "KnowledgeBaseArticleUpvotes", "KnowledgeBaseArticleDownvotes"]) { expect(byModel[model]?.writeExpression, model).toContain('"owner_0"."publishedAt" IS NOT NULL'); } }); it("limits isolated platform analytics to fully anonymous rows and reviewed commands", () => { const result = inspectTenantPolicyContract(root); const visitor = result.definitions.find((definition) => definition.model === "AnalyticsUniqueVisitor"); const childDefinitions = ["AnalyticsPageView", "AnalyticsEvent"].map((model) => result.definitions.find((definition) => definition.model === model)); for (const command of ["select", "insert", "update"]) { expect(visitor?.commandExpressions[command], command).toContain("app.platform_analytics"); expect(visitor?.commandExpressions[command], command).toContain('"AnalyticsUniqueVisitor"."userId" IS NULL'); expect(visitor?.commandExpressions[command], command).toContain('"AnalyticsUniqueVisitor"."portalId" IS NULL'); expect(visitor?.commandExpressions[command], command).toContain('"AnalyticsUniqueVisitor"."portalUserId" IS NULL'); } expect(visitor?.commandExpressions.delete).not.toContain("app.platform_analytics"); for (const definition of childDefinitions) { for (const command of ["select", "insert"]) { expect(definition?.commandExpressions[command], `${definition?.model}.${command}`).toContain("app.platform_analytics"); expect(definition?.commandExpressions[command], `${definition?.model}.${command}`).toContain('"platform_analytics_visitor"."userId" IS NULL'); expect(definition?.commandExpressions[command], `${definition?.model}.${command}`).toContain('"platform_analytics_visitor"."portalId" IS NULL'); expect(definition?.commandExpressions[command], `${definition?.model}.${command}`).toContain('"platform_analytics_visitor"."portalUserId" IS NULL'); } expect(definition?.commandExpressions.update, definition?.model).not.toContain("app.platform_analytics"); expect(definition?.commandExpressions.delete, definition?.model).not.toContain("app.platform_analytics"); } for (const definition of [visitor, ...childDefinitions]) { expect(definition?.commandExpressions.select, definition?.model).toContain("current_user = 'hivegrid_app'"); expect(definition?.commandExpressions.select, definition?.model).toContain("app.tenant_id', true), '') IS NULL"); expect(definition?.commandExpressions.select, definition?.model).toContain("app.user_id', true), '') IS NULL"); } }); it("fails closed if the platform analytics command contract expands", () => { const invalidDerivedContract = { ...DERIVED_OWNERSHIP_CONTRACT, AnalyticsEvent: { ...DERIVED_OWNERSHIP_CONTRACT.AnalyticsEvent, platformAnalytics: { kind: "anonymous-visitor-child", commands: ["select", "insert", "delete"] }, }, }; const result = inspectTenantPolicyContract(root, { derivedContract: invalidDerivedContract }); expect(result.ok).toBe(false); expect(result.errors).toContain("AnalyticsEvent platform analytics access must be anonymous-visitor-child with commands select, insert"); }); it("lets the platform webhook inbox resolve event ownership without granting cross-tenant event writes", () => { const result = inspectTenantPolicyContract(root); const event = result.definitions.find((entry) => entry.model === "Event"); const attempt = result.definitions.find((entry) => entry.model === "EventWebhookAttempt"); expect(event?.readExpression).toContain("public.hivegrid_is_operator()"); expect(event?.readExpression).not.toContain('"tenantId" IS NULL AND public.hivegrid_is_operator()'); expect(event?.writeExpression).not.toContain("public.hivegrid_is_operator()"); expect(attempt?.commandExpressions.select).toContain("public.hivegrid_is_operator()"); expect(attempt?.commandExpressions.update).toContain('public.hivegrid_is_operator() AND "owner_0"."tenantId" IS NULL'); }); it("makes app events owner-bound and immutable while preserving operator reads and worker mutation", () => { const result = inspectTenantPolicyContract(root); const event = result.definitions.find((entry) => entry.model === "Event"); expect(event?.commandExpressions.select).toContain("\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')"); expect(event?.commandExpressions.select).toContain('"tenantId" IS NULL AND "userId" IS NOT NULL'); expect(event?.commandExpressions.select).toContain("\"userId\" = NULLIF(current_setting('app.user_id', true), '')"); expect(event?.commandExpressions.select).toContain("public.hivegrid_is_operator()"); expect(event?.commandExpressions.select).toContain("current_user = 'hivegrid_worker'"); expect(event?.commandExpressions.insert).toContain( "\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '') AND (\"userId\" IS NULL OR \"userId\" = NULLIF(current_setting('app.user_id', true), ''))" ); expect(event?.commandExpressions.insert).toContain('"tenantId" IS NULL AND "userId" IS NOT NULL'); expect(event?.commandExpressions.insert).not.toContain("hivegrid_is_operator"); expect(event?.commandExpressions.update).toBe("current_user = 'hivegrid_worker'"); expect(event?.commandExpressions.delete).toBe("current_user = 'hivegrid_worker'"); expect(event?.commandRoles.update).toEqual(["hivegrid_worker"]); expect(event?.commandRoles.delete).toEqual(["hivegrid_worker"]); }); it("keeps admin notifications visible only to their exact AdminUser owner", () => { const result = inspectTenantPolicyContract(root); const delivery = result.definitions.find( (entry) => entry.model === "NotificationDelivery" ); expect(delivery?.commandExpressions.select).toContain( '"userId" = NULLIF(current_setting(\'app.user_id\', true), \'\')' ); expect(delivery?.commandExpressions.select).toContain( '"adminUserId" = NULLIF(current_setting(\'app.user_id\', true), \'\')' ); }); it("constrains every global workflow child through a live all-tenants parent", () => { const result = inspectTenantPolicyContract(root); const workflowChildren = ["WorkflowBlock", "WorkflowBlockConditionGroup", "WorkflowBlockCondition", "WorkflowBlockToBlock", "WorkflowInputExample"]; for (const model of workflowChildren) { const definition = result.definitions.find((entry) => entry.model === model); expect(definition?.readExpression, model).toContain("\"status\" = 'live'"); expect(definition?.readExpression, model).toContain('"appliesToAllTenants" = true'); expect(definition?.readExpression, model).toContain("current_user = 'hivegrid_worker'"); expect(definition?.writeExpression, model).not.toContain('"tenantId" IS NULL'); expect(definition?.writeExpression, model).not.toContain("current_user = 'hivegrid_worker'"); expect(definition?.commandExpressions.delete, model).toBe(definition?.writeExpression); } const blockExecution = result.definitions.find((entry) => entry.model === "WorkflowBlockExecution"); expect(blockExecution?.readExpression).toContain("\"status\" = 'live'"); expect(blockExecution?.readExpression).toContain('"appliesToAllTenants" = true'); expect(blockExecution?.writeExpression).toContain("\"status\" = 'live'"); expect(blockExecution?.writeExpression).toContain('"appliesToAllTenants" = true'); expect(blockExecution?.writeExpression).toContain("current_user = 'hivegrid_worker'"); expect(blockExecution?.writeExpression).toContain('"tenantId" IS NULL'); const workflow = result.definitions.find((entry) => entry.model === "Workflow"); expect(workflow?.commandExpressions.delete).toBe(workflow?.writeExpression); expect(workflow?.commandExpressions.delete).not.toContain('"tenantId" IS NULL'); expect(workflow?.commandExpressions.delete).not.toContain("current_user = 'hivegrid_worker'"); }); it("guards the exact reviewed global catalog and operator identity surface", () => { const result = inspectTenantPolicyContract(root); const guardedNames = Object.keys(GLOBAL_GUARDED_MODEL_CONTRACT).sort(); const guardedDefinitions = result.definitions.filter((definition) => definition.enforcement === "operator-write-policy"); expect(guardedNames).toHaveLength(14); expect(guardedNames).toEqual([ "App", "FeatureFlag", "FeatureFlagAudit", "FeatureFlagFilter", "Onboarding", "OnboardingFilter", "OnboardingStep", "Permission", "Subprocessor", "SubscriptionFeature", "SubscriptionPrice", "SubscriptionProduct", "SubscriptionUsageBasedPrice", "SubscriptionUsageBasedTier", ]); expect([...GLOBAL_GUARDED_EXTRA_MODELS].sort()).toEqual(["FeatureFlag", "FeatureFlagAudit", "FeatureFlagFilter"]); expect(guardedDefinitions.map(({ model }) => model).sort()).toEqual(guardedNames); for (const definition of guardedDefinitions) { expect(definition.commandExpressions.select, definition.model).toBe("true"); expect(definition.commandExpressions.insert, definition.model).toBe("public.hivegrid_is_operator()"); expect(definition.commandExpressions.update, definition.model).toBe("public.hivegrid_is_operator()"); expect(definition.commandExpressions.delete, definition.model).toBe("public.hivegrid_is_operator()"); expect(definition.commandRoles.select, definition.model).toEqual(["hivegrid_app", "hivegrid_worker"]); expect(definition.commandRoles.insert, definition.model).toEqual(["hivegrid_app"]); } const adminUser = result.definitions.find((definition) => definition.model === "AdminUser"); expect(adminUser?.forceRls).toBe(true); expect(adminUser?.commandRoles.select).toEqual(["hivegrid_app"]); expect(new Set(Object.values(adminUser?.commandExpressions ?? {}))).toEqual(new Set(["public.hivegrid_is_operator()"])); }); it("fails closed when guarded global coverage drifts", () => { const { Permission: _permission, ...missingPermission } = GLOBAL_GUARDED_MODEL_CONTRACT; const result = inspectTenantPolicyContract(root, { globalGuardContract: missingPermission }); expect(result.ok).toBe(false); expect(result.errors).toContain("global guarded model contract is missing Permission"); expect(result.errors).toContain( `reviewed policy definition baseline changed: expected ${EXPECTED_POLICY_DEFINITION_COUNT}, discovered ${EXPECTED_POLICY_DEFINITION_COUNT - 1}` ); }); it("requires an explicit fail-closed contract for every global-shared model", () => { const result = inspectTenantPolicyContract(root); const globalSharedNames = [...TENANT_SCOPE_GROUPS["global-shared"]].sort(); const definitions = result.definitions.filter((definition) => definition.scope === "global-shared"); expect(Object.keys(GLOBAL_SHARED_POLICY_CONTRACT).sort()).toEqual(globalSharedNames); expect(definitions.map(({ model }) => model).sort()).toEqual(globalSharedNames); const { BillingWebhookLog: _billingWebhookLog, ...missingContract } = GLOBAL_SHARED_POLICY_CONTRACT; const missing = inspectTenantPolicyContract(root, { globalSharedContract: missingContract }); expect(missing.ok).toBe(false); expect(missing.errors).toContain("global-shared policy contract is missing BillingWebhookLog"); expect(missing.errors).toContain( `reviewed policy definition baseline changed: expected ${EXPECTED_POLICY_DEFINITION_COUNT}, discovered ${EXPECTED_POLICY_DEFINITION_COUNT - 1}` ); }); it("grants only the reviewed global-shared commands", () => { const result = inspectTenantPolicyContract(root); const byModel = Object.fromEntries( result.definitions.filter((definition) => definition.scope === "global-shared").map((definition) => [definition.model, definition]) ); for (const model of ["FileUploadProgress", "FileChunk", "FileObject", "Credential"]) { expect(byModel[model].commandRoles, model).toEqual({ select: [], insert: [], update: [], delete: [] }); expect(byModel[model].commandExpressions, model).toEqual({ select: "false", insert: "false", update: "false", delete: "false" }); } expect(byModel.BillingWebhookLog.commandRoles).toEqual({ select: ["hivegrid_app"], insert: [], update: [], delete: [] }); expect(byModel.BillingWebhookLog.commandExpressions.select).toBe("public.hivegrid_is_operator()"); expect(byModel.AnalyticsSettings.commandRoles).toEqual({ select: ["hivegrid_app", "hivegrid_worker"], insert: ["hivegrid_app"], update: ["hivegrid_app"], delete: ["hivegrid_app"], }); expect(byModel.McpOAuthClient.commandRoles.select).toEqual(["hivegrid_app"]); expect(byModel.McpOAuthClient.commandExpressions.select).toContain('"active" = true'); expect(byModel.McpOAuthClient.commandExpressions.select).toContain("hivegrid_is_operator"); }); it("protects every platform-admin model with its reviewed command policy", () => { const result = inspectTenantPolicyContract(root); const expectedPlatformModels = TENANT_SCOPE_GROUPS["platform-admin"].filter((model) => model !== "AdminUser").sort(); const platformDefinitions = result.definitions .filter((definition) => definition.scope === "platform-admin" && definition.model !== "AdminUser") .sort((left, right) => left.model.localeCompare(right.model)); expect(Object.keys(PLATFORM_ADMIN_POLICY_CONTRACT).sort()).toEqual(expectedPlatformModels); expect(platformDefinitions.map(({ model }) => model)).toEqual(expectedPlatformModels); expect(platformDefinitions).toHaveLength(expectedPlatformModels.length); expect(platformDefinitions.every((definition) => definition.forceRls === true)).toBe(true); const byModel = Object.fromEntries(platformDefinitions.map((definition) => [definition.model, definition])); expect(byModel.AdminTenantNote.commandExpressions.select).toContain("app.tenant_id"); expect(byModel.AdminTenantNote.commandExpressions.select).toContain("hivegrid_is_operator"); expect(byModel.AdminTenantNote.commandExpressions.select).toContain(" AND "); for (const model of ["Feedback", "SupportTicket"]) { expect(byModel[model].commandExpressions.select, model).toContain("app.tenant_id"); expect(byModel[model].commandExpressions.select, model).toContain("app.user_id"); expect(byModel[model].commandExpressions.insert, model).toContain('"tenantId" IS NULL'); expect(byModel[model].commandExpressions.insert, model).toContain('"userId" IS NULL'); expect(byModel[model].commandRoles.insert, model).toEqual(["hivegrid_app"]); expect(byModel[model].commandExpressions.update, model).toBe(byModel[model].commandExpressions.select); expect(byModel[model].updateCheckExpression, model).toContain('"tenantId" IS NULL'); expect(byModel[model].updateCheckExpression, model).toContain('"userId" IS NULL'); expect(byModel[model].updateCheckExpression, model).toContain('FROM "TenantUser" AS "platform_target_membership"'); expect(byModel[model].updateCheckExpression, model).toContain(`"platform_target_membership"."tenantId" = "${model}"."tenantId"`); expect(byModel[model].updateCheckExpression, model).toContain(`"platform_target_membership"."userId" = "${model}"."userId"`); expect(byModel[model].updateCheckExpression, model).toContain("hivegrid_is_operator"); } expect(new Set(Object.values(byModel.ImpersonationAudit.commandExpressions))).toEqual(new Set(["public.hivegrid_is_operator()"])); for (const command of ["select", "insert", "update"]) { expect(byModel.AdminLead.commandExpressions[command], `AdminLead.${command}`).toContain( "public.hivegrid_admin_has_permission" ); expect(byModel.AdminLead.commandExpressions[command], `AdminLead.${command}`).toContain( '"AdminLead"."assignedToAdminUserId"' ); } expect(byModel.AdminLead.commandExpressions.select).toContain("admin_sales.crm.read_all"); expect(byModel.AdminLead.commandExpressions.insert).toContain("admin_sales.crm.write_all"); for (const model of ["AdminLeadSource", "AdminLeadSourceCredential"]) { expect(byModel[model].commandExpressions.select, model).toContain("admin_sales.crm.read"); expect(byModel[model].commandExpressions.insert, model).toContain("admin_sales.crm.write"); expect(byModel[model].commandExpressions.update, model).toContain("admin_sales.crm.write"); } for (const model of ["Lead", "LeadEvent"]) { expect(byModel[model].commandExpressions.select, model).toBe("public.hivegrid_is_operator()"); for (const command of ["insert", "update", "delete"]) { expect(byModel[model].commandExpressions[command], `${model}.${command}`).toBe("false"); expect(byModel[model].commandRoles[command], `${model}.${command}`).toEqual([]); } } for (const model of ["AdminLead", "AdminLeadSource", "AdminLeadSourceCredential"]) { expect(byModel[model].commandExpressions.delete, model).toBe("false"); expect(byModel[model].commandRoles.delete, model).toEqual([]); } expect(byModel.AdminLeadActivity.commandExpressions.select).toContain("admin_sales.crm.read"); expect(byModel.AdminLeadActivity.commandExpressions.select).toContain('FROM "AdminLead"'); expect(byModel.AdminLeadActivity.commandExpressions.select).toContain('"assignedToAdminUserId"'); expect(byModel.AdminLeadActivity.commandExpressions.select).toContain("admin_sales.crm.read_all"); expect(byModel.AdminLeadActivity.commandExpressions.insert).toContain("\"actorAdminUserId\" = NULLIF(current_setting('app.user_id'"); expect(byModel.AdminLeadActivity.commandExpressions.insert).toContain("admin_sales.crm.write_all"); expect(byModel.AdminLeadActivity.commandExpressions.insert).toContain("legacy-activity:%"); expect(byModel.AdminLeadActivity.commandExpressions.insert).toContain("legacy_import_parent"); expect(byModel.AdminLeadActivity.commandExpressions.insert).toContain("public.hivegrid_is_operator()"); expect(byModel.AdminLeadActivity.commandExpressions.update).toBe("false"); expect(byModel.AdminLeadActivity.commandExpressions.delete).toBe("false"); expect(byModel.AdminLeadActivity.commandRoles.update).toEqual([]); expect(byModel.AdminLeadActivity.commandRoles.delete).toEqual([]); for (const model of ["AdminDealContact", "AdminDealStageHistory"]) { expect(byModel[model].commandExpressions.select, model).toContain('FROM "AdminDeal"'); expect(byModel[model].commandExpressions.select, model).toContain('"ownerAdminUserId"'); expect(byModel[model].commandExpressions.select, model).toContain("admin_sales.crm.read_all"); expect(byModel[model].commandExpressions.insert, model).toContain("admin_sales.crm.write_all"); } for (const model of ["AdminTask", "AdminTaskRecurrence"]) { expect(byModel[model].commandExpressions.select, model).toContain("admin_sales.crm.read_all"); expect(byModel[model].commandExpressions.insert, model).toContain("admin_sales.crm.write_all"); expect(byModel[model].commandExpressions.insert, model).toContain("current_user = 'hivegrid_worker'"); } expect(byModel.AdminCustomFieldValue.commandExpressions.select).toContain('FROM "AdminDeal"'); expect(byModel.AdminCustomFieldValue.commandExpressions.select).toContain('"dealId" IS NULL'); expect(byModel.AdminLeadQualification.commandExpressions.select).toContain('FROM "AdminLead"'); expect(byModel.AdminDuplicateCandidate.commandExpressions.select.match(/FROM "AdminLead"/g)).toHaveLength(2); expect(byModel.AdminMergeRecord.commandExpressions.select.match(/FROM "AdminLead"/g)).toHaveLength(2); expect(byModel.AdminActivity.commandExpressions.select).toContain('FROM "AdminEmailMessage"'); expect(byModel.AdminActivity.commandExpressions.select).toContain('FROM "AdminCallSession"'); expect(byModel.AdminActivity.commandExpressions.select).toContain('FROM "AdminBooking"'); expect(byModel.AdminActivity.commandExpressions.select).toContain("admin_sales.communication.read_all"); expect(byModel.MarketingIntegration.commandRoles.select).toEqual(["hivegrid_app", "hivegrid_worker"]); expect(byModel.MarketingIntegration.commandRoles.insert).toEqual(["hivegrid_app"]); expect(byModel.MarketingIntegration.commandRoles.update).toEqual(["hivegrid_app", "hivegrid_worker"]); expect(byModel.MarketingIntegration.commandRoles.delete).toEqual(["hivegrid_app"]); expect(byModel.QueueFailedJob.commandRoles.select).toEqual(["hivegrid_app", "hivegrid_worker"]); expect(byModel.QueueFailedJob.commandRoles.insert).toEqual(["hivegrid_worker"]); expect(byModel.QueueFailedJob.commandRoles.update).toEqual(["hivegrid_worker"]); expect(byModel.QueueFailedJob.commandRoles.delete).toEqual(["hivegrid_app", "hivegrid_worker"]); for (const command of ["select", "insert", "update", "delete"]) { expect(byModel.SupportTicketMessage.commandExpressions[command], command).toContain('"internalNote" = false'); expect(byModel.SupportTicketMessage.commandExpressions[command], command).toContain('FROM "SupportTicket"'); expect(byModel.SupportTicketMessage.commandExpressions[command], command).toContain("app.tenant_id"); expect(byModel.TenantAcquisition.commandRoles[command], command).toEqual(["hivegrid_app", "hivegrid_worker"]); } }); it("fails closed if any platform-admin policy is removed", () => { const { Feedback: _feedback, ...missingFeedback } = PLATFORM_ADMIN_POLICY_CONTRACT; const result = inspectTenantPolicyContract(root, { platformContract: missingFeedback }); expect(result.ok).toBe(false); expect(result.errors).toContain("platform admin policy contract is missing Feedback"); expect(result.errors).toContain( `reviewed policy definition baseline changed: expected ${EXPECTED_POLICY_DEFINITION_COUNT}, discovered ${EXPECTED_POLICY_DEFINITION_COUNT - 1}` ); }); it("keeps the exact twenty-nine bootstrap resolvers narrow and read-only", () => { const result = inspectTenantPolicyContract(root); const queries = Object.fromEntries(result.resolvers.map((resolver) => [resolver.name, resolver.query])); expect(result.resolvers.map(({ name }) => name)).toEqual(EXPECTED_TENANT_RESOLVER_NAMES); expect(Object.keys(TENANT_RESOLVER_CONTRACT)).toEqual(EXPECTED_TENANT_RESOLVER_NAMES); expect(result.resolvers).toHaveLength(29); for (const resolver of result.resolvers) { expect(resolver.query, resolver.name).toMatch(/^(SELECT|WITH)\b/); expect(resolver.query, resolver.name).not.toMatch(/;|\b(?:INSERT|UPDATE|DELETE|GRANT|REVOKE|ALTER|DROP|CREATE)\b/i); expect(resolver.query, resolver.name).toContain("AS tenant_id"); expect(resolver.query, resolver.name).toContain("AS resource_id"); expect(resolver.query, resolver.name).toContain("AS user_id"); } expect(queries.hivegrid_resolve_user_email).toContain('lower(trim(user_row."email")) = lower(trim(p_email))'); expect(queries.hivegrid_resolve_user_email).toContain("HAVING count(*) = 1"); expect(queries.hivegrid_resolve_user_email).toContain("LIMIT 2"); expect(queries.hivegrid_resolve_user_email).not.toContain('user_row."email" = p_email'); expect(queries.hivegrid_resolve_admin_sso_identity_v2).toContain('admin_row."authentikSubject" = trim(p_subject)'); expect(queries.hivegrid_resolve_admin_sso_identity_v2).toContain('admin_row."status" = \'active\''); expect(queries.hivegrid_resolve_admin_session_identity).toContain('session_row."tokenHash" = p_token_hash'); expect(queries.hivegrid_resolve_admin_session_identity).toContain('session_row."expiresAt" > clock_timestamp()'); expect(queries.hivegrid_resolve_admin_booking_page).toContain('page_row."published" = true'); expect(queries.hivegrid_resolve_admin_booking_page).toContain('page_row."createdByAdminUserId"::text AS user_id'); expect(queries.hivegrid_resolve_admin_booking_page).toContain('admin_row."status" = \'active\''); expect(queries.hivegrid_resolve_user_session).toContain('session_row."tokenHash" = p_token_hash'); expect(queries.hivegrid_resolve_user_session).toContain('session_row."revokedAt" IS NULL'); expect(queries.hivegrid_resolve_trusted_device).toContain('device_row."tokenHash" = p_token_hash'); expect(queries.hivegrid_resolve_trusted_device).toContain('device_row."expiresAt" > CURRENT_TIMESTAMP'); expect(queries.hivegrid_resolve_public_form_key).toContain('form_row."key" = p_key'); expect(queries.hivegrid_resolve_public_form_key).toContain('form_row."isEnabled" = true'); const formSlug = queries.hivegrid_resolve_public_form_slug; for (const predicate of [ 'tenant_row."slug" = p_tenant_slug', 'tenant_row."active" = true', 'form_row."slug" = p_form_slug', 'form_row."isEnabled" = true', 'form_row."isPublic" = true', "form_row.\"status\" = 'published'", ]) { expect(formSlug).toContain(predicate); } const booking = queries.hivegrid_resolve_public_booking_page; for (const predicate of ['tenant_row."active" = true', 'page_row."slug" = p_page_slug', 'page_row."isPublished" = true', 'page_row."archivedAt" IS NULL']) { expect(booking).toContain(predicate); } const calendarWebhook = queries.hivegrid_resolve_calendar_webhook; expect(calendarWebhook).toContain('connection_row."webhookSubscriptionId" = p_channel_id'); expect(calendarWebhook).toContain('connection_row."id" = p_channel_token'); expect(calendarWebhook).toContain("connection_row.\"status\" = 'active'"); const aircallWebhook = queries.hivegrid_resolve_aircall_webhook; expect(aircallWebhook).toContain('connection_row."webhookTokenHash" = p_token_hash'); expect(aircallWebhook).toContain('data_connection."tenantId" = connection_row."tenantId"'); expect(aircallWebhook).toContain("data_connection.\"appId\" = 'aircall'"); expect(aircallWebhook).toContain("data_connection.\"connectionStatus\" IN ('active', 'degraded')"); const hallopetraWebhook = queries.hivegrid_resolve_hallopetra_webhook; expect(hallopetraWebhook).toContain('connection_row."webhookTokenHash" = p_token_hash'); expect(hallopetraWebhook).toContain('data_connection."tenantId" = connection_row."tenantId"'); expect(hallopetraWebhook).toContain("connection_row.\"provider\" = 'hallopetra'"); expect(hallopetraWebhook).toContain("data_connection.\"appId\" = 'hallopetra'"); expect(hallopetraWebhook).toContain("data_connection.\"connectionStatus\" IN ('active', 'degraded')"); const adminAircallWebhook = queries.hivegrid_resolve_admin_aircall_webhook; expect(adminAircallWebhook).toContain('phone_connection."webhookTokenHash" = p_token_hash'); expect(adminAircallWebhook).toContain('data_connection."adminUserId" = phone_connection."adminUserId"'); expect(adminAircallWebhook).toContain("data_connection.\"provider\" = 'aircall'"); expect(adminAircallWebhook).toContain("data_connection.\"capability\" = 'telephony'"); expect(adminAircallWebhook).toContain("admin_row.\"status\" = 'active'"); const gmail = queries.hivegrid_resolve_gmail_mailboxes; expect(gmail).toContain("p_provider = 'gmail'"); expect(gmail).toContain('mailbox_row."provider"::text = p_provider'); expect(gmail).toContain('lower(btrim(mailbox_row."emailAddress")) = p_email'); expect(gmail).toContain("count(*) BETWEEN 1 AND 25"); expect(gmail).not.toContain("LIMIT 1"); const microsoft = queries.hivegrid_resolve_microsoft_mailbox; expect(microsoft).toContain('mailbox_row."webhookSubscriptionId" = p_subscription_id'); expect(microsoft).toContain('mailbox_row."webhookClientState" = p_client_state'); expect(queries.hivegrid_resolve_signature_signer).toContain('signer_row."accessTokenHash" = p_access_token_hash'); expect(queries.hivegrid_resolve_outbound_email_click).toContain('email_row."id" = p_outbound_email_id'); expect(queries.hivegrid_resolve_outbound_email_click).not.toContain("trackingToken"); expect(queries.hivegrid_resolve_outbound_email_open).toContain('email_row."trackingToken" = p_tracking_token'); const invite = queries.hivegrid_resolve_workspace_invite; expect(invite).toContain("p_token_hash IS NOT NULL"); expect(invite).toContain('invitation_row."tokenHash" = p_token_hash'); expect(invite).toContain('invitation_row."expiresAt" IS NOT NULL'); expect(invite).toContain('invitation_row."expiresAt" > CURRENT_TIMESTAMP'); expect(invite).toContain("invitation_row.\"status\" = 'pending'"); expect(invite).toContain('invitation_row."pending" = true'); expect(invite).toContain("invitation_row.\"status\" = 'accepted'"); expect(invite).toContain('invitation_row."pending" = false'); expect(invite).toContain('invitation_row."type" = 0'); expect(invite).toContain('invitation_row."acceptedByUserId" IS NOT NULL'); expect(invite).toContain('invitation_row."revokedAt" IS NULL'); expect(invite).not.toContain("invitation_row.\"status\" = 'revoked'"); const apiKey = queries.hivegrid_resolve_api_key; expect(apiKey).toContain('key_row."keyHash" = p_key_hash'); expect(apiKey).toContain('p_plaintext IS NOT NULL AND key_row."key" = p_plaintext'); expect(apiKey).toContain('key_row."createdByUserId"::text AS user_id'); const publicWebhook = queries.hivegrid_resolve_public_webhook; for (const predicate of [ 'tenant_row."id" = p_tenant OR tenant_row."slug" = p_tenant', 'tenant_row."active" = true', 'endpoint_row."tenantId" = tenant_row."id"', 'endpoint_row."slug" = p_slug', 'endpoint_row."archivedAt" IS NULL', "endpoint_row.\"status\" = 'active'", ]) { expect(publicWebhook).toContain(predicate); } for (const name of ["hivegrid_resolve_mcp_oauth_access_token", "hivegrid_resolve_mcp_oauth_refresh_token"]) { expect(queries[name], name).toContain('token_row."tokenHash" = p_token_hash'); expect(queries[name], name).toContain('token_row."userId"::text AS user_id'); } expect(queries.hivegrid_resolve_mcp_oauth_authorization_code).toContain('code_row."codeHash" = p_token_hash'); expect(queries.hivegrid_resolve_mcp_oauth_authorization_code).toContain('code_row."userId"::text AS user_id'); const inbound = queries.hivegrid_resolve_tenant_inbound_address; expect(inbound).toContain('address_row."archivedAt" IS NULL'); expect(inbound).toContain('address_row."address" = ANY (p_addresses)'); expect(inbound).toContain('address_row."fullAddress" = ANY (p_addresses)'); expect(inbound).toContain('count(DISTINCT matches."tenantId") = 1'); expect(inbound).toContain('ORDER BY matches."id"'); const provider = queries.hivegrid_resolve_email_sequence_provider_message; expect(provider).toContain('delivery_row."providerMessageId" = p_provider_message_id'); expect(provider).toContain('run_row."tenantId" IS NOT NULL'); expect(provider).toContain('count(DISTINCT matches."tenantId") = 1'); expect(queries.hivegrid_resolve_event_webhook_attempt).toContain('attempt_row."id" = p_attempt_id'); expect(queries.hivegrid_resolve_event_webhook_attempt).toContain('event_row."tenantId" IS NOT NULL'); expect(queries.hivegrid_resolve_email_sequence_delivery).toContain('delivery_row."id" = p_delivery_id'); expect(queries.hivegrid_resolve_email_sequence_delivery).toContain('run_row."tenantId" IS NOT NULL'); expect(queries.hivegrid_resolve_public_knowledge_base).toContain('knowledge_base."tenantId" IS NULL'); expect(queries.hivegrid_resolve_public_knowledge_base).toContain('knowledge_base."enabled" = true'); }); it("renders every resolver as a fixed SECURITY DEFINER function with execute-only bootstrap access", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); const resolverSection = sql.slice(sql.indexOf("-- Bootstrap resolvers expose only"), sql.indexOf("-- Refuse the cutover if legacy rows")); const resolverCount = EXPECTED_TENANT_RESOLVER_NAMES.length; expect(resolverSection.match(/SECURITY DEFINER/g) ?? []).toHaveLength(resolverCount); expect(resolverSection.match(/SET search_path = pg_catalog, public/g) ?? []).toHaveLength(resolverCount); expect(resolverSection.match(/SET row_security = off/g) ?? []).toHaveLength(resolverCount); expect(resolverSection.match(/REVOKE ALL ON FUNCTION/g) ?? []).toHaveLength(resolverCount); expect(resolverSection.match(/FROM PUBLIC, hivegrid_app, hivegrid_worker, hivegrid_authentik_jit/g) ?? []).toHaveLength(resolverCount); expect(resolverSection.match(/GRANT EXECUTE ON FUNCTION/g) ?? []).toHaveLength(resolverCount); expect(resolverSection.match(/TO hivegrid_app;/g) ?? []).toHaveLength(resolverCount); expect(resolverSection).not.toMatch(/GRANT\s+(?:SELECT|INSERT|UPDATE|DELETE)\s+ON/i); expect(resolverSection).not.toMatch(/GRANT EXECUTE[^;]+hivegrid_worker/); expect(resolverSection).toContain('public."hivegrid_resolve_api_key"("p_key_hash" text, "p_plaintext" text DEFAULT NULL)'); expect(resolverSection).toContain('public."hivegrid_resolve_admin_sso_identity_v2"("p_subject" text)'); expect(resolverSection).toContain('public."hivegrid_resolve_admin_session_identity"("p_token_hash" text)'); }); it("renders fail-closed prepared-AdminUser binding through its dedicated database capability", () => { const result = inspectTenantPolicyContract(root); const sql = renderTenantPolicySql(result); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_bind_prepared_authentik_admin_v3("); expect(sql).toContain("session_user <> 'hivegrid_authentik_jit'"); expect(sql).toContain("p_email_verified IS DISTINCT FROM true"); expect(sql).toContain("p_groups && ARRAY['hivegrid-admin', 'hivegrid-staff']::text[]"); expect(sql).toContain("pg_advisory_xact_lock(hashtextextended('authentik-prepared-admin-sub:'"); expect(sql).toContain('WHERE lower(admin_row."email") = normalized_email'); expect(sql).toContain('AND admin_row."status" = \'active\''); const bindingFunction = sql.match(/CREATE OR REPLACE FUNCTION public\.hivegrid_bind_prepared_authentik_admin_v3\([\s\S]+?\$function\$;/)?.[0] ?? ""; expect(bindingFunction).not.toContain('INSERT INTO public."AdminUser"'); expect(bindingFunction).not.toContain('SET "email" ='); expect(bindingFunction).not.toContain('"disabledAt" = NULL'); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_lock_admin_sso_audit_head()"); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_append_admin_sso_audit("); expect(sql).toContain("p_event->>'sourceModule' IS DISTINCT FROM 'admin-sso'"); expect(sql).toContain( "GRANT EXECUTE ON FUNCTION public.hivegrid_bind_prepared_authentik_admin_v3(text,text,boolean,text[],text,text,text,timestamptz) TO hivegrid_authentik_jit;" ); expect(sql).not.toContain( "GRANT EXECUTE ON FUNCTION public.hivegrid_bind_prepared_authentik_admin_v3(text,text,boolean,text[],text,text,text,timestamptz) TO hivegrid_app;" ); expect(sql).toContain( "('public.hivegrid_bind_prepared_authentik_admin_v3(text,text,boolean,text[],text,text,text,timestamp with time zone)', false, false, true)" ); expect(sql).not.toMatch( /GRANT EXECUTE ON FUNCTION public\.hivegrid_(?:bind_prepared_authentik_admin_v3|lock_admin_sso_audit_head|append_admin_sso_audit)[^;]+hivegrid_worker/ ); expect(sql).toContain( 'GRANT INSERT ON "Registration", "Blacklist", "IpAddress", "IpAddressLog", "McpOAuthClient", "User", "AdminUser", "AuditEvent", "AuditChainHead", "Lead", "LeadEvent", "TenantAcquisition", "AdminLead", "AdminLeadActivity", "IdempotencyKey", "OutboxEvent", "NotificationDelivery" TO hivegrid_rls_definer;' ); }); it("resolves AdminRBAC permissions inside forced-RLS policies", () => { const result = inspectTenantPolicyContract(root); const sql = renderTenantPolicySql(result); const permissionFunction = sql.match( /CREATE OR REPLACE FUNCTION public\.hivegrid_admin_has_permission\(p_permission text\)[\s\S]+?\$function\$;/ )?.[0] ?? ""; expect(permissionFunction).toContain("SECURITY DEFINER"); expect(permissionFunction).toContain("SET row_security = off"); expect(permissionFunction).toContain("session_user = 'hivegrid_app'"); expect(permissionFunction).toContain('permission_admin."status" = \'active\''); expect(permissionFunction).toContain('role."active" = true'); expect(permissionFunction).toContain('permission."name" = p_permission'); expect(sql).toContain( "REVOKE ALL ON FUNCTION public.hivegrid_admin_has_permission(text) FROM PUBLIC, hivegrid_authentik_jit;" ); expect(sql).toContain( "GRANT EXECUTE ON FUNCTION public.hivegrid_admin_has_permission(text) TO hivegrid_app, hivegrid_worker;" ); expect(sql).toContain( "('public.hivegrid_admin_has_permission(text)', true, true, false)" ); }); it("enforces platform admin audit rows as append-only at the database boundary", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_reject_admin_audit_mutation()"); expect(sql).toContain("IF OLD.\"tenantId\" IS NULL AND OLD.\"actorType\" = 'admin' THEN"); expect(sql).toContain("RAISE EXCEPTION 'Platform admin audit events are append-only' USING ERRCODE = '42501'"); expect(sql).toContain('CREATE TRIGGER "hg_AuditEvent_admin_append_only"'); expect(sql).toContain('BEFORE UPDATE OR DELETE ON public."AuditEvent"'); expect(sql).toContain( 'GRANT EXECUTE ON FUNCTION public.hivegrid_reject_admin_audit_mutation() TO hivegrid_migrator;\nRESET ROLE;\nDROP TRIGGER IF EXISTS "hg_AuditEvent_admin_append_only" ON public."AuditEvent";\nCREATE TRIGGER "hg_AuditEvent_admin_append_only"' ); expect(sql).toContain( 'FOR EACH ROW EXECUTE FUNCTION public.hivegrid_reject_admin_audit_mutation();\nSET LOCAL ROLE hivegrid_rls_definer;\nREVOKE EXECUTE ON FUNCTION public.hivegrid_reject_admin_audit_mutation() FROM hivegrid_migrator;' ); expect(sql).toContain( "REVOKE ALL ON FUNCTION public.hivegrid_reject_admin_audit_mutation() FROM PUBLIC, hivegrid_app, hivegrid_worker, hivegrid_authentik_jit;" ); expect(sql).toContain("('public.hivegrid_reject_admin_audit_mutation()', false, false, false)"); }); it("renders source-scoped platform-lead capabilities without granting the app role direct anonymous access", () => { const result = inspectTenantPolicyContract(root); const sql = renderTenantPolicySql(result); const adminLead = result.definitions.find((definition) => definition.model === "AdminLead"); const captureSql = sql.slice( sql.indexOf("CREATE OR REPLACE FUNCTION public.hivegrid_capture_admin_lead("), sql.indexOf("ALTER FUNCTION public.hivegrid_authenticate_admin_lead_source(text)") ); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_authenticate_admin_lead_source(p_credential_hash text)"); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_enqueue_admin_lead_audit("); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_capture_admin_lead("); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_resolve_platform_lead_notification_recipient("); expect(sql).toContain("session_user <> 'hivegrid_app'"); expect(sql).toContain('credential."keyHash" = p_credential_hash'); expect(sql).toContain('credential."sourceId" = p_source_id'); expect(sql).toContain("pg_advisory_xact_lock(hashtextextended(scope_key || ':' || p_idempotency_key"); expect(sql).toContain("'platform-lead-external:' || source_row.\"id\" || ':'"); expect(captureSql.indexOf('SET "lastUsedAt" = now_at')).toBeGreaterThan( captureSql.indexOf("pg_advisory_xact_lock(hashtextextended(scope_key || ':' || p_idempotency_key") ); expect(sql).toContain("'platform-leads:' || source_row.\"id\""); expect(sql).toContain("RETURN existing_idempotency.\"responseBody\" || jsonb_build_object('outcome', 'replayed')"); expect(sql).toContain("'platform.admin_lead.captured.v1'"); expect(sql).toContain("'audit.event.create'"); expect(sql).toContain("'notification.platform.requested.v1'"); expect(sql).toContain("'platform.leads.captured'"); expect(sql).toContain('ON CONFLICT ("userId", "channel", "sourceKey") WHERE "tenantId" IS NULL'); expect(sql).toContain("'platform-notification:' || delivery_id"); expect(sql).toContain('source_row."notifyAdminUserIds"'); expect(sql).toContain('cardinality(COALESCE(source_row."notifyAdminUserIds", ARRAY[]::text[])) NOT BETWEEN 1 AND 20'); expect(sql).toContain("p_credential_hash IS NULL OR p_credential_hash !~ '^[0-9a-f]{64}$'"); expect(sql).toContain("p_lead_id !~ '^[A-Za-z0-9_-]+$'"); expect(sql).toContain("regexp_replace(p_input->>'phone', '[^0-9]', '', 'g')"); expect(sql).toContain("regexp_replace(p_reason, E'[\\t\\n\\r]', '', 'g') ~ '[[:cntrl:]]'"); expect(sql).not.toContain("lead_event_metadata := jsonb_build_object('email'"); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_capture_admin_lead(text,text,text,text,text,text,jsonb) TO hivegrid_app;"); expect(sql).toContain( "GRANT EXECUTE ON FUNCTION public.hivegrid_enqueue_admin_lead_audit(text,text,text,text,text,text,text,text,text,text,jsonb,jsonb) TO hivegrid_app;" ); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_resolve_platform_lead_notification_recipient(text,text) TO hivegrid_worker;"); expect(sql).not.toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_resolve_platform_lead_notification_recipient(text,text) TO hivegrid_app;"); expect(sql).toContain('operator_admin."status" = \'active\''); expect(sql).toContain('FROM public."AdminUserRole" AS assignment'); expect(sql).toContain("permission.\"name\" = 'admin_sales.crm.read'"); expect(sql).toContain("('public.hivegrid_resolve_platform_lead_notification_recipient(text,text)', false, true, false)"); expect(sql).not.toMatch( /GRANT EXECUTE ON FUNCTION public\.hivegrid_(?:authenticate_admin_lead_source|enqueue_admin_lead_audit|capture_admin_lead)[^;]+hivegrid_worker/u ); expect(adminLead?.commandExpressions.insert).toContain("public.hivegrid_is_operator()"); expect(adminLead?.commandExpressions.insert).toContain("admin_sales.crm.write_all"); expect(adminLead?.commandExpressions.insert).toContain('"AdminLead"."assignedToAdminUserId"'); expect(adminLead?.commandExpressions.insert).not.toContain("current_user = 'hivegrid_app'"); expect(adminLead?.commandExpressions.delete).toBe("false"); expect(result.definitions.find((definition) => definition.model === "AdminLeadSource")?.commandExpressions.delete).toBe("false"); expect(result.definitions.find((definition) => definition.model === "AdminLeadSourceCredential")?.commandExpressions.delete).toBe("false"); }); it("renders narrow marketing capture, signed-prefill, and self-service conversion capabilities", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_capture_marketing_lead("); expect(sql).toContain("pg_advisory_xact_lock(hashtextextended('marketing-lead-email:'"); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_find_lead_for_signed_conversion(p_lead_id text)"); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_convert_self_service_lead("); expect(sql).toContain("context_user_id IS DISTINCT FROM requested_user_id"); expect(sql).toContain('membership."status" = 2'); expect(sql).not.toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_capture_marketing_lead(text,text,jsonb) TO hivegrid_app;"); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_convert_self_service_lead(text,text,jsonb) TO hivegrid_app;"); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_find_lead_for_signed_conversion(text) TO hivegrid_app;"); expect(sql).toContain("('public.hivegrid_capture_marketing_lead(text,text,jsonb)', false, false, false)"); expect(sql).toContain("('public.hivegrid_convert_self_service_lead(text,text,jsonb)', true, false, false)"); expect(sql).not.toMatch( /GRANT EXECUTE ON FUNCTION public\.hivegrid_(?:capture_marketing_lead|find_lead_for_signed_conversion|convert_self_service_lead)[^;]+hivegrid_worker/ ); }); it("renders a worker-only, tenant-bound default-user detach capability", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); expect(sql).toContain("CREATE OR REPLACE FUNCTION public.hivegrid_detach_default_tenant_users(p_tenant_id text)"); expect(sql).toContain("session_user <> 'hivegrid_worker'"); // NULL-safe on purpose: with `<>` an UNSET app.tenant_id made the whole // guard chain evaluate to NULL, so the IF never fired and the capability // detached users of the requested tenant without any bound context. expect(sql).toContain("p_tenant_id IS DISTINCT FROM NULLIF(current_setting('app.tenant_id', true), '')"); expect(sql).toContain('GRANT UPDATE ("defaultTenantId", "updatedAt") ON "User" TO hivegrid_rls_definer;'); expect(sql).toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_detach_default_tenant_users(text) TO hivegrid_worker;"); expect(sql).not.toContain("GRANT EXECUTE ON FUNCTION public.hivegrid_detach_default_tenant_users(text) TO hivegrid_app;"); expect(sql).toContain("('public.hivegrid_detach_default_tenant_users(text)', false, true, false)"); }); it("never compares a SECURITY DEFINER guard against a session context with a NULL-unsafe operator", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); // A capability guard is inverted logic: it RAISEs when the condition is // true, so a NULL comparison means "no exception" — fail-open. Policy // USING clauses may compare with `=` (NULL there hides the row, which is // fail-closed); `<>` against a context setting only ever appears in a // guard, and is always the bug. expect(sql).not.toContain("<> NULLIF(current_setting("); }); it("asserts externally provisioned restricted roles without requiring CREATEROLE", () => { const sql = renderTenantPolicySql(inspectTenantPolicyContract(root)); expect(sql).not.toMatch(/\b(?:CREATE|ALTER) ROLE hivegrid_(?:app|worker|authentik_jit|rls_definer)\b/); expect(sql).toContain("hivegrid_app must be provisioned before migration; run pnpm db:roles:provision"); expect(sql).toContain("hivegrid_worker must be provisioned before migration; run pnpm db:roles:provision"); expect(sql).toContain("hivegrid_authentik_jit must be provisioned before migration; run pnpm db:roles:provision"); expect(sql).toContain("hivegrid_rls_definer must be provisioned before migration; run pnpm db:roles:provision"); expect(sql).toContain("hivegrid_authentik_jit must be LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOREPLICATION NOBYPASSRLS"); expect(sql).toContain("Runtime roles must not be members of any other role"); expect(sql).toContain("pg_has_role('hivegrid_app', granted_role.oid, 'MEMBER')"); expect(sql).toContain("pg_has_role('hivegrid_worker', granted_role.oid, 'MEMBER')"); expect(sql).toContain("pg_has_role('hivegrid_authentik_jit', granted_role.oid, 'MEMBER')"); expect(sql).toContain("REVOKE ALL PRIVILEGES ON ALL TABLES IN SCHEMA public FROM hivegrid_app, hivegrid_worker, hivegrid_authentik_jit;"); expect(sql).toContain('ALTER TABLE "User" FORCE ROW LEVEL SECURITY;'); expect(sql).toContain('CREATE POLICY "hg_User_select" ON "User"'); expect(sql).toContain('"visible_membership"."userId" = "User"."id"'); expect(sql).toContain("\"User\".\"id\" = NULLIF(current_setting('app.user_id', true), '')"); expect(sql).not.toContain('GRANT SELECT ON "FileObject" TO hivegrid_app;'); expect(sql).not.toContain('GRANT SELECT ON "Credential" TO hivegrid_worker;'); expect(sql).toContain('GRANT SELECT, INSERT, UPDATE, DELETE ON "AnalyticsSettings" TO hivegrid_app;'); expect(sql).toContain('GRANT SELECT ON "AnalyticsSettings" TO hivegrid_worker;'); expect(sql).toContain('GRANT SELECT ON "BillingWebhookLog" TO hivegrid_app;'); expect(sql).not.toContain('GRANT INSERT, UPDATE, DELETE ON "BillingWebhookLog"'); expect(sql).toContain("DROP POLICY %I ON %I.%I"); expect(sql).toContain("policy.polname NOT LIKE 'hg_portal_%'"); expect(sql).toContain("procedure.proname NOT LIKE 'hivegrid_portal_%'"); expect(sql).toContain("('public.hivegrid_form_submission_actor_contract(text,text,text,text)', true, true, false)"); expect(sql).toContain('"Portal", "PortalUser", "PortalSession", "PortalToken" TO hivegrid_rls_definer'); expect(sql).not.toContain("ALTER DEFAULT PRIVILEGES"); expect(sql).toContain('CREATE POLICY "hg_Tenant_select" ON "Tenant"'); expect(sql).toContain('CREATE POLICY "hg_TenantUser_insert" ON "TenantUser"'); expect(sql).toContain('ALTER TABLE "KnowledgeBaseArticle" FORCE ROW LEVEL SECURITY;'); expect(sql).toContain('ALTER TABLE "AdminUser" FORCE ROW LEVEL SECURITY;'); expect(sql).toContain('GRANT SELECT ON "Permission" TO hivegrid_worker;'); expect(sql).not.toContain('GRANT INSERT, UPDATE, DELETE ON "Permission" TO hivegrid_worker;'); expect(sql).toContain('FROM "KnowledgeBase" AS "owner_0"'); }); it("keeps the current review artifact generated while freezing the applied deployment migration", () => { const result = inspectTenantPolicyContract(root); const current = readFileSync(path.join(root, GENERATED_POLICY_PATH), "utf8"); const currentMigration = readFileSync(path.join(root, GENERATED_MIGRATION_PATH), "utf8"); const currentRuntimeContract = readFileSync(path.join(root, GENERATED_RUNTIME_CONTRACT_PATH), "utf8"); expect(current).toBe(renderTenantPolicySql(result)); expect(sha256(currentMigration)).toBe(FROZEN_BASELINE_MIGRATION_SHA256); expect(currentMigration).not.toBe(renderTenantPolicySql(result, { deployment: true })); expect(currentRuntimeContract).toBe(renderRlsRuntimeContract(result)); }); it("recognizes every reviewed policy and resolver in the frozen baseline", () => { const result = inspectTenantPolicyContract(root); const currentMigration = readFileSync(path.join(root, GENERATED_MIGRATION_PATH), "utf8"); const delta = renderPostCutoverPolicyDeltaSql(result, currentMigration); expect(delta).toContain("Additive coverage: 87 tables, 5 bootstrap resolvers"); for (const model of [ "AdminFeatureFlagOverride", "AppEntityBinding", "KwpApiContractSnapshot", "KwpCapabilityState", "KwpErrorReport", "KwpMaterialPosition", "KwpProjectCatalogItem", "KwpProjectCatalogState", "KwpProjectRouting", ]) { expect(delta).toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(delta).toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); } expect(delta).not.toContain('CREATE OR REPLACE FUNCTION public."hivegrid_resolve_aircall_webhook"'); for (const model of ["TelephonyConnection", "TelephonyUserBinding", "TelephonyCallSession", "TelephonyWebhookEvent"]) { expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); } for (const model of ["PortalSession", "PortalToken", "PortalProjectAccess", "PortalStageVisibility", "PortalProjectDocument", "PortalEmailTemplate"]) { expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); } for (const model of [ "PortalActivityRoutingRule", "PortalComplaint", "PortalConfiguration", "PortalDeletionRequest", "PortalDocumentAutoReleaseRule", "PortalGdprExportJob", "PortalNotificationPreference", "PortalServiceInboxItem", "PortalSubcontractorAccess", "PortalUpload", "PortalDomainHostnameClaim", "PortalCustomDomain", "TenantProductAcquisition", ]) { expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); } for (const model of ["AdminLead", "AdminLeadActivity", "AdminLeadSource", "AdminLeadSourceCredential"]) { expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); } expect(delta).not.toContain("CREATE OR REPLACE FUNCTION public.hivegrid_capture_admin_lead("); expect(delta).not.toContain("CREATE OR REPLACE FUNCTION public.hivegrid_resolve_platform_lead_notification_recipient("); expect(delta).not.toContain( 'GRANT SELECT ON "User", "AdminUser", "AdminLeadSource", "AdminLeadSourceCredential", "AdminLead", "IdempotencyKey", "OutboxEvent", "NotificationDelivery", "UserRole", "Role", "RolePermission", "Permission" TO hivegrid_rls_definer;' ); expect(delta).not.toContain('ALTER TABLE "Kontakt" ENABLE ROW LEVEL SECURITY;'); expect(delta).not.toContain('CREATE OR REPLACE FUNCTION public."hivegrid_resolve_calendar_webhook"'); expect(sha256(currentMigration)).toBe(FROZEN_BASELINE_MIGRATION_SHA256); }); it("recognizes the complete post-baseline policy contract including the HalloPetra merge migration", () => { const result = inspectTenantPolicyContract(root); const currentMigration = readFileSync(path.join(root, GENERATED_MIGRATION_PATH), "utf8"); const postCutoverMigrationSql = readPostCutoverMigrationSql(root); const delta = renderPostCutoverPolicyDeltaSql(result, currentMigration, postCutoverMigrationSql); expect(postCutoverMigrationSql).toContain("VR-P32b / VR-P32d"); expect(postCutoverMigrationSql).toContain("VR-P28a / VA-P28b / VA-P28c / VA-P28d / VA-P28f"); expect(delta).toContain("Additive coverage: 0 tables, 0 bootstrap resolvers."); expect(delta).not.toContain('CREATE OR REPLACE FUNCTION public."hivegrid_resolve_hallopetra_webhook"'); expect(postCutoverMigrationSql).toContain('CREATE OR REPLACE FUNCTION public."hivegrid_resolve_hallopetra_webhook"'); expect(postCutoverMigrationSql).toContain('ALTER TABLE "AdminFeatureFlagOverride" ENABLE ROW LEVEL SECURITY;'); expect(postCutoverMigrationSql).toContain('ALTER TABLE "AdminFeatureFlagOverride" FORCE ROW LEVEL SECURITY;'); expect(postCutoverMigrationSql).toContain( 'GRANT SELECT ON "AdminFeatureFlagOverride", "FeatureFlag", "FeatureFlagFilter", "FeatureFlagAudit", "TeamChatEvent", "AdminTenantNote", "SupportTicket", "SupportTicketMessage", "Feedback" TO hivegrid_rls_definer;' ); expect(postCutoverMigrationSql).toContain( 'GRANT DELETE ON "AdminFeatureFlagOverride", "FeatureFlag", "FeatureFlagFilter", "FeatureFlagAudit", "UserRole", "TeamChatEvent", "AdminTenantNote", "SupportTicket", "SupportTicketMessage", "Feedback" TO hivegrid_rls_definer;' ); for (const model of [ "AppEntityBinding", "KwpApiContractSnapshot", "KwpCapabilityState", "KwpErrorReport", "KwpProjectRouting", ]) { expect(postCutoverMigrationSql).toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(postCutoverMigrationSql).toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); } for (const model of [ "TeamChat", "TeamChatMessage", "TeamChatMember", "TeamChatThread", "TeamChatPinnedMessage", "TeamChatReaction", "TeamChatRead", "TeamChatEvent", "TeamChatGroupSource", ]) { expect(postCutoverMigrationSql).toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(postCutoverMigrationSql).toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); } expect(delta).not.toMatch(/GRANT\s+USAGE\s+ON\s+ALL\s+SEQUENCES/i); expect(delta).not.toContain('ALTER TABLE "TelephonyConnection" ENABLE ROW LEVEL SECURITY;'); expect(delta).not.toContain('CREATE OR REPLACE FUNCTION public."hivegrid_resolve_aircall_webhook"'); for (const model of [ "PortalSession", "PortalToken", "PortalProjectAccess", "PortalStageVisibility", "PortalProjectDocument", "PortalEmailTemplate", "PortalActivityRoutingRule", "PortalComplaint", "PortalConfiguration", "PortalCustomDomain", "PortalDeletionRequest", "PortalDocumentAutoReleaseRule", "PortalDomainHostnameClaim", "PortalGdprExportJob", "PortalNotificationPreference", "PortalServiceInboxItem", "PortalSubcontractorAccess", "PortalUpload", "TenantProductAcquisition", ]) { expect(postCutoverMigrationSql).toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); expect(postCutoverMigrationSql).toContain(`ALTER TABLE "${model}" FORCE ROW LEVEL SECURITY;`); expect(delta).not.toContain(`ALTER TABLE "${model}" ENABLE ROW LEVEL SECURITY;`); } }); });