@prisma-next/target-postgres 0.14.0-dev.53 → 0.14.0-dev.55

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

@@ -2,6 +2,7 @@ import type { ColumnDefault } from '@prisma-next/contract/types';
 import type { SqlDescribedContractSpace } from '@prisma-next/family-sql/control';
 import type {
   DefaultMappingOptions,
+  EnumInfo,
   PslNativeTypeAttribute,
   PslPrinterOptions,
   PslTypeMap,
@@ -13,21 +14,30 @@ import {
   inferRelations,
   mapDefault,
   parseRawDefault,
+  toEnumMemberName,
+  toEnumName,
   toFieldName,
   toModelName,
   toNamedTypeName,
 } from '@prisma-next/family-sql/psl-infer';
-import { coordinateKey, elementCoordinates } from '@prisma-next/framework-components/ir';
+import {
+  coordinateKey,
+  elementCoordinates,
+  isPlainRecord,
+} from '@prisma-next/framework-components/ir';
 import type {
   PslAttribute,
   PslAttributeArgument,
   PslDocumentAst,
+  PslExtensionBlock,
+  PslExtensionBlockParamValue,
   PslField,
   PslFieldAttribute,
   PslModel,
   PslModelAttribute,
   PslNamedTypeDeclaration,
   PslSpan,
+  PslTypeConstructorCall,
   PslTypesBlock,
 } from '@prisma-next/framework-components/psl-ast';
 import {
@@ -40,6 +50,7 @@ import type { SqlColumnIR, SqlForeignKeyIR } from '@prisma-next/sql-schema-ir/ty
 import { SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { PostgresNativeEnum } from '../postgres-native-enum';
 import type { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { createPostgresDefaultMapping } from './postgres-default-mapping';
 import { createPostgresTypeMap } from './postgres-type-map';
@@ -287,20 +298,52 @@ export function inferPostgresPslContract(
 ): 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
-  // names live on each namespace node's `nativeEnumTypeNames`.
-  const enumTypeNames = [...new Set(namespaces.flatMap((ns) => ns.nativeEnumTypeNames))];
-  if (enumTypeNames.length > 0) {
-    const names = enumTypeNames.join(', ');
-    throw new Error(
-      `contract infer: the database contains native Postgres enum type(s): ${names}. ` +
-        'Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by contract infer. ' +
-        'Drop the native type and replace each column with a text column carrying a CHECK constraint, ' +
-        `then re-run contract infer. The domain enum (enum Name { @@type("pg/text@1") … }) authoring ` +
-        'surface generates the required check automatically.',
-    );
+  const enumOwners = describedNativeEnumOwnersByTypeName(describedContracts ?? []);
+
+  // Native enum adoption: each namespace's introspected `{ typeName, values }`
+  // entries become `native_enum` blocks + `pg.enum(<Name>)` columns, minus the
+  // types a described pack contract already declares (matched by TYPE NAME —
+  // see describedNativeEnumOwnersByTypeName). Transitional grade gap: an
+  // inferred block carries no explicit `control` and inherits the contract's
+  // `defaultControl`; under `defaultControl: 'managed'` the planner does not
+  // yet enforce the native enum lifecycle (CREATE TYPE / DROP TYPE / ADD
+  // VALUE) — that lands with Phase 2 of projects/native-postgres-enums/spec.md,
+  // making the grade true retroactively with no contract change.
+  const enumDefinitions = new Map<string, readonly string[]>();
+  const packOwnedEnumTypesByNamespace = new Map<string, Map<string, string>>();
+  const enumNamespaceNames = new Set<string>();
+  for (const namespace of namespaces) {
+    const definitionsForNamespace = new Set(namespace.nativeEnums.map((e) => e.typeName));
+    for (const typeName of namespace.nativeEnumTypeNames) {
+      if (!definitionsForNamespace.has(typeName)) {
+        throw new Error(
+          `contract infer: introspection reported native enum type "${typeName}" in schema ` +
+            `"${namespace.schemaName}" without member values — the introspected tree's ` +
+            '`nativeEnumTypeNames` and `nativeEnums` are out of sync (internal invariant).',
+        );
+      }
+    }
+    for (const { typeName, values } of namespace.nativeEnums) {
+      const owner = enumOwners.get(
+        coordinateKey({
+          namespaceId: namespace.schemaName,
+          entityKind: 'native_enum',
+          entityName: typeName,
+        }),
+      );
+      if (owner !== undefined) {
+        const owned = packOwnedEnumTypesByNamespace.get(namespace.schemaName) ?? new Map();
+        // Columns reference the type either bare or schema-qualified —
+        // `format_type` qualifies a type outside the connection's
+        // search_path — so both spellings are owned.
+        owned.set(typeName, owner.spaceId);
+        owned.set(`${namespace.schemaName}.${typeName}`, owner.spaceId);
+        packOwnedEnumTypesByNamespace.set(namespace.schemaName, owned);
+        continue;
+      }
+      enumDefinitions.set(typeName, values);
+      enumNamespaceNames.add(namespace.schemaName);
+    }
   }
 
   // Stopgap (TML-2958): flatten the schema-IR *tree* into the single `{ tables }`
@@ -311,7 +354,9 @@ export function inferPostgresPslContract(
   // single introspected namespace, and a same-named table in two schemas has no
   // unambiguous single-bucket model, so we throw rather than silently drop one.
   const tables: Record<string, SqlTableIR> = {};
+  const tableNamespaceNames = new Set<string>();
   for (const namespace of namespaces) {
+    const ownedEnumTypes = packOwnedEnumTypesByNamespace.get(namespace.schemaName);
     for (const [tableName, table] of Object.entries(namespace.tables)) {
       if (
         owners.has(
@@ -331,9 +376,45 @@ export function inferPostgresPslContract(
             'output is a later slice).',
         );
       }
+      if (ownedEnumTypes !== undefined) {
+        for (const column of Object.values(table.columns)) {
+          const owningSpaceId = ownedEnumTypes.get(column.nativeType);
+          if (owningSpaceId !== undefined) {
+            throw new Error(
+              `contract infer: column "${tableName}"."${column.name}" is typed by native enum ` +
+                `type "${column.nativeType}", which extension pack space "${owningSpaceId}" ` +
+                'already describes. A cross-space enum-typed column has no authorable PSL form ' +
+                "yet; describe the table in that pack's contract or retype the column before " +
+                're-running contract infer.',
+            );
+          }
+        }
+      }
       tables[tableName] = new SqlTableIR(table);
+      tableNamespaceNames.add(namespace.schemaName);
+    }
+  }
+
+  // Namespace wrap (pinned during shaping): a `native_enum` block only lowers
+  // inside an explicit `namespace { … }` block — the interpreter skips
+  // extension entities in the unspecified top-level bucket — so enum-bearing
+  // output wraps everything in the introspected schema's name. Enum-free
+  // output stays flat and byte-identical to the prior inference.
+  let wrapNamespaceName: string | undefined;
+  if (enumDefinitions.size > 0) {
+    const contentNamespaces = new Set([...enumNamespaceNames, ...tableNamespaceNames]);
+    if (contentNamespaces.size > 1) {
+      throw new Error(
+        'contract infer: native enum adoption with content across multiple schemas is not yet ' +
+          'supported (single-namespace PSL inference emits one `namespace { … }` block; ' +
+          `multi-namespace output is a later slice). Schemas: ${[...contentNamespaces]
+            .sort()
+            .join(', ')}.`,
+      );
     }
+    wrapNamespaceName = [...contentNamespaces][0];
   }
+
   const {
     tables: resolvedTables,
     extraRelationsByTable,
@@ -341,25 +422,87 @@ export function inferPostgresPslContract(
   } = resolveForeignKeys(tables, owners);
   const schemaIR = new SqlSchemaIR({ tables: resolvedTables });
 
+  // Live introspection reports an enum column's nativeType schema-qualified
+  // whenever the type sits outside the connection's search_path (`format_type`
+  // semantics; e.g. `auth.aal_level`), while `pg_type.typname` — the
+  // definitions key — is always bare. Register the qualified spelling as an
+  // alias so those columns resolve; block emission stays keyed on the bare
+  // name (one block per type).
+  const enumTypeNames = new Set(enumDefinitions.keys());
+  if (wrapNamespaceName !== undefined) {
+    for (const typeName of enumDefinitions.keys()) {
+      enumTypeNames.add(`${wrapNamespaceName}.${typeName}`);
+    }
+  }
+  const enumInfo: EnumInfo = {
+    typeNames: enumTypeNames,
+    definitions: enumDefinitions,
+  };
   const options: PslPrinterOptions = {
-    typeMap: createPostgresTypeMap(new Set()),
+    typeMap: createPostgresTypeMap(enumInfo.typeNames),
     defaultMapping: createPostgresDefaultMapping(),
     parseRawDefault,
+    ...(enumDefinitions.size > 0 ? { enumInfo } : {}),
   };
 
-  return buildPslDocumentAst(schemaIR, options, {
-    extraRelationsByTable,
-    crossSpaceFieldNamesByTable,
-  });
+  return buildPslDocumentAst(
+    schemaIR,
+    options,
+    {
+      extraRelationsByTable,
+      crossSpaceFieldNamesByTable,
+    },
+    wrapNamespaceName,
+  );
 }
 
-function buildPslDocumentAst(
+/**
+ * Native-enum ownership index for pack subtraction, keyed by TYPE NAME
+ * coordinate. A pack contract keys `entries.native_enum` by HANDLE name
+ * (`AalLevel`) while introspection sees the Postgres type name (`aal_level`);
+ * the entity's `typeName` field carries the mapping, so this walk indexes by
+ * it rather than reusing {@link describedContractOwners}' entries-key
+ * coordinates.
+ *
+ * Reads `entries.native_enum` directly: the kind map is carried
+ * non-enumerable on `PostgresSchema.entries`, so the generic
+ * `elementCoordinates` walk never yields it. Serialized pack contracts do
+ * not carry `native_enum` entries at all (`PostgresContractSerializer`
+ * strips them; only the derived `valueSet` survives), so this subtraction
+ * currently matches in-memory described contracts only.
+ */
+function describedNativeEnumOwnersByTypeName(
+  describedContracts: readonly SqlDescribedContractSpace[],
+): ReadonlyMap<string, SqlDescribedContractSpace> {
+  const owners = new Map<string, SqlDescribedContractSpace>();
+  for (const entry of describedContracts) {
+    for (const [namespaceId, ns] of Object.entries(entry.contract.storage.namespaces)) {
+      const kindMap = ns.entries['native_enum'];
+      if (!isPlainRecord(kindMap)) continue;
+      for (const entity of Object.values(kindMap)) {
+        if (!PostgresNativeEnum.is(entity)) continue;
+        owners.set(
+          coordinateKey({
+            namespaceId,
+            entityKind: 'native_enum',
+            entityName: entity.typeName,
+          }),
+          entry,
+        );
+      }
+    }
+  }
+  return owners;
+}
+
+export function buildPslDocumentAst(
   schemaIR: SqlSchemaIR,
   options: PslPrinterOptions,
   foreignKeyExtras: Pick<
     ForeignKeyResolution,
     'extraRelationsByTable' | 'crossSpaceFieldNamesByTable'
   >,
+  namespaceName?: string,
 ): PslDocumentAst {
   const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
   const { extraRelationsByTable, crossSpaceFieldNamesByTable } = foreignKeyExtras;
@@ -374,7 +517,23 @@ function buildPslDocumentAst(
   const modelNameMap = new Map(
     [...modelNames].map(([tableName, result]) => [tableName, result.name]),
   );
-  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
+
+  const { enumNameMap: bareEnumNameMap, enumBlocks } = buildNativeEnumBlocks(
+    options.enumInfo?.definitions ?? new Map(),
+    modelNames,
+  );
+
+  // Columns reference an enum type bare or schema-qualified (`format_type`
+  // qualifies types outside the search_path); alias the qualified spelling
+  // onto the same PSL name. Blocks stay keyed on the bare name.
+  const enumNameMap = new Map(bareEnumNameMap);
+  if (namespaceName !== undefined) {
+    for (const [typeName, pslName] of bareEnumNameMap) {
+      enumNameMap.set(`${namespaceName}.${typeName}`, pslName);
+    }
+  }
+
+  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNameMap);
 
   // 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
@@ -385,7 +544,7 @@ function buildPslDocumentAst(
     ...buildFieldNamesByTable(schemaIR.tables),
   ]);
   const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, new Map(), reservedNamedTypeNames);
+  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
 
   const models: PslModel[] = [];
   for (const table of Object.values(schemaIR.tables)) {
@@ -393,7 +552,7 @@ function buildPslDocumentAst(
       buildModel(
         table,
         typeMap,
-        new Map(),
+        enumNameMap,
         fieldNamesByTable,
         namedTypes,
         defaultMapping,
@@ -421,19 +580,20 @@ function buildPslDocumentAst(
       : undefined;
 
   // Inferred PSL nodes will eventually be routed into per-namespace buckets
-  // matching the source storage; for now we synthesise a single
-  // `__unspecified__` bucket so round-tripping the AST through the framework
-  // printer (which emits the synthesised bucket at top level with no
-  // `namespace { … }` wrapper) preserves the existing introspection output
-  // verbatim.
+  // matching the source storage; for now everything lands in a single bucket.
+  // Without a `namespaceName` that bucket is the synthesised `__unspecified__`
+  // one, which the framework printer emits at top level with no
+  // `namespace { … }` wrapper — preserving the existing flat introspection
+  // output verbatim. With a `namespaceName` (enum-bearing output) the bucket
+  // is a real named namespace, printed as an explicit block.
   const ast: PslDocumentAst = {
     kind: 'document',
     sourceId: '<sql-schema-ir>',
     namespaces: [
       makePslNamespace({
         kind: 'namespace',
-        name: UNSPECIFIED_PSL_NAMESPACE_ID,
-        entries: makePslNamespaceEntries(sortedModels, [], []),
+        name: namespaceName ?? UNSPECIFIED_PSL_NAMESPACE_ID,
+        entries: makePslNamespaceEntries(sortedModels, [], enumBlocks),
         span: SYNTHETIC_SPAN,
       }),
     ],
@@ -444,6 +604,87 @@ function buildPslDocumentAst(
   return ast;
 }
 
+type NativeEnumBlockResult = {
+  /** Native enum type name → PSL block name, for `pg.enum(<Name>)` field refs. */
+  readonly enumNameMap: ReadonlyMap<string, string>;
+  readonly enumBlocks: readonly PslExtensionBlock[];
+};
+
+/**
+ * Builds one `native_enum` extension-block AST node per introspected enum
+ * definition. Block names go through the shared top-level transform
+ * (`toEnumName`, intra-enum collisions throw like model collisions) and are
+ * then reserved against the model names — an enum whose PSL name a model
+ * already claims gets a numeric suffix, with `@@map` carrying the real type
+ * name. Members print as explicit `member = "value"` pairs: the member name
+ * is the sanitized value (deduplicated within the block), the JSON-encoded
+ * value carries the truth verbatim.
+ */
+function buildNativeEnumBlocks(
+  definitions: ReadonlyMap<string, readonly string[]>,
+  modelNames: ReadonlyMap<string, TopLevelNameResult>,
+): NativeEnumBlockResult {
+  const enumNames = buildTopLevelNameMap(
+    [...definitions.keys()].sort(),
+    toEnumName,
+    'enum',
+    'enum type',
+  );
+
+  const usedTopLevelNames = new Set<string>(PSL_SCALAR_TYPE_NAMES);
+  for (const result of modelNames.values()) {
+    usedTopLevelNames.add(result.name);
+  }
+
+  const enumNameMap = new Map<string, string>();
+  const enumBlocks: PslExtensionBlock[] = [];
+  for (const [typeName, result] of enumNames) {
+    const name = createUniqueFieldName(result.name, usedTopLevelNames);
+    usedTopLevelNames.add(name);
+    enumNameMap.set(typeName, name);
+    enumBlocks.push(buildNativeEnumBlock(name, typeName, definitions.get(typeName) ?? []));
+  }
+
+  return { enumNameMap, enumBlocks };
+}
+
+function buildNativeEnumBlock(
+  name: string,
+  typeName: string,
+  values: readonly string[],
+): PslExtensionBlock {
+  const usedMemberNames = new Set<string>();
+  const parameters: Record<string, PslExtensionBlockParamValue> = {};
+  for (const value of values) {
+    const memberName = createUniqueFieldName(toEnumMemberName(value), usedMemberNames);
+    usedMemberNames.add(memberName);
+    parameters[memberName] = { kind: 'value', raw: JSON.stringify(value), span: SYNTHETIC_SPAN };
+  }
+
+  return {
+    kind: 'native_enum',
+    name,
+    parameters,
+    blockAttributes:
+      name === typeName
+        ? []
+        : [
+            {
+              name: 'map',
+              args: [
+                {
+                  kind: 'positional',
+                  value: `"${escapePslString(typeName)}"`,
+                  span: SYNTHETIC_SPAN,
+                },
+              ],
+              span: SYNTHETIC_SPAN,
+            },
+          ],
+    span: SYNTHETIC_SPAN,
+  };
+}
+
 function buildModel(
   table: SqlTableIR,
   typeMap: PslTypeMap,
@@ -582,10 +823,21 @@ function buildScalarField(
     };
   }
 
+  // An enum-typed column emits the `pg.enum(<Name>)` type-constructor call —
+  // the Phase-1 authoring form a `native_enum` ref field takes — not a bare
+  // name substitution. The printer renders `typeConstructor` when present and
+  // composes `?`/`[]` exactly like any other field type.
   let typeName = resolution.pslType;
+  let typeConstructor: PslTypeConstructorCall | undefined;
   const enumPslName = enumNameMap.get(column.nativeType);
   if (enumPslName) {
     typeName = enumPslName;
+    typeConstructor = {
+      kind: 'typeConstructor',
+      path: ['pg', 'enum'],
+      args: [positionalArg(enumPslName)],
+      span: SYNTHETIC_SPAN,
+    };
   }
   if (resolution.nativeTypeAttribute && !enumPslName) {
     typeName = resolveNamedTypeName(namedTypes, resolution);
@@ -624,6 +876,7 @@ function buildScalarField(
     kind: 'field',
     name: fieldName,
     typeName,
+    ...ifDefined('typeConstructor', typeConstructor),
     optional: column.nullable,
     list: column.many === true,
     attributes,
@@ -894,12 +1147,16 @@ function buildTopLevelNameMap(
 
 function createReservedNamedTypeNames(
   modelNames: ReadonlyMap<string, TopLevelNameResult>,
+  enumNameMap: ReadonlyMap<string, string>,
 ): Set<string> {
   const reservedNames = new Set<string>(PSL_SCALAR_TYPE_NAMES);
 
   for (const result of modelNames.values()) {
     reservedNames.add(result.name);
   }
+  for (const enumPslName of enumNameMap.values()) {
+    reservedNames.add(enumPslName);
+  }
 
   return reservedNames;
 }

package/src/core/psl-infer/postgres-type-map.ts

@@ -1,5 +1,4 @@
 import type {
-  EnumInfo,
   PslNativeTypeAttribute,
   PslTypeMap,
   PslTypeResolution,
@@ -127,31 +126,3 @@ export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslT
     },
   };
 }
-
-export function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {
-  const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;
-  const nativeEnumTypeNames = pgAnnotations?.['nativeEnumTypeNames'];
-
-  const typeNames = new Set<string>();
-  const definitions = new Map<string, readonly string[]>();
-
-  if (Array.isArray(nativeEnumTypeNames)) {
-    for (const name of nativeEnumTypeNames) {
-      if (typeof name === 'string') {
-        typeNames.add(name);
-      }
-    }
-  }
-
-  return { typeNames, definitions };
-}
-
-export function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string> {
-  return extractEnumInfo(annotations).typeNames;
-}
-
-export function extractEnumDefinitions(
-  annotations?: Record<string, unknown>,
-): ReadonlyMap<string, readonly string[]> {
-  return extractEnumInfo(annotations).definitions;
-}

package/src/core/schema-ir/postgres-namespace-schema-node.ts

@@ -4,10 +4,17 @@ import { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import type { PostgresTableSchemaNode } from './postgres-table-schema-node';
 import { PostgresSchemaNodeKind } from './schema-node-kinds';
 
+/** One introspected native Postgres enum type, in `pg_enum.enumsortorder` (declaration) order. */
+export interface PostgresNativeEnumIntrospection {
+  readonly typeName: string;
+  readonly values: readonly string[];
+}
+
 export interface PostgresNamespaceSchemaNodeInput {
   readonly schemaName: string;
   readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
   readonly nativeEnumTypeNames: readonly string[];
+  readonly nativeEnums?: readonly PostgresNativeEnumIntrospection[];
 }
 
 /**
@@ -22,6 +29,12 @@ export interface PostgresNamespaceSchemaNodeInput {
  * equal iff their ids (schema names) match. `children()` returns the table
  * nodes. Per-schema metadata is carried on the typed `nativeEnumTypeNames`
  * field, not an annotations bag.
+ *
+ * `nativeEnums` carries the same enum types with their ordered member
+ * values (`{ typeName, values }`), for consumers that need the values
+ * (PSL inference, the printer). `nativeEnumTypeNames` stays a plain name
+ * list read independently by existing consumers (codec `planTypeOperations`
+ * hooks, the infer throw) so none of them need the values to keep working.
  */
 export class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {
   override readonly nodeKind = PostgresSchemaNodeKind.namespace;
@@ -29,12 +42,18 @@ export class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements Diff
   readonly schemaName: string;
   readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
   readonly nativeEnumTypeNames: readonly string[];
+  readonly nativeEnums: readonly PostgresNativeEnumIntrospection[];
 
   constructor(input: PostgresNamespaceSchemaNodeInput) {
     super();
     this.schemaName = input.schemaName;
     this.tables = Object.freeze({ ...input.tables });
     this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
+    this.nativeEnums = Object.freeze(
+      (input.nativeEnums ?? []).map((entry) =>
+        Object.freeze({ typeName: entry.typeName, values: Object.freeze([...entry.values]) }),
+      ),
+    );
     freezeNode(this);
   }
 

package/src/exports/types.ts

@@ -19,6 +19,7 @@ export {
 export {
   PostgresNamespaceSchemaNode,
   type PostgresNamespaceSchemaNodeInput,
+  type PostgresNativeEnumIntrospection,
 } from '../core/schema-ir/postgres-namespace-schema-node';
 export {
   PostgresPolicySchemaNode,

package/dist/authoring-ohGMgi8g.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring-ohGMgi8g.mjs","names":[],"sources":["../src/core/authoring.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityContext,\n  AuthoringEntityTypeFactoryOutput,\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringPslBlockDescriptorNamespace,\n  AuthoringTypeNamespace,\n  PslExtensionBlock,\n} from '@prisma-next/framework-components/authoring';\nimport type { SqlValueSetDerivingEntityTypeOutput } from '@prisma-next/sql-contract/value-set-derivation-hook';\nimport { PG_ENUM_CODEC_ID } from './codec-ids';\nimport { PostgresNativeEnum } from './postgres-native-enum';\nimport { PostgresRlsPolicy } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport {\n  PostgresNativeEnumSchema,\n  PostgresRlsPolicySchema,\n  PostgresRoleSchema,\n} from './postgres-validators';\nimport { computeContentHash, normalizePredicate } from './rls/canonicalize';\n\n/**\n * `pg.enum(<ref>)` registers as an ordinary type constructor whose sole\n * positional argument names a `native_enum` entity instead of carrying a\n * literal value. The interpreter resolves the ref to the `native_enum`\n * entity generically (driven by `entityRefArg`); the `pg/enum@1` codec\n * descriptor's `columnFromEntity` hook (see `codecs.ts`) converts that\n * entity into the column's `typeParams` and native type.\n */\nexport const postgresAuthoringTypes = {\n  pg: {\n    enum: {\n      kind: 'typeConstructor',\n      entityRefArg: { index: 0, entityKind: 'native_enum' },\n      output: {\n        codecId: PG_ENUM_CODEC_ID,\n      },\n    },\n  },\n} 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\n/**\n * Lowers a `native_enum { memberName = \"value\" … @@map(\"type_name\") }` block\n * into a {@link PostgresNativeEnum}. Members must be authored as explicit\n * `key = \"value\"` pairs — a bare (value-less) member is a diagnostic, not\n * accepted (authoring-design.md §2.1). The parsed `memberName` is only used\n * to duplicate-check and report diagnostics; the lowered entity carries just\n * the member values (a native enum is value-only — the member \"name\" isn't\n * a separate authoring concept from the value). `typeName` comes from\n * `@@map` or defaults to the block name verbatim.\n */\nfunction lowerNativeEnumFromBlock(\n  block: PslExtensionBlock,\n  ctx: AuthoringEntityContext,\n): PostgresNativeEnum | undefined {\n  const sourceId = ctx.sourceId ?? 'unknown';\n  const diagnostics = ctx.diagnostics;\n\n  const mapAttr = block.blockAttributes.find((a) => a.name === 'map');\n  let typeName = block.name;\n  if (mapAttr) {\n    const rawArg = mapAttr.args[0]?.value;\n    const mapped = rawArg !== undefined ? unwrapQuotedString(rawArg) : undefined;\n    if (mapped === undefined) {\n      diagnostics?.push({\n        code: 'PSL_NATIVE_ENUM_INVALID_MAP',\n        message: `native_enum \"${block.name}\" @@map attribute must have a quoted type-name argument`,\n        sourceId,\n        span: mapAttr.span,\n      });\n      return undefined;\n    }\n    typeName = mapped;\n  }\n\n  let memberError = false;\n  const seenValues = new Set<string>();\n  const members: string[] = [];\n  for (const [memberName, paramValue] of Object.entries(block.parameters)) {\n    if (paramValue.kind === 'bare') {\n      diagnostics?.push({\n        code: 'PSL_NATIVE_ENUM_BARE_MEMBER',\n        message: `native_enum \"${block.name}\" member \"${memberName}\" has no value; members must be authored as \"${memberName} = \\\\\"value\\\\\"\"`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    if (paramValue.kind !== 'value') continue;\n\n    let jsonValue: unknown;\n    try {\n      jsonValue = JSON.parse(paramValue.raw);\n    } catch {\n      diagnostics?.push({\n        code: 'PSL_EXTENSION_INVALID_VALUE',\n        message: `native_enum \"${block.name}\" member \"${memberName}\" value \"${paramValue.raw}\" is not valid JSON`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    if (typeof jsonValue !== 'string') {\n      diagnostics?.push({\n        code: 'PSL_EXTENSION_INVALID_VALUE',\n        message: `native_enum \"${block.name}\" member \"${memberName}\" value must be a string`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    if (seenValues.has(jsonValue)) {\n      diagnostics?.push({\n        code: 'PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE',\n        message: `native_enum \"${block.name}\": duplicate member value \"${jsonValue}\"`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    seenValues.add(jsonValue);\n    members.push(jsonValue);\n  }\n\n  if (memberError) return undefined;\n\n  if (members.length === 0) {\n    diagnostics?.push({\n      code: 'PSL_NATIVE_ENUM_MISSING_MEMBERS',\n      message: `native_enum \"${block.name}\" must have at least one member`,\n      sourceId,\n      span: block.span,\n    });\n    return undefined;\n  }\n\n  // `control` stays unset — the effective grade is resolved at read time via `effectiveControlPolicy`, like `StorageTable`/`StorageColumn`.\n  return new PostgresNativeEnum({ typeName, members });\n}\n\n/**\n * `native_enum`'s entity-type factory output, checked separately from the assembled\n * `postgresAuthoringEntityTypes` map below: `deriveValueSet` is SQL-family surface\n * ({@link SqlValueSetDerivingEntityTypeOutput}), not part of the framework\n * `AuthoringEntityTypeFactoryOutput` shape, so folding it directly into the map's single\n * `satisfies AuthoringEntityTypeNamespace` check would trip an excess-property error. Checking it\n * here against the intersection of both shapes keeps it structurally valid against each without\n * widening the map's own check.\n */\nconst nativeEnumEntityTypeOutput = {\n  factory: lowerNativeEnumFromBlock,\n  deriveValueSet: (entity: PostgresNativeEnum) => ({\n    kind: 'valueSet' as const,\n    values: [...entity.members],\n  }),\n} satisfies AuthoringEntityTypeFactoryOutput<PslExtensionBlock, PostgresNativeEnum | undefined> &\n  SqlValueSetDerivingEntityTypeOutput;\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  native_enum: {\n    kind: 'entity',\n    discriminator: 'native_enum',\n    validatorSchema: PostgresNativeEnumSchema,\n    output: nativeEnumEntityTypeOutput,\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  /**\n   * PSL block descriptor for `native_enum`.\n   *\n   * Reuses the existing variadic-block mechanism (the same shape the SQL\n   * family's `enum` block ships): the body is an open `memberName = \"value\"`\n   * list. `variadicParameters: true` opens the block to arbitrary keys\n   * beyond the declared (empty) `parameters` set — the lowering factory\n   * (`lowerNativeEnumFromBlock`) turns the variadic entries into ordered\n   * members and rejects a bare (value-less) member.\n   */\n  native_enum: {\n    kind: 'pslBlock',\n    keyword: 'native_enum',\n    discriminator: 'native_enum',\n    name: { required: true },\n    parameters: {},\n    variadicParameters: true,\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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T,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAAU;EACR,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAA0B,yCAAyB;EACjD,SAAS;EACT,YAAY;CACd,CAAC;CACD,YAAY;EACV,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,IAAI;EACF,cAAc;GACZ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,mBAAmB,EACjB,UAAU;KACR,MAAM;KACN,IAAI;IACN,EACF;IACA,IAAI;GACN;EACF;EACA,cAAc;GACZ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,mBAAmB,EACjB,UAAU;KACR,MAAM;KACN,IAAI;IACN,EACF;IACA,IAAI;GACN;EACF;CACF;AACF"}