Refresh HiveGrid Cloud reference snapshot
This commit is contained in:
1 parent
5e99e14772
commit
7f88026f79
5955 files changed
+1177325
-188362
No files matched your search
+794
@@ -0,0 +1,794 @@
|
||||
// @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");
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user