// @vitest-environment node import pg from "pg"; import { afterAll, beforeAll, describe, expect, it } from "vitest"; import { Prisma } from "../generated/prisma/client/client.js"; import { createDbClient, type DbClient } from "./client.server.js"; import { createPrismaPlatformLeadService } from "./platform-leads-admin.server.js"; import { hashPlatformLeadSourceCredential, ingestPlatformLead } from "./platform-leads.server.js"; import { runWithRlsContext } from "./rls-context.server.js"; import { createRlsScopedClient } from "./rls-client.server.js"; import { grantAdminRlsTestPermissions, removeAdminRlsTestRole, } from "./admin-rbac-rls-test-helper.js"; const ADMIN_URL = process.env.RLS_TEST_DATABASE_URL; const APP_ROLE = "hivegrid_app"; const APP_PASSWORD = "hivegrid_rls_test_only"; const SOURCE_CREDENTIAL = "r-leads-source-credential-1234567890"; const SOURCE_ID = "rls_admin_lead_source"; const OPERATOR_USER_ID = "rls_admin_lead_operator"; const OPERATOR_ROLE_ID = "rls_admin_lead_operator_role"; const MUTATION_ROLLBACK_LEAD_ID = "rls_admin_lead_mutation_rollback"; const AUDIT_NEWLINE_LEAD_ID = "rls_admin_lead_audit_newline"; const NOTE_PII_LEAD_ID = "rls_admin_lead_note_pii"; const MISMATCHED_ACTOR_USER_ID = "rls_admin_lead_user"; const MISSING_USER_ID = "rls_admin_lead_missing_user"; const LEGACY_LEAD_ID = "rls_retired_legacy_lead"; const LEGACY_EVENT_ID = "rls_retired_legacy_event"; const LEGACY_CONVERSION_EVENT_ID = "rls_retired_legacy_conversion_event"; const LEGACY_ACQUISITION_ID = "rls_retired_legacy_acquisition"; const LEGACY_TENANT_ID = "rls_retired_legacy_tenant"; const describeIfDatabase = ADMIN_URL ? describe : describe.skip; type AtomicArtifactCounts = { leads: number; activities: number; idempotencyKeys: number; capturedOutboxEvents: number; auditOutboxEvents: number; notificationOutboxEvents: number; deliveries: number; }; function appUrlFrom(adminUrl: string): string { const url = new URL(adminUrl); url.username = APP_ROLE; url.password = APP_PASSWORD; return url.toString(); } async function readAtomicArtifactCounts(admin: pg.Client): Promise { const result = await admin.query( `SELECT (SELECT COUNT(*)::int FROM "AdminLead" WHERE "sourceId" = $1) AS "leads", (SELECT COUNT(*)::int FROM "AdminLeadActivity" AS activity JOIN "AdminLead" AS lead ON lead."id" = activity."leadId" WHERE lead."sourceId" = $1) AS "activities", (SELECT COUNT(*)::int FROM "IdempotencyKey" WHERE "scope" = 'platform-leads:' || $1) AS "idempotencyKeys", (SELECT COUNT(*)::int FROM "OutboxEvent" WHERE "eventType" = 'platform.admin_lead.captured.v1' AND "payload"->>'sourceId' = $1) AS "capturedOutboxEvents", (SELECT COUNT(*)::int FROM "OutboxEvent" WHERE "eventType" = 'audit.event.create' AND "payload"->'metadata'->>'sourceId' = $1) AS "auditOutboxEvents", (SELECT COUNT(*)::int FROM "OutboxEvent" WHERE "eventType" = 'notification.platform.requested.v1' AND "payload"->'metadata'->>'sourceId' = $1) AS "notificationOutboxEvents", (SELECT COUNT(*)::int FROM "NotificationDelivery" WHERE "payloadMetadata"->>'sourceId' = $1) AS "deliveries"`, [SOURCE_ID] ); const counts = result.rows[0]; if (!counts) throw new Error("Platform lead atomic artifact count query returned no row."); return counts; } describeIfDatabase("platform lead RLS and pre-tenant capability", () => { let admin: pg.Client; let client: DbClient; beforeAll(async () => { admin = new pg.Client({ connectionString: ADMIN_URL }); await admin.connect(); await admin.query(`ALTER ROLE ${APP_ROLE} PASSWORD '${APP_PASSWORD}'`); await admin.query(`GRANT CONNECT ON DATABASE "${new URL(ADMIN_URL!).pathname.slice(1)}" TO ${APP_ROLE}`); await admin.query(` DELETE FROM "OutboxEvent" WHERE "payload"->>'sourceId' = '${SOURCE_ID}' OR "payload"->'metadata'->>'sourceId' = '${SOURCE_ID}'; DELETE FROM "NotificationDelivery" WHERE "payloadMetadata"->>'sourceId' = '${SOURCE_ID}'; DELETE FROM "IdempotencyKey" WHERE "scope" = 'platform-leads:${SOURCE_ID}'; DELETE FROM "AdminLeadActivity" WHERE "leadId" LIKE 'rls_admin_lead_%'; DELETE FROM "AdminLead" WHERE "sourceId" = '${SOURCE_ID}'; DELETE FROM "AdminLeadSourceCredential" WHERE "sourceId" = '${SOURCE_ID}'; DELETE FROM "AdminLeadSource" WHERE id = '${SOURCE_ID}'; DELETE FROM "TenantAcquisition" WHERE id = '${LEGACY_ACQUISITION_ID}' OR "tenantId" = '${LEGACY_TENANT_ID}'; DELETE FROM "LeadEvent" WHERE id IN ('${LEGACY_EVENT_ID}', '${LEGACY_CONVERSION_EVENT_ID}'); DELETE FROM "Lead" WHERE id = '${LEGACY_LEAD_ID}'; DELETE FROM "AdminUser" WHERE id IN ('${OPERATOR_USER_ID}', 'rls_admin_lead_user'); DELETE FROM "TenantUser" WHERE "tenantId" = '${LEGACY_TENANT_ID}'; DELETE FROM "Tenant" WHERE id = '${LEGACY_TENANT_ID}'; DELETE FROM "User" WHERE id IN ('${OPERATOR_USER_ID}', 'rls_admin_lead_user'); INSERT INTO "User" (id, "createdAt", "updatedAt", email, "firstName", "lastName", active) VALUES ('${OPERATOR_USER_ID}', now(), now(), 'rls-admin-lead-operator@example.test', 'RLS', 'Operator', true), ('rls_admin_lead_user', now(), now(), 'rls-admin-lead-user@example.test', 'RLS', 'User', true); INSERT INTO "AdminUser" ( id, "createdAt", "updatedAt", email, "firstName", "lastName", status ) VALUES ( '${OPERATOR_USER_ID}', now(), now(), 'rls-admin-lead-operator@example.test', 'RLS', 'Operator', 'active' ); INSERT INTO "Tenant" (id, "createdAt", "updatedAt", slug, name, active) VALUES ('${LEGACY_TENANT_ID}', now(), now(), 'rls-retired-legacy-tenant', 'RLS legacy conversion tenant', true); INSERT INTO "TenantUser" (id, "createdAt", "tenantId", "userId", type, joined, status) VALUES ('rls_retired_legacy_membership', now(), '${LEGACY_TENANT_ID}', 'rls_admin_lead_user', 1, 1, 2); INSERT INTO "AdminLeadSource" ( id, "createdAt", "updatedAt", key, "displayName", enabled, "notifyAdminUserIds", "rateLimitPerMinute" ) VALUES ( '${SOURCE_ID}', now(), now(), 'rls-test-source', 'RLS test source', true, ARRAY['${OPERATOR_USER_ID}']::text[], 60 ); INSERT INTO "AdminLeadSourceCredential" ( id, "createdAt", "sourceId", "keyHash", "keyPrefix" ) VALUES ( 'rls_admin_lead_credential', now(), '${SOURCE_ID}', '${hashPlatformLeadSourceCredential(SOURCE_CREDENTIAL)}', 'r-leads-sour' ); INSERT INTO "AdminLead" (id, "createdAt", "updatedAt", "capturedAt", "sourceId", status, message) VALUES ( '${MUTATION_ROLLBACK_LEAD_ID}', now(), now(), now(), '${SOURCE_ID}', 'new', 'Dedicated transaction rollback fixture' ), ( '${AUDIT_NEWLINE_LEAD_ID}', now(), now(), now(), '${SOURCE_ID}', 'new', 'Dedicated multiline audit fixture' ), ( '${NOTE_PII_LEAD_ID}', now(), now(), now(), '${SOURCE_ID}', 'new', 'Dedicated note PII fixture' ); INSERT INTO "Lead" (id, "createdAt", "updatedAt", email, status) VALUES ('${LEGACY_LEAD_ID}', now(), now(), 'rls-admin-lead-user@example.test', 'new'); INSERT INTO "LeadEvent" (id, "createdAt", "leadId", type, payload) VALUES ('${LEGACY_EVENT_ID}', now(), '${LEGACY_LEAD_ID}', 'captured', '{}'::jsonb); `); await grantAdminRlsTestPermissions(admin, { userId: OPERATOR_USER_ID, roleId: OPERATOR_ROLE_ID, permissions: [ "admin_sales.crm.read", "admin_sales.crm.read_all", "admin_sales.crm.write", "admin_sales.crm.write_all", ], }); client = createRlsScopedClient(createDbClient({ connectionString: appUrlFrom(ADMIN_URL!) })); }); afterAll(async () => { await client?.$disconnect(); if (admin) { await admin.query(` DELETE FROM "OutboxEvent" WHERE "payload"->>'sourceId' = '${SOURCE_ID}' OR "payload"->'metadata'->>'sourceId' = '${SOURCE_ID}'; DELETE FROM "NotificationDelivery" WHERE "payloadMetadata"->>'sourceId' = '${SOURCE_ID}'; DELETE FROM "IdempotencyKey" WHERE "scope" = 'platform-leads:${SOURCE_ID}'; DELETE FROM "AdminLeadActivity" WHERE "leadId" LIKE 'rls_admin_lead_%'; DELETE FROM "AdminLead" WHERE "sourceId" = '${SOURCE_ID}'; DELETE FROM "AdminLeadSourceCredential" WHERE "sourceId" = '${SOURCE_ID}'; DELETE FROM "AdminLeadSource" WHERE id = '${SOURCE_ID}'; DELETE FROM "TenantAcquisition" WHERE id = '${LEGACY_ACQUISITION_ID}' OR "tenantId" = '${LEGACY_TENANT_ID}'; DELETE FROM "LeadEvent" WHERE id IN ('${LEGACY_EVENT_ID}', '${LEGACY_CONVERSION_EVENT_ID}'); DELETE FROM "Lead" WHERE id = '${LEGACY_LEAD_ID}'; DELETE FROM "AdminUser" WHERE id IN ('${OPERATOR_USER_ID}', 'rls_admin_lead_user'); DELETE FROM "TenantUser" WHERE "tenantId" = '${LEGACY_TENANT_ID}'; DELETE FROM "Tenant" WHERE id = '${LEGACY_TENANT_ID}'; DELETE FROM "User" WHERE id IN ('${OPERATOR_USER_ID}', 'rls_admin_lead_user'); `); await removeAdminRlsTestRole(admin, OPERATOR_ROLE_ID); await admin.end(); } }); it("hides platform-lead tables from unbound and non-operator app contexts", async () => { await expect(client.adminLeadSource.count()).resolves.toBe(0); await expect(client.adminLead.count()).resolves.toBe(0); await expect( client.adminLead.create({ data: { id: "rls_admin_lead_direct_denied", sourceId: "rls_admin_lead_source", message: "Denied" }, }) ).rejects.toThrow(/row-level security|denied/i); await expect(runWithRlsContext({ userId: "rls_admin_lead_user" }, () => client.adminLeadSource.count())).resolves.toBe(0); }); it("retires legacy capture and direct table writes while preserving signed self-service conversion", async () => { await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.lead.findUnique({ where: { id: LEGACY_LEAD_ID }, select: { id: true, email: true }, }) ) ).resolves.toEqual({ id: LEGACY_LEAD_ID, email: "rls-admin-lead-user@example.test", }); await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.lead.update({ where: { id: LEGACY_LEAD_ID }, data: { company: "Must not persist" }, }) ) ).rejects.toThrow(/permission denied|row-level security|denied/i); await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.leadEvent.create({ data: { id: "rls_retired_legacy_event_denied", leadId: LEGACY_LEAD_ID, type: "note", payload: {}, }, }) ) ).rejects.toThrow(/permission denied|row-level security|denied/i); await expect(runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.lead.delete({ where: { id: LEGACY_LEAD_ID } }))).rejects.toThrow( /permission denied|row-level security|denied/i ); const privileges = await admin.query<{ capture: boolean; conversion: boolean; }>(`SELECT has_function_privilege('hivegrid_app', 'public.hivegrid_capture_marketing_lead(text,text,jsonb)', 'EXECUTE') AS capture, has_function_privilege('hivegrid_app', 'public.hivegrid_convert_self_service_lead(text,text,jsonb)', 'EXECUTE') AS conversion`); expect(privileges.rows[0]).toEqual({ capture: false, conversion: true }); await expect( client.$queryRaw(Prisma.sql` SELECT public.hivegrid_capture_marketing_lead( ${"rls_retired_legacy_capture"}, ${"rls_retired_legacy_capture_event"}, ${JSON.stringify({ email: "retired-writer@example.test", eventPayload: {} })}::jsonb ) AS result `) ).rejects.toThrow(/permission denied|42501/i); const conversionRows = await runWithRlsContext({ userId: MISMATCHED_ACTOR_USER_ID, tenantId: LEGACY_TENANT_ID }, () => client.$queryRaw>(Prisma.sql` SELECT public.hivegrid_convert_self_service_lead( ${LEGACY_CONVERSION_EVENT_ID}, ${LEGACY_ACQUISITION_ID}, ${JSON.stringify({ userId: MISMATCHED_ACTOR_USER_ID, tenantId: LEGACY_TENANT_ID, leadId: LEGACY_LEAD_ID, expectedEmail: "rls-admin-lead-user@example.test", planId: null, })}::jsonb ) AS result `) ); expect(conversionRows[0]?.result).toMatchObject({ leadId: LEGACY_LEAD_ID, convertedToTenantId: LEGACY_TENANT_ID, alreadyConverted: false, }); const conversionArtifacts = await admin.query<{ leadStatus: string; conversionEvents: number; acquisitions: number; }>(`SELECT (SELECT status::text FROM "Lead" WHERE id = '${LEGACY_LEAD_ID}') AS "leadStatus", (SELECT COUNT(*)::int FROM "LeadEvent" WHERE id = '${LEGACY_CONVERSION_EVENT_ID}' AND type = 'converted') AS "conversionEvents", (SELECT COUNT(*)::int FROM "TenantAcquisition" WHERE id = '${LEGACY_ACQUISITION_ID}' AND "leadId" = '${LEGACY_LEAD_ID}') AS acquisitions`); expect(conversionArtifacts.rows[0]).toEqual({ leadStatus: "trial", conversionEvents: 1, acquisitions: 1 }); }); it("allows an active operator to manage lead rows while keeping activities append-only", async () => { await expect(runWithRlsContext({ userId: "rls_admin_lead_operator" }, () => client.adminLeadSource.count())).resolves.toBe(1); await runWithRlsContext({ userId: "rls_admin_lead_operator" }, () => client.adminLead.create({ data: { id: "rls_admin_lead_operator_created", sourceId: "rls_admin_lead_source", message: "Operator-created", activities: { create: { id: "rls_admin_lead_operator_activity", type: "manually_created", actorAdminUserId: "rls_admin_lead_operator", payload: { sourceId: "rls_admin_lead_source" }, }, }, }, }) ); await expect( runWithRlsContext({ userId: "rls_admin_lead_operator" }, () => client.adminLeadActivity.update({ where: { id: "rls_admin_lead_operator_activity" }, data: { payload: { rewritten: true } }, }) ) ).rejects.toThrow(/permission denied|denied/i); await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.adminLeadActivity.create({ data: { id: "rls_admin_lead_activity_forged_actor", leadId: "rls_admin_lead_operator_created", type: "note_added", actorAdminUserId: MISMATCHED_ACTOR_USER_ID, payload: { note: "Must be rejected" }, }, }) ) ).rejects.toThrow(/row-level security|denied/i); await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.adminLeadActivity.create({ data: { id: "rls_admin_lead_activity_null_actor", leadId: "rls_admin_lead_operator_created", type: "note_added", actorAdminUserId: null, payload: { note: "Must also be rejected" }, }, }) ) ).rejects.toThrow(/row-level security|denied/i); await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => client.adminLeadActivity.create({ data: { id: "rls_admin_lead_activity_own_actor", leadId: "rls_admin_lead_operator_created", type: "note_added", actorAdminUserId: OPERATOR_USER_ID, payload: { note: "Attributable operator activity" }, }, }) ) ).resolves.toMatchObject({ id: "rls_admin_lead_activity_own_actor", actorAdminUserId: OPERATOR_USER_ID }); }); it("imports deterministic legacy activities with system attribution under enforced RLS", async () => { const capturedAt = new Date("2026-03-01T09:00:00.000Z"); const occurredAt = new Date("2026-03-02T09:00:00.000Z"); const result = await runWithRlsContext({ userId: OPERATOR_USER_ID }, () => createPrismaPlatformLeadService(client).importLead({ channel: "import", sourceId: SOURCE_ID, actorAdminUserId: OPERATOR_USER_ID, reason: "Import RLS legacy activity proof", capturedAt, payload: { externalId: "legacy:hivegrid-cloud-legacy:" + "a".repeat(64), email: "legacy-import-rls@example.test", }, legacyActivities: [ { externalActivityId: "rls-legacy-status-event", occurredAt, type: "status_changed", payload: { from: "new", to: "contacted", legacyActorId: "legacy-operator" }, }, ], }) ); expect(result.outcome).toBe("created"); const persisted = await admin.query<{ actorAdminUserId: string | null; createdAt: Date; legacyActorId: string | null; }>( `SELECT activity."actorAdminUserId", activity."createdAt" AT TIME ZONE 'UTC' AS "createdAt", activity."payload"->>'legacyActorId' AS "legacyActorId" FROM "AdminLeadActivity" AS activity WHERE activity."leadId" = $1 AND activity.id LIKE 'legacy-activity:%'`, [result.lead.id] ); expect(persisted.rows).toEqual([ expect.objectContaining({ actorAdminUserId: null, createdAt: occurredAt, legacyActorId: "legacy-operator" }), ]); }); it("captures every durable artifact atomically and replays with stable counts", async () => { const indexResult = await admin.query<{ indexdef: string }>( `SELECT indexdef FROM pg_indexes WHERE schemaname = 'public' AND indexname = 'notification_delivery_platform_source_key'` ); expect(indexResult.rows).toHaveLength(1); expect(indexResult.rows[0]?.indexdef).toMatch( /UNIQUE INDEX notification_delivery_platform_source_key[\s\S]*\("userId", channel, "sourceKey"\)[\s\S]*WHERE \("tenantId" IS NULL\)/i ); const before = await readAtomicArtifactCounts(admin); const privateMessage = "RLS capability private lead message"; const input = { channel: "s2s" as const, sourceId: SOURCE_ID, sourceCredential: SOURCE_CREDENTIAL, idempotencyKey: "rls_submission_1", requestFingerprint: "a".repeat(64), payload: { message: privateMessage, externalId: "rls-external-1" }, }; const created = await ingestPlatformLead(input, { client }); expect(created).toMatchObject({ outcome: "created", lead: { status: "new" } }); const afterCreate = await readAtomicArtifactCounts(admin); expect(afterCreate).toEqual({ leads: before.leads + 1, activities: before.activities + 1, idempotencyKeys: before.idempotencyKeys + 1, capturedOutboxEvents: before.capturedOutboxEvents + 1, auditOutboxEvents: before.auditOutboxEvents + 1, notificationOutboxEvents: before.notificationOutboxEvents + 2, deliveries: before.deliveries + 2, }); const deliveries = await admin.query<{ id: string; tenantId: string | null; userId: string; channel: "IN_APP" | "EMAIL"; sourceKey: string; status: string; attemptsMade: number; payloadMetadata: Record; }>( `SELECT "id", "tenantId", "userId", "channel", "sourceKey", "status", "attemptsMade", "payloadMetadata" FROM "NotificationDelivery" WHERE "payloadMetadata"->>'leadId' = $1 ORDER BY "channel"`, [created.lead.id] ); expect(deliveries.rows).toEqual([ expect.objectContaining({ tenantId: null, userId: OPERATOR_USER_ID, channel: "IN_APP", sourceKey: `platform-lead:${created.lead.id}:in-app`, status: "PENDING", attemptsMade: 0, }), expect.objectContaining({ tenantId: null, userId: OPERATOR_USER_ID, channel: "EMAIL", sourceKey: `platform-lead:${created.lead.id}:email`, status: "PENDING", attemptsMade: 0, }), ]); for (const delivery of deliveries.rows) { expect(delivery.payloadMetadata).toEqual({ leadId: created.lead.id, sourceId: SOURCE_ID, eventType: "platform.admin_lead.captured.v1", deeplink: `/leads/${created.lead.id}`, }); } const notificationOutbox = await admin.query<{ tenantId: string | null; status: string; dispatchKey: string; payload: Record; }>( `SELECT "tenantId", "status", "dispatchKey", "payload" FROM "OutboxEvent" WHERE "eventType" = 'notification.platform.requested.v1' AND "payload"->'metadata'->>'leadId' = $1 ORDER BY "payload"->>'channel'`, [created.lead.id] ); expect(notificationOutbox.rows).toHaveLength(2); for (const event of notificationOutbox.rows) { expect(event.tenantId).toBeNull(); expect(event.status).toBe("PENDING"); expect(event.dispatchKey).toBe(`platform-notification:${String(event.payload.deliveryId)}`); expect(event.payload).toEqual( expect.objectContaining({ deliveryId: expect.any(String), userId: OPERATOR_USER_ID, sourceKey: expect.stringMatching(new RegExp(`^platform-lead:${created.lead.id}:(?:email|in-app)$`, "u")), channel: expect.stringMatching(/^(?:email|in-app)$/u), messageKey: "platform.leads.captured", category: "leads", metadata: { leadId: created.lead.id, sourceId: SOURCE_ID, eventType: "platform.admin_lead.captured.v1", deeplink: `/leads/${created.lead.id}`, }, }) ); } const durablePayloads = await admin.query<{ serialized: string }>( `SELECT "payload"::text AS serialized FROM "OutboxEvent" WHERE "payload"->>'sourceId' = $1 OR "payload"->'metadata'->>'sourceId' = $1 UNION ALL SELECT "payloadMetadata"::text AS serialized FROM "NotificationDelivery" WHERE "payloadMetadata"->>'sourceId' = $1`, [SOURCE_ID] ); expect(durablePayloads.rows.map((row) => row.serialized).join("\n")).not.toContain(privateMessage); expect(durablePayloads.rows.map((row) => row.serialized).join("\n")).not.toContain("rls-admin-lead-operator@example.test"); await expect(ingestPlatformLead(input, { client })).resolves.toMatchObject({ outcome: "replayed", lead: { id: created.lead.id } }); await expect(ingestPlatformLead({ ...input, requestFingerprint: "b".repeat(64), payload: { message: "Changed" } }, { client })).rejects.toMatchObject({ code: "IDEMPOTENCY_CONFLICT", }); await expect(readAtomicArtifactCounts(admin)).resolves.toEqual(afterCreate); }); it("serializes concurrent external-id submissions across different idempotency keys", async () => { const before = await readAtomicArtifactCounts(admin); const common = { channel: "s2s" as const, sourceId: SOURCE_ID, sourceCredential: SOURCE_CREDENTIAL, requestFingerprint: "e".repeat(64), payload: { message: "Concurrent external identity", externalId: "rls-external-concurrent" }, }; const results = await Promise.all([ ingestPlatformLead({ ...common, idempotencyKey: "rls_submission_concurrent_a" }, { client }), ingestPlatformLead({ ...common, idempotencyKey: "rls_submission_concurrent_b" }, { client }), ]); expect(results.map((result) => result.outcome).sort()).toEqual(["created", "replayed"]); expect(new Set(results.map((result) => result.lead.id)).size).toBe(1); const after = await readAtomicArtifactCounts(admin); expect(after).toEqual({ leads: before.leads + 1, activities: before.activities + 1, idempotencyKeys: before.idempotencyKeys + 2, capturedOutboxEvents: before.capturedOutboxEvents + 1, auditOutboxEvents: before.auditOutboxEvents + 1, notificationOutboxEvents: before.notificationOutboxEvents + 2, deliveries: before.deliveries + 2, }); }); it("rolls back lead, activity, audit, outbox, idempotency and delivery artifacts when a recipient FK fails", async () => { const before = await readAtomicArtifactCounts(admin); const credentialBefore = await admin.query<{ lastUsedAt: Date | null }>(`SELECT "lastUsedAt" FROM "AdminLeadSourceCredential" WHERE "sourceId" = $1`, [ SOURCE_ID, ]); await admin.query(`UPDATE "AdminLeadSource" SET "notifyAdminUserIds" = ARRAY[$2]::text[], "updatedAt" = now() WHERE "id" = $1`, [ SOURCE_ID, MISSING_USER_ID, ]); try { await expect( ingestPlatformLead( { channel: "s2s", sourceId: SOURCE_ID, sourceCredential: SOURCE_CREDENTIAL, idempotencyKey: "rls_submission_fk_failure", requestFingerprint: "c".repeat(64), payload: { message: "Must roll back completely", externalId: "rls-external-fk-failure" }, }, { client } ) ).rejects.toThrow(/foreign key|NotificationDelivery_userId_fkey|23503/i); } finally { await admin.query(`UPDATE "AdminLeadSource" SET "notifyAdminUserIds" = ARRAY[$2]::text[], "updatedAt" = now() WHERE "id" = $1`, [ SOURCE_ID, OPERATOR_USER_ID, ]); } await expect(readAtomicArtifactCounts(admin)).resolves.toEqual(before); const credentialAfter = await admin.query<{ lastUsedAt: Date | null }>(`SELECT "lastUsedAt" FROM "AdminLeadSourceCredential" WHERE "sourceId" = $1`, [ SOURCE_ID, ]); expect(credentialAfter.rows[0]?.lastUsedAt?.toISOString()).toBe(credentialBefore.rows[0]?.lastUsedAt?.toISOString()); }); it("keeps domain and capability validation aligned for normalized phone, metadata controls and payload bytes", async () => { const before = await readAtomicArtifactCounts(admin); const tamperedPayload = JSON.stringify({ phone: "+49 30 123456", normalizedPhone: "+491111111111", message: "The capability must reject this normalized phone mismatch", }); await expect( client.$queryRaw(Prisma.sql` SELECT public.hivegrid_capture_admin_lead( ${SOURCE_ID}, ${hashPlatformLeadSourceCredential(SOURCE_CREDENTIAL)}, ${"rls_submission_tampered_phone"}, ${"d".repeat(64)}, ${"rls_admin_lead_tampered_phone"}, ${"rls_admin_lead_tampered_phone_activity"}, ${tamperedPayload}::jsonb ) AS result `) ).rejects.toThrow(/invalid platform lead capture request|22023/i); const controlMetadataPayload = JSON.stringify({ message: "Metadata validation parity", metadata: { formName: "PII\nspill" }, }); await expect( client.$queryRaw(Prisma.sql` SELECT public.hivegrid_capture_admin_lead( ${SOURCE_ID}, ${hashPlatformLeadSourceCredential(SOURCE_CREDENTIAL)}, ${"rls_submission_control_metadata"}, ${"f".repeat(64)}, ${"rls_admin_lead_control_metadata"}, ${"rls_admin_lead_control_metadata_activity"}, ${controlMetadataPayload}::jsonb ) AS result `) ).rejects.toThrow(/invalid platform lead capture request|22023/i); const oversizedPayload = JSON.stringify({ externalId: "rls-oversized", message: "m".repeat(8_000), referrer: "r".repeat(2_048), landingPage: "l".repeat(2_048), utmSource: "s".repeat(500), utmMedium: "m".repeat(500), utmCampaign: "c".repeat(500), utmTerm: "t".repeat(500), utmContent: "u".repeat(500), sourceDetail: "d".repeat(500), firstName: "a".repeat(200), lastName: "b".repeat(200), company: "c".repeat(300), metadata: { formName: "f".repeat(500) }, }); await expect( client.$queryRaw(Prisma.sql` SELECT public.hivegrid_capture_admin_lead( ${SOURCE_ID}, ${hashPlatformLeadSourceCredential(SOURCE_CREDENTIAL)}, ${"rls_submission_oversized"}, ${"9".repeat(64)}, ${"rls_admin_lead_oversized"}, ${"rls_admin_lead_oversized_activity"}, ${oversizedPayload}::jsonb ) AS result `) ).rejects.toThrow(/invalid platform lead capture request|22023/i); await expect(readAtomicArtifactCounts(admin)).resolves.toEqual(before); }); it("rejects assignment to a missing operator without changing lead or activity state", async () => { const readState = () => admin.query<{ assignedToAdminUserId: string | null; assignedActivities: number }>( `SELECT lead."assignedToAdminUserId", (SELECT COUNT(*)::int FROM "AdminLeadActivity" WHERE "leadId" = lead.id AND type = 'assigned') AS "assignedActivities" FROM "AdminLead" AS lead WHERE lead.id = $1`, [NOTE_PII_LEAD_ID] ); const before = (await readState()).rows[0]; await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => createPrismaPlatformLeadService(client).assignLead({ leadId: NOTE_PII_LEAD_ID, assignedToAdminUserId: MISSING_USER_ID, actorAdminUserId: OPERATOR_USER_ID, reason: "Attempt invalid platform operator assignment", }) ) ).rejects.toMatchObject({ code: "VALIDATION" }); expect((await readState()).rows[0]).toEqual(before); }); it("rolls back an operator mutation when the audit capability is unavailable", async () => { const readState = async () => { const result = await admin.query<{ status: string; updatedAt: Date; statusActivities: number; auditOutboxEvents: number; }>( `SELECT lead.status::text AS status, lead."updatedAt" AS "updatedAt", (SELECT COUNT(*)::int FROM "AdminLeadActivity" WHERE "leadId" = lead.id AND type = 'status_changed') AS "statusActivities", (SELECT COUNT(*)::int FROM "OutboxEvent" WHERE "eventType" = 'audit.event.create' AND "payload"->>'targetId' = lead.id AND "payload"->>'action' = 'admin.lead.statusChanged') AS "auditOutboxEvents" FROM "AdminLead" AS lead WHERE lead.id = $1`, [MUTATION_ROLLBACK_LEAD_ID] ); const state = result.rows[0]; if (!state) throw new Error("Platform lead mutation rollback fixture is missing."); return state; }; const before = await readState(); expect(before).toMatchObject({ status: "new", statusActivities: 0, auditOutboxEvents: 0 }); const auditSignature = "public.hivegrid_enqueue_admin_lead_audit(text,text,text,text,text,text,text,text,text,text,jsonb,jsonb)"; await admin.query(`REVOKE EXECUTE ON FUNCTION ${auditSignature} FROM ${APP_ROLE}`); try { await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => createPrismaPlatformLeadService(client).updateStatus({ leadId: MUTATION_ROLLBACK_LEAD_ID, status: "qualified", actorAdminUserId: OPERATOR_USER_ID, reason: "Inject an unavailable audit capability after the business mutation", }) ) ).rejects.toThrow(/permission denied|42501/i); } finally { await admin.query(`GRANT EXECUTE ON FUNCTION ${auditSignature} TO ${APP_ROLE}`); } await expect(readState()).resolves.toEqual(before); }); it("accepts a multiline operator reason and commits its mutation plus audit outbox atomically", async () => { const reason = "Reviewed by the operator\nFollow-up context remains attributable"; await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => createPrismaPlatformLeadService(client).updateStatus({ leadId: AUDIT_NEWLINE_LEAD_ID, status: "contacted", actorAdminUserId: OPERATOR_USER_ID, reason, }) ) ).resolves.toMatchObject({ id: AUDIT_NEWLINE_LEAD_ID, status: "contacted" }); const persisted = await admin.query<{ status: string; statusActivities: number; auditOutboxEvents: number; reason: string | null; }>( `SELECT lead.status::text AS status, (SELECT COUNT(*)::int FROM "AdminLeadActivity" WHERE "leadId" = lead.id AND type = 'status_changed') AS "statusActivities", (SELECT COUNT(*)::int FROM "OutboxEvent" WHERE "eventType" = 'audit.event.create' AND "payload"->>'targetId' = lead.id AND "payload"->>'action' = 'admin.lead.statusChanged') AS "auditOutboxEvents", (SELECT "payload"->'metadata'->>'reason' FROM "OutboxEvent" WHERE "eventType" = 'audit.event.create' AND "payload"->>'targetId' = lead.id AND "payload"->>'action' = 'admin.lead.statusChanged' LIMIT 1) AS reason FROM "AdminLead" AS lead WHERE lead.id = $1`, [AUDIT_NEWLINE_LEAD_ID] ); expect(persisted.rows[0]).toEqual({ status: "contacted", statusActivities: 1, auditOutboxEvents: 1, reason }); }); it("keeps note PII in the activity while using a fixed non-PII audit reason", async () => { const privateNote = "CUSTOMER-PII-MARKER customer@example.test called about billing"; await expect( runWithRlsContext({ userId: OPERATOR_USER_ID }, () => createPrismaPlatformLeadService(client).addNote({ leadId: NOTE_PII_LEAD_ID, note: privateNote, actorAdminUserId: OPERATOR_USER_ID, reason: privateNote, }) ) ).resolves.toMatchObject({ id: NOTE_PII_LEAD_ID }); const activity = await admin.query<{ note: string | null }>( `SELECT "payload"->>'note' AS note FROM "AdminLeadActivity" WHERE "leadId" = $1 AND type = 'note_added' ORDER BY "createdAt" DESC LIMIT 1`, [NOTE_PII_LEAD_ID] ); expect(activity.rows[0]?.note).toBe(privateNote); const audit = await admin.query<{ payload: Record; serialized: string }>( `SELECT "payload", "payload"::text AS serialized FROM "OutboxEvent" WHERE "eventType" = 'audit.event.create' AND "payload"->>'targetId' = $1 AND "payload"->>'action' = 'admin.lead.noteAdded' ORDER BY "createdAt" DESC LIMIT 1`, [NOTE_PII_LEAD_ID] ); expect(audit.rows[0]?.payload).toEqual(expect.objectContaining({ metadata: { reason: "Operator note added" } })); expect(audit.rows[0]?.serialized).not.toContain("CUSTOMER-PII-MARKER"); expect(audit.rows[0]?.serialized).not.toContain("customer@example.test"); }); });