Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/platform-leads.rls.integration.test.ts
T

795 lines
34 KiB
TypeScript

// @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<AtomicArtifactCounts> {
const result = await admin.query<AtomicArtifactCounts>(
`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<Array<{ result: { leadId: string; convertedToTenantId: string; alreadyConverted: boolean } }>>(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<string, unknown>;
}>(
`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<string, unknown>;
}>(
`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<string, unknown>; 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");
});
});