@prisma-next/target-postgres 0.14.0-dev.9 → 0.14.0-dev.90

package/dist/authoring-BtsOWgI3.mjs

@@ -0,0 +1,674 @@
+import { a as PG_ENUM_CODEC_ID } from "./codec-ids-B10ZZHzw.mjs";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-BwVNf0Ku.mjs";
+import { _ as PostgresRlsEnablement, d as PostgresRlsEnablementSchema, f as PostgresRlsPolicySchema, g as PostgresRlsPolicy, m as PostgresRole, p as PostgresRoleSchema, u as PostgresNativeEnumSchema } from "./postgres-schema-Cm4DtiGA.mjs";
+import { a as normalizePredicate, i as computeContentHash, r as POLICY_OPERATION_PREDICATES, t as formatRlsPolicyWireName } from "./wire-name-DbQ9-2RC.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
+import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { modelAttribute } from "@prisma-next/psl-parser";
+import { assertDefined } from "@prisma-next/utils/assertions";
+//#region src/core/authoring.ts
+/**
+* `pg.enum(<ref>)` registers as an ordinary type constructor whose sole
+* positional argument names a `native_enum` entity instead of carrying a
+* literal value. The interpreter resolves the ref to the `native_enum`
+* entity generically (driven by `entityRefArg`); the `pg/enum@1` codec
+* descriptor's `columnFromEntity` hook (see `codecs.ts`) converts that
+* entity into the column's `typeParams` and native type.
+*/
+const postgresAuthoringTypes = { pg: { enum: {
+	kind: "typeConstructor",
+	entityRefArg: {
+		index: 0,
+		entityKind: "native_enum"
+	},
+	output: { codecId: PG_ENUM_CODEC_ID }
+} } };
+/**
+* Maps a `policy_<op>` keyword to the RLS operation it authors. The keyword
+* IS the operation (per the project's rejection of a `policy { operation = … }`
+* conditional block).
+*/
+const POLICY_KEYWORD_OPERATION = {
+	policy_select: "select",
+	policy_insert: "insert",
+	policy_update: "update",
+	policy_delete: "delete",
+	policy_all: "all"
+};
+function readValueParam(block, key) {
+	const param = block.parameters[key];
+	return param?.kind === "value" ? param.raw : void 0;
+}
+function readListRefParams(block, key) {
+	const param = block.parameters[key];
+	if (param?.kind !== "list") return [];
+	return param.items.flatMap((item) => item.kind === "ref" ? [item.identifier] : []);
+}
+/**
+* Unwraps a quoted PSL string argument, inverting the printer's
+* `escapePslString` escapes (`\\`, `\"`, `\n`, `\r`). An unknown escape
+* sequence is kept verbatim, matching the printer-side `unescapePslString`
+* convention.
+*/
+function unwrapQuotedString(raw) {
+	if (!(raw.startsWith("\"") && raw.endsWith("\"") && raw.length >= 2)) return raw;
+	const inner = raw.slice(1, -1);
+	let result = "";
+	for (let i = 0; i < inner.length; i++) {
+		if (inner[i] !== "\\" || i + 1 >= inner.length) {
+			result += inner[i];
+			continue;
+		}
+		const next = inner[i + 1];
+		if (next === "\\" || next === "\"") result += next;
+		else if (next === "n") result += "\n";
+		else if (next === "r") result += "\r";
+		else {
+			result += "\\";
+			result += next;
+		}
+		i++;
+	}
+	return result;
+}
+/**
+* Assembles a {@link PostgresRlsPolicy} from lowered inputs: normalizes the
+* predicates, computes the content-hash wire name, and constructs the frozen
+* entity. The single hash-assembly body shared by the PSL block lowering
+* ({@link lowerRlsPolicyFromBlock}) and the TS entity-handle lowering
+* ({@link postgresLowerEntityHandles}) so the two surfaces cannot drift.
+*/
+function buildRlsPolicyEntity(input) {
+	const wireHash = computeContentHash({
+		...ifDefined("using", input.using !== void 0 ? normalizePredicate(input.using) : void 0),
+		...ifDefined("withCheck", input.withCheck !== void 0 ? normalizePredicate(input.withCheck) : void 0),
+		roles: input.roles,
+		operation: input.operation,
+		permissive: true
+	});
+	return new PostgresRlsPolicy({
+		name: formatRlsPolicyWireName(input.prefix, wireHash),
+		prefix: input.prefix,
+		tableName: input.tableName,
+		namespaceId: input.namespaceId,
+		operation: input.operation,
+		roles: input.roles,
+		...ifDefined("using", input.using),
+		...ifDefined("withCheck", input.withCheck),
+		permissive: true
+	});
+}
+function lowerRlsPolicyFromBlock(block, ctx) {
+	const prefix = block.name;
+	const operation = POLICY_KEYWORD_OPERATION[block.keyword] ?? "select";
+	const tableName = block.resolvedModelRefs?.["target"]?.tableName;
+	assertDefined(tableName, `lowerRlsPolicyFromBlock: policy "${block.name}" reached the factory without a resolved \`target\` ref; the interpreter resolves same-namespace model refs before invoking entity factories.`);
+	const roles = [...readListRefParams(block, "roles")].sort();
+	const usingRaw = readValueParam(block, "using");
+	const withCheckRaw = readValueParam(block, "withCheck");
+	const support = POLICY_OPERATION_PREDICATES[operation];
+	const rejectPredicate = (predicate) => {
+		ctx.diagnostics?.push({
+			code: "PSL_RLS_PREDICATE_NOT_FOR_OPERATION",
+			message: `\`${block.keyword}\` policy "${block.name}" does not take a \`${predicate}\` predicate; the ${operation.toUpperCase()} operation uses ${support.using ? "`using`" : "`withCheck`"}${support.using && support.withCheck ? " and `withCheck`" : " only"}.`,
+			sourceId: ctx.sourceId ?? "unknown",
+			span: block.parameters[predicate]?.span ?? block.span
+		});
+	};
+	if (usingRaw !== void 0 && !support.using) return rejectPredicate("using");
+	if (withCheckRaw !== void 0 && !support.withCheck) return rejectPredicate("withCheck");
+	const using = usingRaw !== void 0 ? unwrapQuotedString(usingRaw) : void 0;
+	const withCheck = withCheckRaw !== void 0 ? unwrapQuotedString(withCheckRaw) : void 0;
+	return buildRlsPolicyEntity({
+		prefix,
+		tableName,
+		namespaceId: block.namespaceId,
+		operation,
+		roles,
+		...ifDefined("using", using),
+		...ifDefined("withCheck", withCheck)
+	});
+}
+/**
+* Lowers a `native_enum { memberName = "value" … @@map("type_name") }` block
+* into a {@link PostgresNativeEnum}. Members must be authored as explicit
+* `key = "value"` pairs — a bare (value-less) member is a diagnostic, not
+* accepted (authoring-design.md §2.1). The parsed `memberName` is only used
+* to duplicate-check and report diagnostics; the lowered entity carries just
+* the member values (a native enum is value-only — the member "name" isn't
+* a separate authoring concept from the value). `typeName` comes from
+* `@@map` or defaults to the block name verbatim.
+*/
+function lowerNativeEnumFromBlock(block, ctx) {
+	const sourceId = ctx.sourceId ?? "unknown";
+	const diagnostics = ctx.diagnostics;
+	const mapAttr = block.blockAttributes.find((a) => a.name === "map");
+	let typeName = block.name;
+	if (mapAttr) {
+		const rawArg = mapAttr.args[0]?.value;
+		const mapped = rawArg !== void 0 ? unwrapQuotedString(rawArg) : void 0;
+		if (mapped === void 0) {
+			diagnostics?.push({
+				code: "PSL_NATIVE_ENUM_INVALID_MAP",
+				message: `native_enum "${block.name}" @@map attribute must have a quoted type-name argument`,
+				sourceId,
+				span: mapAttr.span
+			});
+			return;
+		}
+		typeName = mapped;
+	}
+	let memberError = false;
+	const seenValues = /* @__PURE__ */ new Set();
+	const members = [];
+	for (const [memberName, paramValue] of Object.entries(block.parameters)) {
+		if (paramValue.kind === "bare") {
+			diagnostics?.push({
+				code: "PSL_NATIVE_ENUM_BARE_MEMBER",
+				message: `native_enum "${block.name}" member "${memberName}" has no value; members must be authored as "${memberName} = \\"value\\""`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		if (paramValue.kind !== "value") continue;
+		let jsonValue;
+		try {
+			jsonValue = JSON.parse(paramValue.raw);
+		} catch {
+			diagnostics?.push({
+				code: "PSL_EXTENSION_INVALID_VALUE",
+				message: `native_enum "${block.name}" member "${memberName}" value "${paramValue.raw}" is not valid JSON`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		if (typeof jsonValue !== "string") {
+			diagnostics?.push({
+				code: "PSL_EXTENSION_INVALID_VALUE",
+				message: `native_enum "${block.name}" member "${memberName}" value must be a string`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		if (seenValues.has(jsonValue)) {
+			diagnostics?.push({
+				code: "PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE",
+				message: `native_enum "${block.name}": duplicate member value "${jsonValue}"`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		seenValues.add(jsonValue);
+		members.push(jsonValue);
+	}
+	if (memberError) return void 0;
+	if (members.length === 0) {
+		diagnostics?.push({
+			code: "PSL_NATIVE_ENUM_MISSING_MEMBERS",
+			message: `native_enum "${block.name}" must have at least one member`,
+			sourceId,
+			span: block.span
+		});
+		return;
+	}
+	return new PostgresNativeEnum({
+		typeName,
+		members
+	});
+}
+/**
+* `native_enum`'s entity-type factory output, checked separately from the assembled
+* `postgresAuthoringEntityTypes` map below: `deriveValueSet` is SQL-family surface
+* ({@link SqlValueSetDerivingEntityTypeOutput}), not part of the framework
+* `AuthoringEntityTypeFactoryOutput` shape, so folding it directly into the map's single
+* `satisfies AuthoringEntityTypeNamespace` check would trip an excess-property error. Checking it
+* here against the intersection of both shapes keeps it structurally valid against each without
+* widening the map's own check.
+*/
+const nativeEnumEntityTypeOutput = {
+	factory: lowerNativeEnumFromBlock,
+	deriveValueSet: (entity) => ({
+		kind: "valueSet",
+		values: [...entity.members]
+	})
+};
+/**
+* Lowers a `role <name> {}` block into a {@link PostgresRole}. Roles are
+* cluster-scoped in Postgres, so the block must be declared inside
+* `namespace unbound { … }` — any other lexical namespace (a named schema,
+* or the default bucket top-level declarations resolve to) is a load-time
+* diagnostic. The lowered entity carries the unbound coordinate.
+*/
+function lowerRoleFromBlock(block, ctx) {
+	if (block.namespaceId !== UNBOUND_NAMESPACE_ID) {
+		ctx.diagnostics?.push({
+			code: "PSL_ROLE_BLOCK_OUTSIDE_UNBOUND_NAMESPACE",
+			message: `\`role\` block "${block.name}" must be declared inside \`namespace unbound { }\`, not in namespace "${block.namespaceId}"`,
+			sourceId: ctx.sourceId ?? "unknown",
+			span: block.span
+		});
+		return;
+	}
+	return new PostgresRole({
+		name: block.name,
+		namespaceId: UNBOUND_NAMESPACE_ID
+	});
+}
+const postgresAuthoringEntityTypes = {
+	role: {
+		kind: "entity",
+		discriminator: "role",
+		validatorSchema: PostgresRoleSchema,
+		output: { factory: lowerRoleFromBlock }
+	},
+	rls: {
+		kind: "entity",
+		discriminator: "rls",
+		validatorSchema: PostgresRlsEnablementSchema,
+		output: { factory: (input) => new PostgresRlsEnablement(input) }
+	},
+	policy: {
+		kind: "entity",
+		discriminator: "policy",
+		validatorSchema: PostgresRlsPolicySchema,
+		output: { factory: lowerRlsPolicyFromBlock }
+	},
+	native_enum: {
+		kind: "entity",
+		discriminator: "native_enum",
+		validatorSchema: PostgresNativeEnumSchema,
+		output: nativeEnumEntityTypeOutput
+	}
+};
+/**
+* Field presets contributed by the Postgres target pack.
+*
+* These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
+* (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
+* via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
+* surface (e.g. `Int`) lowers to byte-identical contracts.
+*
+* The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the
+* native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target
+* portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from
+* the family pack instead.
+*/
+/**
+* Shared parameter descriptors for the five `policy_<op>` PSL block
+* keywords. All five share the `policy` discriminator — the parser
+* dispatches by keyword (see the framework's PSL-block SPI), and every
+* keyword's factory lowers to `PostgresRlsPolicy` via `lowerRlsPolicyFromBlock`.
+*
+* The `roles` list uses `scope:'cross-space'` because same-namespace
+* role ref resolution requires PSL namespace entries keyed by `refKind`
+* (i.e. `'role'`), which in turn requires the role block discriminator to
+* equal `'role'`. Aligning discriminator with refKind is tracked for
+* slice 4 (cross-space roles). Until then cross-space passes validation
+* unconditionally and the authored role names flow through unchanged.
+*/
+const policyTargetParam = {
+	kind: "ref",
+	refKind: "model",
+	scope: "same-namespace",
+	required: true
+};
+const policyRolesParam = {
+	kind: "list",
+	of: {
+		kind: "ref",
+		refKind: "role",
+		scope: "cross-space"
+	}
+};
+const policyPredicateParam = {
+	kind: "value",
+	codecId: "pg/text@1",
+	required: true
+};
+const policyRequiresRls = {
+	parameter: "target",
+	attribute: "rls"
+};
+const postgresAuthoringPslBlockDescriptors = {
+	policy_select: {
+		kind: "pslBlock",
+		keyword: "policy_select",
+		discriminator: "policy",
+		name: { required: true },
+		parameters: {
+			target: policyTargetParam,
+			roles: policyRolesParam,
+			using: policyPredicateParam
+		},
+		requiresModelAttribute: policyRequiresRls
+	},
+	policy_delete: {
+		kind: "pslBlock",
+		keyword: "policy_delete",
+		discriminator: "policy",
+		name: { required: true },
+		parameters: {
+			target: policyTargetParam,
+			roles: policyRolesParam,
+			using: policyPredicateParam
+		},
+		requiresModelAttribute: policyRequiresRls
+	},
+	policy_insert: {
+		kind: "pslBlock",
+		keyword: "policy_insert",
+		discriminator: "policy",
+		name: { required: true },
+		parameters: {
+			target: policyTargetParam,
+			roles: policyRolesParam,
+			withCheck: policyPredicateParam
+		},
+		requiresModelAttribute: policyRequiresRls
+	},
+	policy_update: {
+		kind: "pslBlock",
+		keyword: "policy_update",
+		discriminator: "policy",
+		name: { required: true },
+		parameters: {
+			target: policyTargetParam,
+			roles: policyRolesParam,
+			using: policyPredicateParam,
+			withCheck: policyPredicateParam
+		},
+		requiresModelAttribute: policyRequiresRls
+	},
+	policy_all: {
+		kind: "pslBlock",
+		keyword: "policy_all",
+		discriminator: "policy",
+		name: { required: true },
+		parameters: {
+			target: policyTargetParam,
+			roles: policyRolesParam,
+			using: policyPredicateParam,
+			withCheck: policyPredicateParam
+		},
+		requiresModelAttribute: policyRequiresRls
+	},
+	/**
+	* PSL block descriptor for `native_enum`.
+	*
+	* Reuses the existing variadic-block mechanism (the same shape the SQL
+	* family's `enum` block ships): the body is an open `memberName = "value"`
+	* list. `variadicParameters: true` opens the block to arbitrary keys
+	* beyond the declared (empty) `parameters` set — the lowering factory
+	* (`lowerNativeEnumFromBlock`) turns the variadic entries into ordered
+	* members and rejects a bare (value-less) member.
+	*/
+	native_enum: {
+		kind: "pslBlock",
+		keyword: "native_enum",
+		discriminator: "native_enum",
+		name: { required: true },
+		parameters: {},
+		variadicParameters: true
+	},
+	/**
+	* PSL block descriptor for `role` (e.g. `role anon {}`). Name-only, no
+	* parameters and no body content. Declared inside `namespace unbound { }`
+	* — see {@link lowerRoleFromBlock} for the placement check and the
+	* coordinate the lowered entity carries.
+	*/
+	role: {
+		kind: "pslBlock",
+		keyword: "role",
+		discriminator: "role",
+		name: { required: true },
+		parameters: {}
+	}
+};
+/**
+* `@@` model attributes contributed by the Postgres target pack.
+*
+* `@@rls` is argument-less: presence marks the model's table
+* RLS-controlled. It lowers to a {@link PostgresRlsEnablement} marker in
+* the namespace's `entries.rls`, keyed by the model's table name — the
+* marker (never the policy set) is what drives
+* `ENABLE`/`DISABLE ROW LEVEL SECURITY` planning.
+*/
+const postgresAuthoringModelAttributes = { rls: {
+	kind: "modelAttribute",
+	attribute: "rls",
+	spec: modelAttribute("rls", {}),
+	lower: (_parsed, ctx) => ({
+		key: ctx.storageName,
+		entity: new PostgresRlsEnablement({
+			tableName: ctx.storageName,
+			namespaceId: ctx.namespaceId
+		})
+	})
+} };
+const postgresAuthoringFieldPresets = {
+	text: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/text@1",
+			nativeType: "text"
+		}
+	},
+	int: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int4@1",
+			nativeType: "int4"
+		}
+	},
+	bigint: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int8@1",
+			nativeType: "int8"
+		}
+	},
+	float: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/float8@1",
+			nativeType: "float8"
+		}
+	},
+	decimal: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/numeric@1",
+			nativeType: "numeric"
+		}
+	},
+	boolean: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bool@1",
+			nativeType: "bool"
+		}
+	},
+	json: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/jsonb@1",
+			nativeType: "jsonb"
+		}
+	},
+	bytes: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bytea@1",
+			nativeType: "bytea"
+		}
+	},
+	dateTime: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/timestamptz@1",
+			nativeType: "timestamptz"
+		}
+	},
+	temporal: /* @__PURE__ */ temporalAuthoringPresets({
+		codecId: "pg/timestamptz@1",
+		nativeType: "timestamptz"
+	}),
+	uuidNative: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/uuid@1",
+			nativeType: "uuid"
+		}
+	},
+	id: {
+		uuidv4Native: {
+			kind: "fieldPreset",
+			output: {
+				codecId: "pg/uuid@1",
+				nativeType: "uuid",
+				executionDefaults: { onCreate: {
+					kind: "generator",
+					id: "uuidv4"
+				} },
+				id: true
+			}
+		},
+		uuidv7Native: {
+			kind: "fieldPreset",
+			output: {
+				codecId: "pg/uuid@1",
+				nativeType: "uuid",
+				executionDefaults: { onCreate: {
+					kind: "generator",
+					id: "uuidv7"
+				} },
+				id: true
+			}
+		}
+	}
+};
+/**
+* Postgres identifiers cap at 63 characters and the wire name appends a
+* 9-character `_<8hex>` suffix, so the authored prefix is bounded at 54.
+*/
+const RLS_POLICY_PREFIX_MAX_LENGTH = 54;
+/**
+* Resolves an entity handle's `target` ref to a table coordinate of this
+* contract, or throws the load-time diagnostic naming the handle: a
+* cross-space target is rejected (you cannot CREATE POLICY on a table
+* another space owns) and an unresolved target names the model.
+*/
+function requireLocalTarget(refs, subject) {
+	const target = refs["target"];
+	if (target !== void 0 && target.kind === "resolved") return {
+		namespaceId: target.namespaceId,
+		tableName: target.tableName
+	};
+	if (target !== void 0 && target.kind === "cross-space") throw new Error(`defineContract: ${subject} targets model "${target.modelName ?? target.tableName}", which lives in another contract space. Policies and rlsEnabled entries must target a model declared in this contract.`);
+	throw new Error(`defineContract: ${subject} targets model "${target?.modelName ?? "<anonymous>"}", which is not in the contract's models. Add the model to \`models\`.`);
+}
+/**
+* The SQL-family entity-handle batch lowering hook for the Postgres pack
+* (`SqlEntityHandleLoweringContribution`). Receives every `entities` handle
+* whose kind this pack registered — batch, so the cross-entity diagnostics
+* (duplicate prefix, policy without rlsEnabled, duplicate role) can see
+* sibling handles — and lowers them with the same keying and hash assembly
+* as the PSL path: `policy` keyed by prefix (wire name via
+* {@link buildRlsPolicyEntity}), `rls` keyed by table name, `role` keyed by
+* name and filed under the default namespace (roles are declared
+* contract-wide; PSL has no role block to set a precedent).
+*/
+function postgresLowerEntityHandles(input) {
+	const enablements = /* @__PURE__ */ new Map();
+	const roles = /* @__PURE__ */ new Map();
+	const policies = [];
+	const coordinateKey = (coordinate) => `${coordinate.namespaceId} ${coordinate.tableName}`;
+	for (const { handle, refs } of input.handles) switch (handle.entityKind) {
+		case "rls": {
+			const coordinate = requireLocalTarget(refs, "an rlsEnabled entry");
+			const key = coordinateKey(coordinate);
+			if (!enablements.has(key)) enablements.set(key, {
+				coordinate,
+				entity: new PostgresRlsEnablement({
+					tableName: coordinate.tableName,
+					namespaceId: coordinate.namespaceId
+				})
+			});
+			break;
+		}
+		case "role": {
+			const roleHandle = blindCast(handle);
+			if (roles.has(roleHandle.name)) throw new Error(`defineContract: role "${roleHandle.name}" is declared more than once in the entities list.`);
+			roles.set(roleHandle.name, new PostgresRole({
+				name: roleHandle.name,
+				namespaceId: UNBOUND_NAMESPACE_ID
+			}));
+			break;
+		}
+		case "policy": {
+			const policyHandle = blindCast(handle);
+			policies.push({
+				handle: policyHandle,
+				refs
+			});
+			break;
+		}
+		default: throw new Error(`defineContract: the postgres pack does not lower "${handle.entityKind}" handles from the entities list.`);
+	}
+	const rows = [];
+	const seenPrefixes = /* @__PURE__ */ new Set();
+	for (const { handle: policy, refs } of policies) {
+		const prefix = policy.name;
+		if (prefix.length > RLS_POLICY_PREFIX_MAX_LENGTH) throw new Error(`defineContract: policy prefix "${prefix}" exceeds the ${RLS_POLICY_PREFIX_MAX_LENGTH}-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`);
+		const coordinate = requireLocalTarget(refs, `policy "${prefix}"`);
+		if (!enablements.has(coordinateKey(coordinate))) {
+			const target = refs["target"];
+			throw new Error(`defineContract: policy "${prefix}" targets model "${target?.modelName ?? coordinate.tableName}", whose table is not RLS-enabled. Add rlsEnabled(<model>) to the entities list.`);
+		}
+		const prefixKey = `${coordinate.namespaceId} ${prefix}`;
+		if (seenPrefixes.has(prefixKey)) throw new Error(`defineContract: policy prefix "${prefix}" is declared more than once in namespace "${coordinate.namespaceId}". Policy prefixes must be unique per namespace.`);
+		seenPrefixes.add(prefixKey);
+		const roleNames = [...new Set(policy.roles.map((roleHandle) => roleHandle.name))].sort();
+		rows.push({
+			namespaceId: coordinate.namespaceId,
+			entityKind: "policy",
+			key: prefix,
+			entity: buildRlsPolicyEntity({
+				prefix,
+				tableName: coordinate.tableName,
+				namespaceId: coordinate.namespaceId,
+				operation: policy.operation,
+				roles: roleNames,
+				...ifDefined("using", policy.using),
+				...ifDefined("withCheck", policy.withCheck)
+			})
+		});
+	}
+	for (const { coordinate, entity } of enablements.values()) rows.push({
+		namespaceId: coordinate.namespaceId,
+		entityKind: "rls",
+		key: coordinate.tableName,
+		entity
+	});
+	for (const [name, entity] of roles) rows.push({
+		namespaceId: UNBOUND_NAMESPACE_ID,
+		entityKind: "role",
+		key: name,
+		entity
+	});
+	return rows;
+}
+//#endregion
+export { postgresAuthoringTypes as a, postgresAuthoringPslBlockDescriptors as i, postgresAuthoringFieldPresets as n, postgresLowerEntityHandles as o, postgresAuthoringModelAttributes as r, postgresAuthoringEntityTypes as t };
+
+//# sourceMappingURL=authoring-BtsOWgI3.mjs.map