Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/scripts/generate-tenant-policy-contract.test.mjs
T

1364 lines
86 KiB
JavaScript

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;`);
}
});
});