@prisma-next/target-postgres 0.14.0-dev.44 → 0.14.0-dev.46

package/src/core/postgres-schema.ts

@@ -19,7 +19,8 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresTableSource } from './ast/table-source';
 import { PG_TEXT_CODEC_ID } from './codec-ids';
-import { policyEntityKind, roleEntityKind } from './entity-kinds';
+import { nativeEnumEntityKind, policyEntityKind, roleEntityKind } from './entity-kinds';
+import type { PostgresNativeEnum } from './postgres-native-enum';
 import type { PostgresRlsPolicy } from './postgres-rls-policy';
 import type { PostgresRole } from './postgres-role';
 import { escapeLiteral } from './sql-utils';
@@ -29,6 +30,7 @@ export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgr
 export type PostgresNamespaceEntries = SqlNamespaceEntries & {
   readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
   readonly role?: Readonly<Record<string, PostgresRole>>;
+  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;
 };
 
 export interface PostgresSchemaInput {
@@ -70,7 +72,7 @@ export class PostgresSchema extends SqlNamespaceBase {
 
     const dispatched = hydrateNamespaceEntities(
       input.entries,
-      composeSqlEntityKinds([policyEntityKind, roleEntityKind]),
+      composeSqlEntityKinds([policyEntityKind, roleEntityKind, nativeEnumEntityKind]),
       'carry',
     );
 
@@ -81,11 +83,33 @@ export class PostgresSchema extends SqlNamespaceBase {
         ? { ...dispatched, valueSet: undefined }
         : dispatched;
 
+    // `native_enum` is authoring-time-only (`PostgresContractSerializer`
+    // never re-emits it; its member values live on via the `valueSet`
+    // entry it derives). Carried as a non-enumerable property — like
+    // `kind` below — so `JSON.stringify` (the hashing pipeline's
+    // canonicalization step, `computeStorageHash` via `hashContract`)
+    // walks past it and the storage hash matches what actually gets
+    // serialized. Direct property access (`ns.entries.native_enum`)
+    // still resolves normally; only enumeration is affected.
+    const nativeEnumRaw = dispatched['native_enum'];
+    const entriesInput: Record<string, Readonly<Record<string, unknown>> | undefined> = {
+      ...withPresence,
+    };
+    delete entriesInput['native_enum'];
+    if (nativeEnumRaw !== undefined) {
+      Object.defineProperty(entriesInput, 'native_enum', {
+        value: nativeEnumRaw,
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+
     this.entries = Object.freeze(
       blindCast<
         PostgresNamespaceEntries,
-        'composeSqlEntityKinds([policyEntityKind, roleEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole descriptors'
-      >(withPresence),
+        'composeSqlEntityKinds([policyEntityKind, roleEntityKind, nativeEnumEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole, native_enum→PostgresNativeEnum descriptors'
+      >(entriesInput),
     );
     Object.defineProperty(this, 'kind', {
       value: 'schema',

package/src/core/postgres-validators.ts

@@ -18,3 +18,10 @@ export const PostgresRlsPolicySchema = type({
   'withCheck?': 'string',
   permissive: 'boolean',
 });
+
+export const PostgresNativeEnumSchema = type({
+  kind: "'postgres-enum'",
+  typeName: 'string',
+  members: type.string.array().readonly(),
+  'control?': "'managed' | 'tolerated' | 'external' | 'observed'",
+});

package/src/core/psl-infer/infer-psl-contract.ts

@@ -1,4 +1,5 @@
 import type { ColumnDefault } from '@prisma-next/contract/types';
+import type { SqlDescribedContractSpace } from '@prisma-next/family-sql/control';
 import type {
   DefaultMappingOptions,
   PslNativeTypeAttribute,
@@ -7,6 +8,8 @@ import type {
   RelationField,
 } from '@prisma-next/family-sql/psl-infer';
 import {
+  buildChildRelationField,
+  deriveRelationFieldName,
   inferRelations,
   mapDefault,
   parseRawDefault,
@@ -14,6 +17,7 @@ import {
   toModelName,
   toNamedTypeName,
 } from '@prisma-next/family-sql/psl-infer';
+import { coordinateKey, elementCoordinates } from '@prisma-next/framework-components/ir';
 import type {
   PslAttribute,
   PslAttributeArgument,
@@ -31,7 +35,15 @@ import {
   makePslNamespaceEntries,
   UNSPECIFIED_PSL_NAMESPACE_ID,
 } from '@prisma-next/framework-components/psl-ast';
-import type { SqlColumnIR, SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
+import type { SqlModelStorage } from '@prisma-next/sql-contract/types';
+import type {
+  SqlColumnIR,
+  SqlForeignKeyIR,
+  SqlSchemaIR,
+  SqlTableIR,
+} from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { createPostgresDefaultMapping } from './postgres-default-mapping';
 import { createPostgresTypeMap } from './postgres-type-map';
@@ -76,6 +88,179 @@ type TopLevelNameResult = {
   readonly map?: string | undefined;
 };
 
+/**
+ * Coordinates every element a set of already-assembled contracts declare,
+ * mapped to the {@link SqlDescribedContractSpace} that owns it and keyed by
+ * the shared {@link coordinateKey} helper. `contract infer` uses this to omit
+ * database elements a stack extension pack's contract space already
+ * describes — reusing the same coordinate walk the contract-space aggregate
+ * and cross-space collision check use (`elementCoordinates`), rather than a
+ * bespoke per-entity-kind membership test — and, for a foreign key whose
+ * referenced table an entry owns, to resolve the qualified cross-space
+ * relation it describes.
+ */
+function describedContractOwners(
+  describedContracts: readonly SqlDescribedContractSpace[],
+): ReadonlyMap<string, SqlDescribedContractSpace> {
+  const owners = new Map<string, SqlDescribedContractSpace>();
+  for (const entry of describedContracts) {
+    for (const coordinate of elementCoordinates(entry.contract.storage)) {
+      owners.set(coordinateKey(coordinate), entry);
+    }
+  }
+  return owners;
+}
+
+/**
+ * The domain model a described contract maps a `(namespaceId, tableName)`
+ * storage coordinate to, plus the pack's own space id and column→field-name
+ * mapping — everything `buildModel`/`buildRelationField` need to emit the
+ * cross-space relation `<spaceId>:<namespaceId>.<modelName>` and resolve its
+ * `references` argument to the pack's own field names rather than a generic
+ * column-name guess.
+ */
+type CrossSpaceTarget = {
+  readonly spaceId: string;
+  readonly namespaceId: string;
+  readonly modelName: string;
+  readonly fieldNamesByColumn: TableColumnFieldNameMap;
+};
+
+function resolveCrossSpaceTarget(
+  owner: SqlDescribedContractSpace,
+  namespaceId: string,
+  tableName: string,
+): CrossSpaceTarget | undefined {
+  const domainNamespace = owner.contract.domain.namespaces[namespaceId];
+  if (domainNamespace === undefined) {
+    return undefined;
+  }
+
+  for (const [modelName, model] of Object.entries(domainNamespace.models)) {
+    const storage = blindCast<SqlModelStorage, 'SQL contract model storage'>(model.storage);
+    if (storage.namespaceId !== namespaceId || storage.table !== tableName) {
+      continue;
+    }
+
+    const fieldNamesByColumn = new Map<string, ResolvedColumnFieldName>();
+    for (const [fieldName, fieldStorage] of Object.entries(storage.fields)) {
+      fieldNamesByColumn.set(fieldStorage.column, { fieldName });
+    }
+
+    return { spaceId: owner.spaceId, namespaceId, modelName, fieldNamesByColumn };
+  }
+
+  return undefined;
+}
+
+type ForeignKeyResolution = {
+  /** `tables`, with every cross-space or dangling foreign key removed. */
+  readonly tables: Record<string, SqlTableIR>;
+  /** Cross-space relation fields to merge onto `inferRelations`'s output, keyed by host table name. */
+  readonly extraRelationsByTable: ReadonlyMap<string, readonly RelationField[]>;
+  /** Synthetic field-name maps for cross-space-referenced pack tables, merged into `fieldNamesByTable`. */
+  readonly crossSpaceFieldNamesByTable: ReadonlyMap<string, TableColumnFieldNameMap>;
+};
+
+/**
+ * Classifies every foreign key on a surviving table into one of three cases.
+ * A foreign key that carries a `referencedSchema` is checked against the
+ * pack-owned coordinates first, so a pack-owned target wins even when a local
+ * table happens to share its bare name; only foreign keys with no owned
+ * coordinate fall through to the local/dangling distinction.
+ *
+ * - **Cross-space**: `referencedSchema` is set and a described contract owns
+ *   the coordinate `(referencedSchema, 'table', referencedTable)`. The
+ *   referenced table is absent from the tree (omitted because the pack
+ *   describes it, or never introspected — `contract infer` walks a single
+ *   namespace). Removed from `foreignKeys` (so `inferRelations` never falls
+ *   back to a bare, unqualified table name for it) and replaced with a
+ *   `RelationField` qualified with the owning pack's space id and namespace
+ *   id. `owners` holds only pack-declared coordinates, so an app's own table
+ *   (e.g. `public.users`) is never owned and cannot be captured here.
+ * - **Local**: not a pack-owned coordinate, and the referenced table survived
+ *   introspection — left untouched, `inferRelations` handles it as before.
+ * - **Dangling**: not a pack-owned coordinate, and the referenced table is
+ *   neither in the tree nor owned by any described contract. Removed from
+ *   `foreignKeys`, keeping the scalar column, rather than emitting a relation
+ *   to a model that was never defined.
+ *
+ * A pack that owns the referenced coordinate but declares no domain model
+ * mapped to it is malformed; that case throws rather than degrading to a
+ * silent drop, which would contradict the dangling definition above.
+ */
+function resolveForeignKeys(
+  tables: Readonly<Record<string, SqlTableIR>>,
+  owners: ReadonlyMap<string, SqlDescribedContractSpace>,
+): ForeignKeyResolution {
+  const resultTables: Record<string, SqlTableIR> = {};
+  const extraRelationsByTable = new Map<string, RelationField[]>();
+  const crossSpaceFieldNamesByTable = new Map<string, TableColumnFieldNameMap>();
+
+  for (const [tableName, table] of Object.entries(tables)) {
+    const keptForeignKeys: SqlForeignKeyIR[] = [];
+
+    for (const fk of table.foreignKeys) {
+      if (fk.referencedSchema !== undefined) {
+        const owner = owners.get(
+          coordinateKey({
+            namespaceId: fk.referencedSchema,
+            entityKind: 'table',
+            entityName: fk.referencedTable,
+          }),
+        );
+        if (owner !== undefined) {
+          const target = resolveCrossSpaceTarget(owner, fk.referencedSchema, fk.referencedTable);
+          if (target === undefined) {
+            throw new Error(
+              `contract infer: described contract space "${owner.spaceId}" owns storage ` +
+                `coordinate "${fk.referencedSchema}.${fk.referencedTable}" but declares no ` +
+                'domain model mapped to it. A pack that describes a table must also declare the ' +
+                'domain model it maps to; this pack is malformed.',
+            );
+          }
+
+          if (!crossSpaceFieldNamesByTable.has(fk.referencedTable)) {
+            crossSpaceFieldNamesByTable.set(fk.referencedTable, target.fieldNamesByColumn);
+          }
+
+          const fieldName = deriveRelationFieldName(fk.columns, fk.referencedTable);
+          const optional = fk.columns.some(
+            (columnName) => table.columns[columnName]?.nullable ?? false,
+          );
+          const relationField: RelationField = {
+            ...buildChildRelationField(fieldName, target.modelName, fk, optional),
+            typeNamespaceId: target.namespaceId,
+            typeContractSpaceId: target.spaceId,
+          };
+
+          const existingRelations = extraRelationsByTable.get(tableName);
+          if (existingRelations) {
+            existingRelations.push(relationField);
+          } else {
+            extraRelationsByTable.set(tableName, [relationField]);
+          }
+          continue;
+        }
+      }
+
+      // Not a pack-owned coordinate: keep the foreign key if the referenced
+      // table survived introspection (local), otherwise drop it while keeping
+      // the scalar column (dangling).
+      if (tables[fk.referencedTable] !== undefined) {
+        keptForeignKeys.push(fk);
+      }
+    }
+
+    resultTables[tableName] =
+      keptForeignKeys.length === table.foreignKeys.length
+        ? table
+        : { ...table, foreignKeys: keptForeignKeys };
+  }
+
+  return { tables: resultTables, extraRelationsByTable, crossSpaceFieldNamesByTable };
+}
+
 /**
  * Infers a PSL AST (for `printPsl`) from an introspected Postgres schema tree.
  *
@@ -89,9 +274,23 @@ type TopLevelNameResult = {
  * introspects a single live namespace) are gathered into the model set and
  * emitted as one `UNSPECIFIED_PSL_NAMESPACE_ID` bucket. Top-level entities
  * (policies/roles → PSL extension blocks) are a later slice.
+ *
+ * `describedContracts` — the stack's extension packs' already-assembled
+ * contracts, each paired with its space id — is consulted while gathering
+ * tables: a table whose coordinate `(schemaName, 'table', tableName)` one of
+ * those contracts already declares is omitted, before the duplicate-name
+ * check below and before relation inference, so it cannot spuriously
+ * collide with an app table and never contributes a bare relation field. A
+ * surviving table's foreign key into an omitted, pack-owned table is not
+ * dropped: {@link resolveForeignKeys} rewrites it into a relation qualified
+ * with the pack's space id (`<spaceId>:<namespaceId>.<Model>`) instead.
  */
-export function inferPostgresPslContract(tree: PostgresDatabaseSchemaNode): PslDocumentAst {
+export function inferPostgresPslContract(
+  tree: PostgresDatabaseSchemaNode,
+  describedContracts?: readonly SqlDescribedContractSpace[],
+): PslDocumentAst {
   const namespaces = Object.values(tree.namespaces);
+  const owners = describedContractOwners(describedContracts ?? []);
 
   // Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by
   // `contract infer`; throw an actionable diagnostic naming the type(s). Enum
@@ -118,6 +317,17 @@ export function inferPostgresPslContract(tree: PostgresDatabaseSchemaNode): PslD
   const tables: Record<string, SqlTableIR> = {};
   for (const namespace of namespaces) {
     for (const [tableName, table] of Object.entries(namespace.tables)) {
+      if (
+        owners.has(
+          coordinateKey({
+            namespaceId: namespace.schemaName,
+            entityKind: 'table',
+            entityName: tableName,
+          }),
+        )
+      ) {
+        continue;
+      }
       if (tables[tableName] !== undefined) {
         throw new Error(
           `contract infer: duplicate table name "${tableName}" across schemas is not yet supported ` +
@@ -128,7 +338,13 @@ export function inferPostgresPslContract(tree: PostgresDatabaseSchemaNode): PslD
       tables[tableName] = table;
     }
   }
-  const schemaIR: SqlSchemaIR = { tables };
+
+  const {
+    tables: resolvedTables,
+    extraRelationsByTable,
+    crossSpaceFieldNamesByTable,
+  } = resolveForeignKeys(tables, owners);
+  const schemaIR: SqlSchemaIR = { tables: resolvedTables };
 
   const options: PslPrinterOptions = {
     typeMap: createPostgresTypeMap(new Set()),
@@ -136,11 +352,22 @@ export function inferPostgresPslContract(tree: PostgresDatabaseSchemaNode): PslD
     parseRawDefault,
   };
 
-  return buildPslDocumentAst(schemaIR, options);
+  return buildPslDocumentAst(schemaIR, options, {
+    extraRelationsByTable,
+    crossSpaceFieldNamesByTable,
+  });
 }
 
-function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions): PslDocumentAst {
+function buildPslDocumentAst(
+  schemaIR: SqlSchemaIR,
+  options: PslPrinterOptions,
+  foreignKeyExtras: Pick<
+    ForeignKeyResolution,
+    'extraRelationsByTable' | 'crossSpaceFieldNamesByTable'
+  >,
+): PslDocumentAst {
   const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
+  const { extraRelationsByTable, crossSpaceFieldNamesByTable } = foreignKeyExtras;
 
   const modelNames = buildTopLevelNameMap(
     Object.keys(schemaIR.tables),
@@ -154,7 +381,14 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
   );
   const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
 
-  const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
+  // Cross-space entries are seeded first so a real local table of the same
+  // bare name (an existing single-namespace-flat-bucket limitation, not new
+  // here) always wins the merge, matching `resolveForeignKeys`'s own
+  // precedence: a surviving local table is never treated as cross-space.
+  const fieldNamesByTable = new Map([
+    ...crossSpaceFieldNamesByTable,
+    ...buildFieldNamesByTable(schemaIR.tables),
+  ]);
   const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
   const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, new Map(), reservedNamedTypeNames);
 
@@ -169,7 +403,10 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
         namedTypes,
         defaultMapping,
         rawDefaultParser,
-        relationsByTable.get(table.name) ?? [],
+        [
+          ...(relationsByTable.get(table.name) ?? []),
+          ...(extraRelationsByTable.get(table.name) ?? []),
+        ],
       ),
     );
   }
@@ -452,6 +689,8 @@ function buildRelationField(
     kind: 'field',
     name: fieldName,
     typeName: rel.typeName,
+    ...ifDefined('typeNamespaceId', rel.typeNamespaceId),
+    ...ifDefined('typeContractSpaceId', rel.typeContractSpaceId),
     optional: rel.optional,
     list: rel.list,
     attributes: attrs,

package/src/exports/control.ts

@@ -58,9 +58,9 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
     ...postgresTargetDescriptorMeta,
     contractSerializer: new PostgresContractSerializer(),
     schemaVerifier: new PostgresSchemaVerifier(),
-    inferPslContract(schema) {
+    inferPslContract(schema, describedContracts) {
       PostgresDatabaseSchemaNode.assert(schema);
-      return inferPostgresPslContract(schema);
+      return inferPostgresPslContract(schema, describedContracts);
     },
     diffDatabaseSchema(input) {
       return diffPostgresDatabaseSchema({

package/dist/authoring-BX1WHIdN.mjs

@@ -1,220 +0,0 @@
-import { c as PostgresRlsPolicySchema, d as PostgresRlsPolicy, l as PostgresRoleSchema, u as PostgresRole } from "./postgres-schema-BLIHBEfX.mjs";
-import { n as normalizePredicate, t as computeContentHash } from "./canonicalize-Bn3BM1Cn.mjs";
-import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
-//#region src/core/authoring.ts
-const postgresAuthoringTypes = {};
-function readRefParam(block, key) {
-	const param = block.parameters[key];
-	return param?.kind === "ref" ? param.identifier : void 0;
-}
-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] : []);
-}
-function unwrapQuotedString(raw) {
-	if (raw.startsWith("\"") && raw.endsWith("\"") && raw.length >= 2) return raw.slice(1, -1).replace(/\\"/g, "\"");
-	return raw;
-}
-function lowerRlsPolicyFromBlock(block, _ctx) {
-	const prefix = block.name;
-	const targetModelName = readRefParam(block, "target") ?? "";
-	const tableName = targetModelName.charAt(0).toLowerCase() + targetModelName.slice(1);
-	const roles = [...readListRefParams(block, "roles")].sort();
-	const using = unwrapQuotedString(readValueParam(block, "using") ?? "");
-	return new PostgresRlsPolicy({
-		name: `${prefix}_${computeContentHash({
-			using: normalizePredicate(using),
-			roles,
-			operation: "select",
-			permissive: true
-		})}`,
-		prefix,
-		tableName,
-		namespaceId: block.namespaceId,
-		operation: "select",
-		roles,
-		using,
-		permissive: true
-	});
-}
-const postgresAuthoringEntityTypes = {
-	role: {
-		kind: "entity",
-		discriminator: "role",
-		validatorSchema: PostgresRoleSchema,
-		output: { factory: (input) => new PostgresRole(input) }
-	},
-	policy: {
-		kind: "entity",
-		discriminator: "policy",
-		validatorSchema: PostgresRlsPolicySchema,
-		output: { factory: lowerRlsPolicyFromBlock }
-	}
-};
-/**
-* 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.
-*/
-/**
-* PSL block descriptor for `policy_select`.
-*
-* The parser learns the block shape from this descriptor; lowering from
-* `PslExtensionBlock` to `PostgresRlsPolicy` is wired in the PSL
-* interpreter (a later dispatch). The `discriminator` matches
-* `PostgresRlsPolicy.kind` so the parsed block node carries the same
-* discriminant as the IR class it will lower to.
-*
-* 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 postgresAuthoringPslBlockDescriptors = { policy_select: {
-	kind: "pslBlock",
-	keyword: "policy_select",
-	discriminator: "policy",
-	name: { required: true },
-	parameters: {
-		target: {
-			kind: "ref",
-			refKind: "model",
-			scope: "same-namespace",
-			required: true
-		},
-		roles: {
-			kind: "list",
-			of: {
-				kind: "ref",
-				refKind: "role",
-				scope: "cross-space"
-			}
-		},
-		using: {
-			kind: "value",
-			codecId: "pg/text@1",
-			required: true
-		}
-	}
-} };
-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
-			}
-		}
-	}
-};
-//#endregion
-export { postgresAuthoringTypes as i, postgresAuthoringFieldPresets as n, postgresAuthoringPslBlockDescriptors as r, postgresAuthoringEntityTypes as t };
-
-//# sourceMappingURL=authoring-BX1WHIdN.mjs.map

package/dist/authoring-BX1WHIdN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring-BX1WHIdN.mjs","names":[],"sources":["../src/core/authoring.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityContext,\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringPslBlockDescriptorNamespace,\n  AuthoringTypeNamespace,\n  PslExtensionBlock,\n} from '@prisma-next/framework-components/authoring';\nimport { PostgresRlsPolicy } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';\nimport { computeContentHash, normalizePredicate } from './rls/canonicalize';\n\nexport const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;\n\nexport interface RlsPolicyExtensionBlock extends PslExtensionBlock {\n  readonly namespaceId: string;\n}\n\nfunction readRefParam(block: PslExtensionBlock, key: string): string | undefined {\n  const param = block.parameters[key];\n  return param?.kind === 'ref' ? param.identifier : undefined;\n}\n\nfunction readValueParam(block: PslExtensionBlock, key: string): string | undefined {\n  const param = block.parameters[key];\n  return param?.kind === 'value' ? param.raw : undefined;\n}\n\nfunction readListRefParams(block: PslExtensionBlock, key: string): string[] {\n  const param = block.parameters[key];\n  if (param?.kind !== 'list') return [];\n  return param.items.flatMap((item) => (item.kind === 'ref' ? [item.identifier] : []));\n}\n\nfunction unwrapQuotedString(raw: string): string {\n  if (raw.startsWith('\"') && raw.endsWith('\"') && raw.length >= 2) {\n    return raw.slice(1, -1).replace(/\\\\\"/g, '\"');\n  }\n  return raw;\n}\n\nfunction lowerRlsPolicyFromBlock(\n  block: RlsPolicyExtensionBlock,\n  _ctx: AuthoringEntityContext,\n): PostgresRlsPolicy {\n  const prefix = block.name;\n  const targetModelName = readRefParam(block, 'target') ?? '';\n  const tableName = targetModelName.charAt(0).toLowerCase() + targetModelName.slice(1);\n  const roles = [...readListRefParams(block, 'roles')].sort();\n  const using = unwrapQuotedString(readValueParam(block, 'using') ?? '');\n\n  const wireHash = computeContentHash({\n    using: normalizePredicate(using),\n    roles,\n    operation: 'select',\n    permissive: true,\n  });\n  const wireName = `${prefix}_${wireHash}`;\n\n  return new PostgresRlsPolicy({\n    name: wireName,\n    prefix,\n    tableName,\n    namespaceId: block.namespaceId,\n    operation: 'select',\n    roles,\n    using,\n    permissive: true,\n  });\n}\n\nexport const postgresAuthoringEntityTypes = {\n  role: {\n    kind: 'entity',\n    discriminator: 'role',\n    validatorSchema: PostgresRoleSchema,\n    output: {\n      factory: (input: PostgresRoleInput): PostgresRole => new PostgresRole(input),\n    },\n  },\n  policy: {\n    kind: 'entity',\n    discriminator: 'policy',\n    validatorSchema: PostgresRlsPolicySchema,\n    output: {\n      factory: lowerRlsPolicyFromBlock,\n    },\n  },\n} as const satisfies AuthoringEntityTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n *\n * The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the\n * native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target\n * portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from\n * the family pack instead.\n */\n/**\n * PSL block descriptor for `policy_select`.\n *\n * The parser learns the block shape from this descriptor; lowering from\n * `PslExtensionBlock` to `PostgresRlsPolicy` is wired in the PSL\n * interpreter (a later dispatch). The `discriminator` matches\n * `PostgresRlsPolicy.kind` so the parsed block node carries the same\n * discriminant as the IR class it will lower to.\n *\n * The `roles` list uses `scope:'cross-space'` because same-namespace\n * role ref resolution requires PSL namespace entries keyed by `refKind`\n * (i.e. `'role'`), which in turn requires the role block discriminator to\n * equal `'role'`. Aligning discriminator with refKind is tracked for\n * slice 4 (cross-space roles). Until then cross-space passes validation\n * unconditionally and the authored role names flow through unchanged.\n */\nexport const postgresAuthoringPslBlockDescriptors = {\n  policy_select: {\n    kind: 'pslBlock',\n    keyword: 'policy_select',\n    discriminator: 'policy',\n    name: { required: true },\n    parameters: {\n      target: { kind: 'ref', refKind: 'model', scope: 'same-namespace', required: true },\n      roles: {\n        kind: 'list',\n        of: { kind: 'ref', refKind: 'role', scope: 'cross-space' },\n      },\n      using: { kind: 'value', codecId: 'pg/text@1', required: true },\n    },\n  },\n} as const satisfies AuthoringPslBlockDescriptorNamespace;\n\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  temporal: /* @__PURE__ */ temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n  uuidNative: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/uuid@1',\n      nativeType: 'uuid',\n    },\n  },\n  id: {\n    uuidv4Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv4',\n          },\n        },\n        id: true,\n      },\n    },\n    uuidv7Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv7',\n          },\n        },\n        id: true,\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n"],"mappings":"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"}

package/dist/codec-ids-BvytN2P8.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-ids-BvytN2P8.mjs","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":["export {\n  SQL_CHAR_CODEC_ID,\n  SQL_FLOAT_CODEC_ID,\n  SQL_INT_CODEC_ID,\n  SQL_TEXT_CODEC_ID,\n  SQL_TIMESTAMP_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/sql-relational-core/ast';\nexport const PG_TEXT_CODEC_ID = 'pg/text@1' as const;\nexport const PG_TEXT_ARRAY_CODEC_ID = 'pg/text-array@1' as const;\nexport const PG_CHAR_CODEC_ID = 'pg/char@1' as const;\nexport const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;\nexport const PG_INT_CODEC_ID = 'pg/int@1' as const;\nexport const PG_INT2_CODEC_ID = 'pg/int2@1' as const;\nexport const PG_INT4_CODEC_ID = 'pg/int4@1' as const;\nexport const PG_INT8_CODEC_ID = 'pg/int8@1' as const;\nexport const PG_FLOAT_CODEC_ID = 'pg/float@1' as const;\nexport const PG_FLOAT4_CODEC_ID = 'pg/float4@1' as const;\nexport const PG_FLOAT8_CODEC_ID = 'pg/float8@1' as const;\nexport const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;\nexport const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;\nexport const PG_BIT_CODEC_ID = 'pg/bit@1' as const;\nexport const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;\nexport const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;\nexport const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;\nexport const PG_TIME_CODEC_ID = 'pg/time@1' as const;\nexport const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;\nexport const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;\nexport const PG_JSON_CODEC_ID = 'pg/json@1' as const;\nexport const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;\nexport const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;\nexport const PG_UUID_CODEC_ID = 'pg/uuid@1' as const;\n"],"mappings":";;AAQA,MAAa,mBAAmB;AAChC,MAAa,yBAAyB;AACtC,MAAa,mBAAmB;AAChC,MAAa,sBAAsB;AACnC,MAAa,kBAAkB;AAC/B,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB;AACjC,MAAa,qBAAqB;AAClC,MAAa,qBAAqB;AAClC,MAAa,sBAAsB;AACnC,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAC/B,MAAa,qBAAqB;AAClC,MAAa,wBAAwB;AACrC,MAAa,0BAA0B;AACvC,MAAa,mBAAmB;AAChC,MAAa,qBAAqB;AAClC,MAAa,uBAAuB;AACpC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB;AACjC,MAAa,oBAAoB;AACjC,MAAa,mBAAmB"}

package/dist/codec-ids-CnXu9Qy3.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-ids-CnXu9Qy3.d.mts","names":[],"sources":["../src/core/codec-ids.ts"],"mappings":";;;cAQa,gBAAA;AAAA,cACA,sBAAA;AAAA,cACA,gBAAA;AAAA,cACA,mBAAA;AAAA,cACA,eAAA;AAAA,cACA,gBAAA;AAAA,cACA,gBAAA;AAAA,cACA,gBAAA;AAAA,cACA,iBAAA;AAAA,cACA,kBAAA;AAAA,cACA,kBAAA;AAAA,cACA,mBAAA;AAAA,cACA,gBAAA;AAAA,cACA,eAAA;AAAA,cACA,kBAAA;AAAA,cACA,qBAAA;AAAA,cACA,uBAAA;AAAA,cACA,gBAAA;AAAA,cACA,kBAAA;AAAA,cACA,oBAAA;AAAA,cACA,gBAAA;AAAA,cACA,iBAAA;AAAA,cACA,iBAAA;AAAA,cACA,gBAAA"}