Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/portal-rls-runtime-readiness.server.ts
T

500 lines
24 KiB
TypeScript

import { getReadDbClient, getWriteDbClient, type DbClient } from "./client.server.js";
import {
PORTAL_RLS_CROSS_ROLE_CAPABILITY_CONTRACT,
PORTAL_RLS_COLUMN_PRIVILEGE_CONTRACT,
PORTAL_RLS_POLICY_CONTRACT,
PORTAL_RLS_PRIVATE_DEFINER_HELPER_SIGNATURES,
PORTAL_RLS_PRIVATE_HELPER_SIGNATURES,
PORTAL_RLS_RESOLVER_SIGNATURES,
PORTAL_RLS_RUNTIME_ROLE,
PORTAL_RLS_TABLE_PRIVILEGE_CONTRACT,
} from "./portal-rls-runtime-contract.js";
import { resolveRlsRuntimeMode, type RlsRuntimeMode } from "./rls-runtime-readiness.server.js";
type PortalRlsProbeClient = Pick<DbClient, "$queryRawUnsafe">;
export type PortalRlsRuntimeProbe = {
sessionRoleName: string;
roleName: string;
roleExists: boolean;
canLogin: boolean;
isSuperuser: boolean;
canCreateDb: boolean;
canCreateRole: boolean;
inherits: boolean;
replicates: boolean;
bypassesRls: boolean;
membershipCount: number;
hasSchemaUsage: boolean;
hasSchemaCreate: boolean;
expectedRlsMismatchCount: number;
expectedPolicyMismatchCount: number;
unexpectedPortalPolicyCount: number;
expectedPrivilegeMismatchCount: number;
unexpectedTablePrivilegeCount: number;
expectedColumnPrivilegeMismatchCount: number;
unexpectedColumnPrivilegeCount: number;
resolverMismatchCount: number;
unexpectedResolverCount: number;
unexpectedDefinerExecuteCount: number;
tenantContext: string | null;
userContext: string | null;
portalUserContext: string | null;
publicKnowledgeBaseContext: string | null;
platformAnalyticsContext: string | null;
};
export type PortalRlsRuntimeReadiness = {
mode: RlsRuntimeMode;
ready: boolean;
diagnostics: string[];
probes: PortalRlsRuntimeProbe[];
};
function sqlLiteral(value: string): string {
return `'${value.replaceAll("'", "''")}'`;
}
const EXPECTED_POLICY_VALUES_SQL = PORTAL_RLS_POLICY_CONTRACT.map(
({ table, policy, command, usingHash, withCheckHash }) =>
`(${sqlLiteral(table)}, ${sqlLiteral(policy)}, ${sqlLiteral(command)}, ${usingHash === null ? "NULL" : sqlLiteral(usingHash)}, ${withCheckHash === null ? "NULL" : sqlLiteral(withCheckHash)})`
).join(",\n ");
const EXPECTED_PRIVILEGE_ROWS_SQL = PORTAL_RLS_TABLE_PRIVILEGE_CONTRACT.flatMap(({ table, privileges }) =>
privileges.map((privilege) => `(${sqlLiteral(table)}, ${sqlLiteral(privilege)})`)
).join(",\n ");
const EXPECTED_PRIVILEGE_VALUES_SQL = EXPECTED_PRIVILEGE_ROWS_SQL
? `VALUES\n ${EXPECTED_PRIVILEGE_ROWS_SQL}`
: "SELECT NULL::text, NULL::text WHERE false";
const EXPECTED_COLUMN_PRIVILEGE_VALUES_SQL = PORTAL_RLS_COLUMN_PRIVILEGE_CONTRACT.flatMap(({ table, privilege, columns }) =>
columns.map((column) => `(${sqlLiteral(table)}, ${sqlLiteral(column)}, ${sqlLiteral(privilege)})`)
).join(",\n ");
const EXPECTED_RESOLVER_VALUES_SQL = PORTAL_RLS_RESOLVER_SIGNATURES.map((signature) => `(${sqlLiteral(signature)})`).join(",\n ");
const EXPECTED_PRIVATE_HELPER_VALUES_SQL = PORTAL_RLS_PRIVATE_HELPER_SIGNATURES.map((signature) => `(${sqlLiteral(signature)})`).join(",\n ");
const EXPECTED_PRIVATE_DEFINER_HELPER_VALUES_SQL = PORTAL_RLS_PRIVATE_DEFINER_HELPER_SIGNATURES.map(
(signature) => `(${sqlLiteral(signature)})`,
).join(",\n ");
const EXPECTED_CROSS_ROLE_CAPABILITY_VALUES_SQL = PORTAL_RLS_CROSS_ROLE_CAPABILITY_CONTRACT.map(
({ signature, runtimeRole }) => `(${sqlLiteral(signature)}, ${sqlLiteral(runtimeRole)})`,
).join(",\n ");
export async function verifyPortalRlsRuntimeReadiness(
clients: readonly PortalRlsProbeClient[] = uniqueClients(getWriteDbClient(), getReadDbClient()),
env: NodeJS.ProcessEnv = process.env
): Promise<PortalRlsRuntimeReadiness> {
const mode = resolveRlsRuntimeMode(env);
if (mode === "off") return { mode, ready: true, diagnostics: [], probes: [] };
const probes = await Promise.all(clients.map(readPortalRlsRuntimeProbe));
const diagnostics = probes.flatMap(diagnosePortalProbe);
return { mode, ready: diagnostics.length === 0, diagnostics, probes };
}
export async function assertPortalRlsRuntimeReady(
clients?: readonly PortalRlsProbeClient[],
env: NodeJS.ProcessEnv = process.env
): Promise<PortalRlsRuntimeReadiness> {
const result = await verifyPortalRlsRuntimeReadiness(clients, env);
if (result.mode === "required" && !result.ready) {
throw new Error(`Portal RLS runtime readiness failed: ${result.diagnostics.join(", ")}`);
}
return result;
}
async function readPortalRlsRuntimeProbe(client: PortalRlsProbeClient): Promise<PortalRlsRuntimeProbe> {
const rows = await client.$queryRawUnsafe<
Array<{
session_role_name: string;
role_name: string;
role_exists: boolean;
can_login: boolean;
is_superuser: boolean;
can_create_db: boolean;
can_create_role: boolean;
inherits: boolean;
replicates: boolean;
bypasses_rls: boolean;
membership_count: number;
has_schema_usage: boolean;
has_schema_create: boolean;
expected_rls_mismatch_count: number;
expected_policy_mismatch_count: number;
unexpected_portal_policy_count: number;
expected_privilege_mismatch_count: number;
unexpected_table_privilege_count: number;
expected_column_privilege_mismatch_count: number;
unexpected_column_privilege_count: number;
resolver_mismatch_count: number;
unexpected_resolver_count: number;
unexpected_definer_execute_count: number;
tenant_context: string | null;
user_context: string | null;
portal_user_context: string | null;
public_knowledge_base_context: string | null;
platform_analytics_context: string | null;
}>
>(`
WITH expected_policy(table_name, policy_name, command, using_hash, with_check_hash) AS (
VALUES
${EXPECTED_POLICY_VALUES_SQL}
),
expected_table(table_name) AS (
SELECT DISTINCT table_name FROM expected_policy
),
expected_privilege(table_name, privilege_type) AS (
${EXPECTED_PRIVILEGE_VALUES_SQL}
),
expected_column_privilege(table_name, column_name, privilege_type) AS (
VALUES
${EXPECTED_COLUMN_PRIVILEGE_VALUES_SQL}
),
expected_resolver(signature) AS (
VALUES
${EXPECTED_RESOLVER_VALUES_SQL}
),
expected_private_helper(signature) AS (
VALUES
${EXPECTED_PRIVATE_HELPER_VALUES_SQL}
),
expected_private_definer_helper(signature) AS (
VALUES
${EXPECTED_PRIVATE_DEFINER_HELPER_VALUES_SQL}
),
expected_cross_role_capability(signature, runtime_role) AS (
VALUES
${EXPECTED_CROSS_ROLE_CAPABILITY_VALUES_SQL}
)
SELECT
session_user::text AS session_role_name,
current_user::text AS role_name,
EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}') AS role_exists,
COALESCE((SELECT rolcanlogin FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS can_login,
COALESCE((SELECT rolsuper FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS is_superuser,
COALESCE((SELECT rolcreatedb FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS can_create_db,
COALESCE((SELECT rolcreaterole FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS can_create_role,
COALESCE((SELECT rolinherit FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS inherits,
COALESCE((SELECT rolreplication FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS replicates,
COALESCE((SELECT rolbypassrls FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), false) AS bypasses_rls,
(
SELECT COUNT(*)::int
FROM pg_auth_members AS membership
JOIN pg_roles AS granted ON granted.oid = membership.roleid
JOIN pg_roles AS member ON member.oid = membership.member
WHERE granted.rolname = '${PORTAL_RLS_RUNTIME_ROLE}' OR member.rolname = '${PORTAL_RLS_RUNTIME_ROLE}'
) AS membership_count,
has_schema_privilege('${PORTAL_RLS_RUNTIME_ROLE}', 'public', 'USAGE') AS has_schema_usage,
has_schema_privilege('${PORTAL_RLS_RUNTIME_ROLE}', 'public', 'CREATE') AS has_schema_create,
(
SELECT COUNT(*)::int
FROM expected_table AS expected
LEFT JOIN pg_class AS class
ON class.relname = expected.table_name
AND class.relnamespace = 'public'::regnamespace
WHERE class.oid IS NULL
OR class.relkind NOT IN ('r', 'p')
OR class.relrowsecurity IS DISTINCT FROM true
OR class.relforcerowsecurity IS DISTINCT FROM true
) AS expected_rls_mismatch_count,
(
SELECT COUNT(*)::int
FROM expected_policy AS expected
LEFT JOIN pg_class AS class ON class.relname = expected.table_name AND class.relnamespace = 'public'::regnamespace
LEFT JOIN pg_policy AS policy
ON policy.polrelid = class.oid
AND policy.polname = expected.policy_name
AND policy.polcmd::text = expected.command
WHERE policy.oid IS NULL
OR policy.polpermissive IS DISTINCT FROM true
OR ARRAY(
SELECT CASE
WHEN policy_role.role_oid = 0 THEN 'PUBLIC'
ELSE role.rolname::text
END
FROM unnest(policy.polroles) AS policy_role(role_oid)
LEFT JOIN pg_roles AS role ON role.oid = policy_role.role_oid
ORDER BY 1
) IS DISTINCT FROM ARRAY['${PORTAL_RLS_RUNTIME_ROLE}']::text[]
OR md5(regexp_replace(pg_get_expr(policy.polqual, policy.polrelid, false), '[[:space:]]+', '', 'g'))
IS DISTINCT FROM expected.using_hash
OR md5(regexp_replace(pg_get_expr(policy.polwithcheck, policy.polrelid, false), '[[:space:]]+', '', 'g'))
IS DISTINCT FROM expected.with_check_hash
) AS expected_policy_mismatch_count,
(
SELECT COUNT(*)::int
FROM pg_policy AS policy
JOIN pg_class AS class ON class.oid = policy.polrelid
WHERE class.relnamespace = 'public'::regnamespace
AND (
COALESCE((SELECT oid FROM pg_roles WHERE rolname = '${PORTAL_RLS_RUNTIME_ROLE}'), 0::oid) = ANY (policy.polroles)
OR (
0::oid = ANY (policy.polroles)
AND EXISTS (SELECT 1 FROM expected_table AS expected WHERE expected.table_name = class.relname)
)
)
AND NOT EXISTS (
SELECT 1 FROM expected_policy AS expected
WHERE expected.table_name = class.relname
AND expected.policy_name = policy.polname
AND expected.command = policy.polcmd::text
)
) AS unexpected_portal_policy_count,
(
SELECT COUNT(*)::int
FROM expected_privilege AS expected
WHERE NOT has_table_privilege(
'${PORTAL_RLS_RUNTIME_ROLE}',
format('%I.%I', 'public', expected.table_name),
expected.privilege_type
)
) AS expected_privilege_mismatch_count,
(
SELECT COUNT(*)::int
FROM pg_class AS class
CROSS JOIN (VALUES ('SELECT'), ('INSERT'), ('UPDATE'), ('DELETE'), ('TRUNCATE'), ('REFERENCES'), ('TRIGGER')) AS candidate(privilege_type)
WHERE class.relnamespace = 'public'::regnamespace
AND class.relkind IN ('r', 'p', 'v', 'm', 'f')
AND has_table_privilege('${PORTAL_RLS_RUNTIME_ROLE}', class.oid, candidate.privilege_type)
AND NOT EXISTS (
SELECT 1 FROM expected_privilege AS expected
WHERE expected.table_name = class.relname
AND expected.privilege_type = candidate.privilege_type
)
) AS unexpected_table_privilege_count,
(
SELECT COUNT(*)::int
FROM expected_column_privilege AS expected
JOIN pg_class AS class
ON class.relname = expected.table_name
AND class.relnamespace = 'public'::regnamespace
JOIN pg_attribute AS attribute
ON attribute.attrelid = class.oid
AND attribute.attname = expected.column_name
AND attribute.attnum > 0
AND NOT attribute.attisdropped
WHERE NOT has_column_privilege(
'${PORTAL_RLS_RUNTIME_ROLE}',
class.oid,
attribute.attnum,
expected.privilege_type
)
) AS expected_column_privilege_mismatch_count,
(
SELECT COUNT(*)::int
FROM pg_class AS class
JOIN pg_attribute AS attribute
ON attribute.attrelid = class.oid
AND attribute.attnum > 0
AND NOT attribute.attisdropped
CROSS JOIN (VALUES ('SELECT'), ('INSERT'), ('UPDATE'), ('REFERENCES')) AS candidate(privilege_type)
WHERE class.relnamespace = 'public'::regnamespace
AND class.relkind IN ('r', 'p', 'v', 'm', 'f')
AND has_column_privilege('${PORTAL_RLS_RUNTIME_ROLE}', class.oid, attribute.attnum, candidate.privilege_type)
AND NOT EXISTS (
SELECT 1 FROM expected_privilege AS expected
WHERE expected.table_name = class.relname
AND expected.privilege_type = candidate.privilege_type
)
AND NOT EXISTS (
SELECT 1 FROM expected_column_privilege AS expected
WHERE expected.table_name = class.relname
AND expected.column_name = attribute.attname
AND expected.privilege_type = candidate.privilege_type
)
) AS unexpected_column_privilege_count,
(
SELECT (
SELECT COUNT(*)::int
FROM expected_resolver AS expected
LEFT JOIN pg_proc AS procedure ON procedure.oid = to_regprocedure(expected.signature)
LEFT JOIN pg_roles AS owner ON owner.oid = procedure.proowner
WHERE procedure.oid IS NULL
OR owner.rolname IS DISTINCT FROM 'hivegrid_rls_definer'
OR procedure.prokind IS DISTINCT FROM 'f'
OR procedure.prosecdef IS DISTINCT FROM true
OR NOT (procedure.proconfig @> ARRAY['search_path=pg_catalog, public', 'row_security=off']::text[])
OR NOT has_function_privilege('${PORTAL_RLS_RUNTIME_ROLE}', procedure.oid, 'EXECUTE')
OR EXISTS (
SELECT 1
FROM aclexplode(COALESCE(procedure.proacl, acldefault('f', procedure.proowner))) AS access
LEFT JOIN pg_roles AS grantee ON grantee.oid = access.grantee
WHERE access.privilege_type = 'EXECUTE'
AND access.grantee <> procedure.proowner
AND (access.grantee = 0 OR grantee.rolname <> '${PORTAL_RLS_RUNTIME_ROLE}')
)
) + (
SELECT COUNT(*)::int
FROM expected_private_helper AS expected
LEFT JOIN pg_proc AS procedure ON procedure.oid = to_regprocedure(expected.signature)
LEFT JOIN pg_roles AS owner ON owner.oid = procedure.proowner
WHERE procedure.oid IS NULL
OR owner.rolname IS DISTINCT FROM 'hivegrid_rls_definer'
OR procedure.prokind IS DISTINCT FROM 'f'
OR procedure.prosecdef IS DISTINCT FROM false
OR has_function_privilege('${PORTAL_RLS_RUNTIME_ROLE}', procedure.oid, 'EXECUTE')
) + (
SELECT COUNT(*)::int
FROM expected_private_definer_helper AS expected
LEFT JOIN pg_proc AS procedure ON procedure.oid = to_regprocedure(expected.signature)
LEFT JOIN pg_roles AS owner ON owner.oid = procedure.proowner
WHERE procedure.oid IS NULL
OR owner.rolname IS DISTINCT FROM 'hivegrid_rls_definer'
OR procedure.prokind IS DISTINCT FROM 'f'
OR procedure.prosecdef IS DISTINCT FROM true
OR NOT (procedure.proconfig @> ARRAY['search_path=pg_catalog, public', 'row_security=off']::text[])
OR has_function_privilege('${PORTAL_RLS_RUNTIME_ROLE}', procedure.oid, 'EXECUTE')
OR EXISTS (
SELECT 1
FROM aclexplode(COALESCE(procedure.proacl, acldefault('f', procedure.proowner))) AS access
WHERE access.privilege_type = 'EXECUTE'
AND access.grantee <> procedure.proowner
)
) + (
SELECT COUNT(*)::int
FROM expected_cross_role_capability AS expected
LEFT JOIN pg_proc AS procedure ON procedure.oid = to_regprocedure(expected.signature)
LEFT JOIN pg_roles AS owner ON owner.oid = procedure.proowner
WHERE procedure.oid IS NULL
OR owner.rolname IS DISTINCT FROM 'hivegrid_rls_definer'
OR procedure.prokind IS DISTINCT FROM 'f'
OR procedure.prosecdef IS DISTINCT FROM true
OR NOT (procedure.proconfig @> ARRAY['search_path=pg_catalog, public', 'row_security=off']::text[])
OR has_function_privilege('${PORTAL_RLS_RUNTIME_ROLE}', procedure.oid, 'EXECUTE')
OR NOT has_function_privilege(expected.runtime_role, procedure.oid, 'EXECUTE')
OR EXISTS (
SELECT 1
FROM aclexplode(COALESCE(procedure.proacl, acldefault('f', procedure.proowner))) AS access
LEFT JOIN pg_roles AS grantee ON grantee.oid = access.grantee
WHERE access.privilege_type = 'EXECUTE'
AND access.grantee <> procedure.proowner
AND (access.grantee = 0 OR grantee.rolname IS DISTINCT FROM expected.runtime_role)
)
)
) AS resolver_mismatch_count,
(
SELECT COUNT(*)::int
FROM pg_proc AS procedure
JOIN pg_namespace AS namespace ON namespace.oid = procedure.pronamespace
WHERE namespace.nspname = 'public'
AND procedure.proname LIKE 'hivegrid_portal_%'
AND NOT EXISTS (
SELECT 1 FROM expected_resolver AS expected WHERE procedure.oid = to_regprocedure(expected.signature)
)
AND NOT EXISTS (
SELECT 1 FROM expected_private_helper AS expected WHERE procedure.oid = to_regprocedure(expected.signature)
)
AND NOT EXISTS (
SELECT 1 FROM expected_private_definer_helper AS expected WHERE procedure.oid = to_regprocedure(expected.signature)
)
AND NOT EXISTS (
SELECT 1 FROM expected_cross_role_capability AS expected WHERE procedure.oid = to_regprocedure(expected.signature)
)
) AS unexpected_resolver_count,
(
SELECT COUNT(*)::int
FROM pg_proc AS procedure
JOIN pg_roles AS owner ON owner.oid = procedure.proowner
WHERE owner.rolname = 'hivegrid_rls_definer'
AND has_function_privilege('${PORTAL_RLS_RUNTIME_ROLE}', procedure.oid, 'EXECUTE')
AND NOT EXISTS (
SELECT 1 FROM expected_resolver AS expected WHERE procedure.oid = to_regprocedure(expected.signature)
)
) AS unexpected_definer_execute_count,
NULLIF(current_setting('app.tenant_id', true), '') AS tenant_context,
NULLIF(current_setting('app.user_id', true), '') AS user_context,
NULLIF(current_setting('app.portal_user_id', true), '') AS portal_user_context,
NULLIF(current_setting('app.public_knowledge_base_id', true), '') AS public_knowledge_base_context,
NULLIF(current_setting('app.platform_analytics', true), '') AS platform_analytics_context
`);
const row = rows[0];
if (
!row ||
typeof row.session_role_name !== "string" ||
typeof row.role_name !== "string" ||
!Number.isInteger(row.membership_count) ||
!Number.isInteger(row.expected_rls_mismatch_count) ||
!Number.isInteger(row.expected_policy_mismatch_count) ||
!Number.isInteger(row.unexpected_portal_policy_count) ||
!Number.isInteger(row.expected_privilege_mismatch_count) ||
!Number.isInteger(row.unexpected_table_privilege_count) ||
!Number.isInteger(row.expected_column_privilege_mismatch_count) ||
!Number.isInteger(row.unexpected_column_privilege_count) ||
!Number.isInteger(row.resolver_mismatch_count) ||
!Number.isInteger(row.unexpected_resolver_count) ||
!Number.isInteger(row.unexpected_definer_execute_count)
) {
throw new Error("Portal RLS runtime readiness returned an invalid database probe");
}
return {
sessionRoleName: row.session_role_name,
roleName: row.role_name,
roleExists: row.role_exists,
canLogin: row.can_login,
isSuperuser: row.is_superuser,
canCreateDb: row.can_create_db,
canCreateRole: row.can_create_role,
inherits: row.inherits,
replicates: row.replicates,
bypassesRls: row.bypasses_rls,
membershipCount: row.membership_count,
hasSchemaUsage: row.has_schema_usage,
hasSchemaCreate: row.has_schema_create,
expectedRlsMismatchCount: row.expected_rls_mismatch_count,
expectedPolicyMismatchCount: row.expected_policy_mismatch_count,
unexpectedPortalPolicyCount: row.unexpected_portal_policy_count,
expectedPrivilegeMismatchCount: row.expected_privilege_mismatch_count,
unexpectedTablePrivilegeCount: row.unexpected_table_privilege_count,
expectedColumnPrivilegeMismatchCount: row.expected_column_privilege_mismatch_count,
unexpectedColumnPrivilegeCount: row.unexpected_column_privilege_count,
resolverMismatchCount: row.resolver_mismatch_count,
unexpectedResolverCount: row.unexpected_resolver_count,
unexpectedDefinerExecuteCount: row.unexpected_definer_execute_count,
tenantContext: row.tenant_context,
userContext: row.user_context,
portalUserContext: row.portal_user_context,
publicKnowledgeBaseContext: row.public_knowledge_base_context,
platformAnalyticsContext: row.platform_analytics_context,
};
}
function diagnosePortalProbe(probe: PortalRlsRuntimeProbe, index: number): string[] {
const prefix = `portal_database_${index + 1}`;
return [
...(probe.sessionRoleName === PORTAL_RLS_RUNTIME_ROLE ? [] : [`${prefix}:runtime_session_role_mismatch`]),
...(probe.roleName === PORTAL_RLS_RUNTIME_ROLE ? [] : [`${prefix}:runtime_role_mismatch`]),
...(probe.sessionRoleName === probe.roleName ? [] : [`${prefix}:runtime_role_switch_detected`]),
...(probe.roleExists ? [] : [`${prefix}:portal_role_missing`]),
...(probe.canLogin ? [] : [`${prefix}:portal_role_no_login`]),
...(!probe.isSuperuser ? [] : [`${prefix}:portal_role_superuser`]),
...(!probe.canCreateDb ? [] : [`${prefix}:portal_role_createdb`]),
...(!probe.canCreateRole ? [] : [`${prefix}:portal_role_createrole`]),
...(!probe.inherits ? [] : [`${prefix}:portal_role_inherit`]),
...(!probe.replicates ? [] : [`${prefix}:portal_role_replication`]),
...(!probe.bypassesRls ? [] : [`${prefix}:portal_role_bypassrls`]),
...(probe.membershipCount === 0 ? [] : [`${prefix}:portal_role_membership`]),
...(probe.hasSchemaUsage ? [] : [`${prefix}:portal_schema_usage_missing`]),
...(!probe.hasSchemaCreate ? [] : [`${prefix}:portal_schema_create`]),
...(probe.expectedRlsMismatchCount === 0 ? [] : [`${prefix}:portal_rls_table_mismatch`]),
...(probe.expectedPolicyMismatchCount === 0 ? [] : [`${prefix}:portal_policy_mismatch`]),
...(probe.unexpectedPortalPolicyCount === 0 ? [] : [`${prefix}:portal_unexpected_policy`]),
...(probe.expectedPrivilegeMismatchCount === 0 ? [] : [`${prefix}:portal_privilege_missing`]),
...(probe.unexpectedTablePrivilegeCount === 0 ? [] : [`${prefix}:portal_unexpected_table_privilege`]),
...(probe.expectedColumnPrivilegeMismatchCount === 0 ? [] : [`${prefix}:portal_column_privilege_missing`]),
...(probe.unexpectedColumnPrivilegeCount === 0 ? [] : [`${prefix}:portal_unexpected_column_privilege`]),
...(probe.resolverMismatchCount === 0 ? [] : [`${prefix}:portal_resolver_mismatch`]),
...(probe.unexpectedResolverCount === 0 ? [] : [`${prefix}:portal_unexpected_resolver`]),
...(probe.unexpectedDefinerExecuteCount === 0 ? [] : [`${prefix}:portal_unexpected_definer_execute`]),
...(probe.tenantContext === null &&
probe.userContext === null &&
probe.portalUserContext === null &&
probe.publicKnowledgeBaseContext === null &&
probe.platformAnalyticsContext === null
? []
: [`${prefix}:leaked_rls_context`]),
];
}
function uniqueClients(...clients: PortalRlsProbeClient[]): PortalRlsProbeClient[] {
return [...new Set(clients)];
}