@prisma-next/target-postgres 0.13.0-dev.28 → 0.13.0-dev.29

package/src/core/postgres-contract-serializer.ts

@@ -15,12 +15,9 @@ import {
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
-import { blindCast, castAs } from '@prisma-next/utils/casts';
+import { blindCast } from '@prisma-next/utils/casts';
 import type { JsonObject } from '@prisma-next/utils/json';
-import type { Type } from 'arktype';
 import { postgresAuthoringEntityTypes } from './authoring';
-import type { PostgresEnumType } from './postgres-enum-type';
-import { PostgresEnumTypeSchema } from './postgres-enum-type-schema';
 import { isPostgresSchema, PostgresSchema } from './postgres-schema';
 
 const POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {
@@ -66,44 +63,10 @@ function collectStorageTypesHydrators(
   return registry;
 }
 
-// Pack-contributed validator schemas keyed by entries key: postgres registers
-// 'type' → the inner name→entry map schema. The family base composes these
-// into the single registry alongside SQL core's 'table'/'valueSet' via
-// createSqlEntrySchemaRegistry.
-const POSTGRES_VALIDATOR_REGISTRY: ReadonlyMap<string, Type<unknown>> = new Map<
-  string,
-  Type<unknown>
->([['type', castAs<Type<unknown>>(PostgresEnumTypeSchema)]]);
-
 export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  private readonly enumFactory: SqlEntityHydrationFactory | undefined;
-
   constructor() {
     const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);
-    super(storageTypesHydrators, POSTGRES_VALIDATOR_REGISTRY);
-    this.enumFactory = storageTypesHydrators.get('postgres-enum');
-  }
-
-  protected override hydrateEntriesKind(
-    key: string,
-    innerMap: unknown,
-  ): Record<string, unknown> | undefined {
-    if (key === 'type') {
-      if (innerMap === null || typeof innerMap !== 'object' || Array.isArray(innerMap)) {
-        return {};
-      }
-      return Object.fromEntries(
-        Object.entries(
-          blindCast<Record<string, unknown>, 'checked object, non-null, non-array above'>(innerMap),
-        ).map(([name, entry]) => [
-          name,
-          blindCast<PostgresEnumType, 'postgres-enum factory returns PostgresEnumType'>(
-            this.enumFactory !== undefined ? this.enumFactory(entry) : entry,
-          ),
-        ]),
-      );
-    }
-    return super.hydrateEntriesKind(key, innerMap);
+    super(storageTypesHydrators);
   }
 
   protected override hydrateSqlNamespaceEntry(
@@ -119,34 +82,18 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     >(super.hydrateSqlNamespaceEntry(nsId, raw));
     const { id, entries } = hydrated;
 
-    const typeEntries = blindCast<
-      Record<string, PostgresEnumType> | undefined,
-      'hydrateEntriesKind populates entries[type] with PostgresEnumType instances'
-    >(entries['type']);
-    const valueSetEntries = entries['valueSet'];
-    const hasValueSets = valueSetEntries !== undefined && Object.keys(valueSetEntries).length > 0;
-    const tableEntries = entries['table'] ?? {};
-    const emptyTables = Object.keys(tableEntries).length === 0;
-    const emptyTypes = !typeEntries || Object.keys(typeEntries).length === 0;
-    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes && !hasValueSets) {
+    const valueSetSlot = entries['valueSet'];
+    const hasValueSets = valueSetSlot !== undefined && Object.keys(valueSetSlot).length > 0;
+    const emptyTables = Object.keys(entries['table'] ?? {}).length === 0;
+    if (id === UNBOUND_NAMESPACE_ID && emptyTables && !hasValueSets) {
       return PostgresSchema.unbound;
     }
     return new PostgresSchema({
       id,
       entries: {
-        table: blindCast<
-          Record<string, unknown>,
-          'table entries are StorageTable instances after base hydration'
-        >(tableEntries),
-        type: typeEntries ?? {},
-        ...(hasValueSets
-          ? {
-              valueSet: blindCast<
-                Record<string, unknown>,
-                'valueSet entries are StorageValueSet instances after base hydration'
-              >(valueSetEntries),
-            }
-          : {}),
+        ...entries,
+        table: entries['table'] ?? {},
+        ...(hasValueSets ? { valueSet: valueSetSlot } : {}),
       },
     });
   }
@@ -195,10 +142,6 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     for (const [tableName, table] of Object.entries(ns.table)) {
       tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
     }
-    const typeOut: Record<string, JsonObject> = {};
-    for (const [typeName, ty] of Object.entries(ns.type)) {
-      typeOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
-    }
     const valueSetEntries = ns.valueSet;
     const valueSetOut: Record<string, JsonObject> = {};
     if (valueSetEntries !== undefined) {
@@ -214,7 +157,6 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
       kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
       entries: {
         table: tablesOut,
-        type: typeOut,
         ...(Object.keys(valueSetOut).length > 0 ? { valueSet: valueSetOut } : {}),
       },
     };

package/src/core/postgres-schema.ts

@@ -4,8 +4,6 @@ import {
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import {
-  type PostgresEnumStorageEntry,
-  type SqlNamespaceEntries,
   type SqlNamespaceTablesInput,
   type SqlStorage,
   StorageTable,
@@ -15,13 +13,8 @@ import {
 } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
 import { escapeLiteral } from './sql-utils';
 
-export type PostgresNamespaceEntries = SqlNamespaceEntries & {
-  readonly type?: Readonly<Record<string, PostgresEnumType>>;
-};
-
 export interface PostgresSchemaInput {
   readonly id: string;
   readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
@@ -33,7 +26,7 @@ export interface PostgresSchemaInput {
  * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
  * the Postgres PSL interpreter from `namespace { … }` AST buckets.
  *
- * `entries` holds entity-kind maps (`table`, `type`). Qualifier
+ * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
  * emission is the rendering seam: DDL / SQL emission asks the namespace
  * for its qualifier (`"<schema>"`) or for a qualified table name
  * (`"<schema>"."<table>"`) and consumes the result polymorphically.
@@ -53,7 +46,7 @@ export class PostgresSchema extends NamespaceBase {
 
   declare readonly kind: 'schema';
   readonly id: string;
-  readonly entries: PostgresNamespaceEntries;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 
   constructor(input: PostgresSchemaInput) {
     super();
@@ -61,7 +54,6 @@ export class PostgresSchema extends NamespaceBase {
 
     const carried: Record<string, Readonly<Record<string, unknown>>> = {};
     let table: Readonly<Record<string, StorageTable>> = Object.freeze({});
-    let type: Readonly<Record<string, PostgresEnumType>> = Object.freeze({});
     let valueSet: Readonly<Record<string, StorageValueSet>> | undefined;
     for (const [kind, rawMap] of Object.entries(input.entries)) {
       if (kind === 'table') {
@@ -75,17 +67,6 @@ export class PostgresSchema extends NamespaceBase {
           tableMap[name] = new StorageTable(v);
         }
         table = Object.freeze(tableMap);
-      } else if (kind === 'type') {
-        const typeMap: Record<string, PostgresEnumType> = {};
-        for (const [name, v] of Object.entries(
-          blindCast<
-            Record<string, PostgresEnumTypeInput>,
-            'entries[type] holds PostgresEnumTypeInput by construction'
-          >(rawMap),
-        )) {
-          typeMap[name] = new PostgresEnumType(v);
-        }
-        type = Object.freeze(typeMap);
       } else if (kind === 'valueSet') {
         const vsMap: Record<string, StorageValueSet> = {};
         for (const [name, v] of Object.entries(
@@ -107,7 +88,6 @@ export class PostgresSchema extends NamespaceBase {
     this.entries = Object.freeze({
       ...carried,
       table,
-      type,
       ...ifDefined('valueSet', valueSet),
     });
     Object.defineProperty(this, 'kind', {
@@ -120,15 +100,11 @@ export class PostgresSchema extends NamespaceBase {
   }
 
   get table(): Readonly<Record<string, StorageTable>> {
-    return this.entries.table ?? Object.freeze({});
-  }
-
-  get type(): Readonly<Record<string, PostgresEnumType>> {
-    return this.entries.type ?? Object.freeze({});
+    return this.entries['table'] ?? Object.freeze({});
   }
 
   get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {
-    return this.entries.valueSet;
+    return this.entries['valueSet'] as Readonly<Record<string, StorageValueSet>> | undefined;
   }
 
   /**
@@ -211,7 +187,7 @@ export class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();
 
   constructor(input?: PostgresSchemaInput) {
-    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {}, type: {} } });
+    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });
   }
 
   override qualifier(): string {
@@ -253,19 +229,12 @@ export function isPostgresSchema(ns: unknown): ns is PostgresSchema {
  * by reference and trust the resulting `SqlStorage.namespaces` map to
  * be value-stable for a given input set.
  */
-export function postgresCreateNamespace(
-  input: SqlNamespaceTablesInput,
-  enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,
-): PostgresSchema {
+export function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {
   const schemaInput: PostgresSchemaInput = {
     id: input.id,
     entries: {
       ...input.entries,
       table: input.entries['table'] ?? {},
-      type: blindCast<
-        Record<string, PostgresEnumTypeInput>,
-        'enumTypes values are PostgresEnumTypeInput by construction'
-      >(enumTypes ?? {}),
     },
   };
   if (input.id === UNBOUND_NAMESPACE_ID) {

package/src/exports/codecs.ts

@@ -2,7 +2,6 @@ export type {
   PgBitDescriptor,
   PgBoolDescriptor,
   PgCharDescriptor,
-  PgEnumDescriptor,
   PgFloat4Descriptor,
   PgFloat8Descriptor,
   PgFloatDescriptor,
@@ -27,7 +26,6 @@ export {
   pgBitColumn,
   pgBoolColumn,
   pgCharColumn,
-  pgEnumColumn,
   pgFloat4Column,
   pgFloat8Column,
   pgFloatColumn,

package/src/exports/control.ts

@@ -10,7 +10,6 @@ import type {
 import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
-import { resolveDdlSchemaForNamespaceStorage } from '../core/migrations/enum-planning';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
@@ -31,12 +30,6 @@ function buildNativeTypeExpander(
     readonly typeParams?: Record<string, unknown>;
   }) => {
     if (!input.typeParams) return input.nativeType;
-    // Mirror `renderExpectedNativeType` in verify-sql-schema: when a codec
-    // has no `expandNativeType` hook (e.g. `pg/enum@1`, whose typeParams
-    // describe the value set rather than a DDL suffix), fall back to the
-    // bare native type rather than throwing. Throwing here would reject
-    // every plan involving an enum-/values-typed column as soon as its
-    // `typeRef` resolved to a `StorageTypeInstance` carrying typeParams.
     if (!input.codecId) return input.nativeType;
     const hooks = codecHooks.get(input.codecId);
     if (!hooks?.expandNativeType) return input.nativeType;
@@ -77,14 +70,6 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           annotationNamespace: 'pg',
           ...ifDefined('expandNativeType', expander),
           renderDefault: postgresRenderDefault,
-          // Map each namespace to the live DDL schema its enums are stored
-          // under, so the projected "from" IR nests enums by the same schema
-          // `readExistingEnumValues` reads (the contract-to-contract `migration
-          // plan` path). `undefined` schema IR ⇒ the unbound coordinate
-          // resolves to the default `public` landing schema, matching the
-          // read-side fallback.
-          resolveEnumNamespaceSchema: (storage, namespaceId) =>
-            resolveDdlSchemaForNamespaceStorage(storage, namespaceId, undefined),
         });
       },
     },

package/src/exports/migration.ts

@@ -42,12 +42,6 @@ export {
   createExtension,
   installExtension,
 } from '../core/migrations/operations/dependencies';
-export {
-  addEnumValues,
-  createEnumType,
-  dropEnumType,
-  renameType,
-} from '../core/migrations/operations/enums';
 export { createIndex, dropIndex } from '../core/migrations/operations/indexes';
 export { rawSql } from '../core/migrations/operations/raw';
 export { dropTable } from '../core/migrations/operations/tables';

package/src/exports/op-factory-call.ts

@@ -1,12 +1,10 @@
 export {
   AddCheckConstraintCall,
   AddColumnCall,
-  AddEnumValuesCall,
   AddForeignKeyCall,
   AddPrimaryKeyCall,
   AddUniqueCall,
   AlterColumnTypeCall,
-  CreateEnumTypeCall,
   CreateExtensionCall,
   CreateIndexCall,
   CreateSchemaCall,
@@ -16,12 +14,10 @@ export {
   DropColumnCall,
   DropConstraintCall,
   DropDefaultCall,
-  DropEnumTypeCall,
   DropIndexCall,
   DropNotNullCall,
   DropTableCall,
   RawSqlCall,
-  RenameTypeCall,
   SetDefaultCall,
   SetNotNullCall,
 } from '../core/migrations/op-factory-call';

package/src/exports/types.ts

@@ -1,5 +1,3 @@
-export { PostgresEnumType, type PostgresEnumTypeInput } from '../core/postgres-enum-type';
-export { PostgresEnumTypeSchema } from '../core/postgres-enum-type-schema';
 export {
   PostgresSchema,
   PostgresUnboundSchema,

package/dist/codec-ids-BzrFF-I4.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-ids-BzrFF-I4.d.mts","names":[],"sources":["../src/core/codec-ids.ts"],"mappings":";;;cAQa,gBAAA;AAAA,cACA,sBAAA;AAAA,cACA,gBAAA;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"}

package/dist/codec-ids-C_-Hj6bL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-ids-C_-Hj6bL.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_ENUM_CODEC_ID = 'pg/enum@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,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-types-B0WT0obB.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-B0WT0obB.d.mts","names":[],"sources":["../src/core/codec-type-map.ts","../src/exports/codec-types.ts"],"mappings":";;;;;cA6Ca,kBAAA;EAAA;;;;;;iBA+BH,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;KAEE,OAAA,6BAAoC,CAAA,0BAA2B,CAAA,CAAE,CAAA,IAAK,CAAA,CAAE,CAAA,EAAG,CAAA;AAAA,KAE3E,kBAAA,UAA4B,kBAAkB;AAAA,KAE9C,mBAAA,GAAsB,iBAAiB,CAAC,kBAAA;;;KCvExC,UAAA,GAAa,OAAO,CAAC,mBAAA;AAAA,KAI5B,OAAA,kBAAyB,MAAA,qBAA2B,CAAA,0BAClC,KAAA,GAAQ,KAAA,CAAM,CAAA;AAAA,KAGhC,aAAA,eAA4B,MAAA,qBAA2B,OAAA,SAAgB,KAAA;AAAA,KAEhE,IAAA,qBAAyB,aAAa;EAAG,YAAA,EAAc,CAAA;AAAA;AAAA,KACvD,OAAA,qBAA4B,aAAa;EAAG,eAAA,EAAiB,CAAA;AAAA;AAAA,KAC7D,OAAA,+DAAsE,aAAA;EAChF,kBAAA,EAAoB,CAAA;EACpB,cAAA,EAAgB,CAAA;AAAA;AAAA,KAEN,GAAA,qBAAwB,aAAa;EAAG,WAAA,EAAa,CAAA;AAAA;AAAA,KACrD,MAAA,qBAA2B,aAAa;EAAG,cAAA,EAAgB,CAAA;AAAA;AAAA,KAC3D,SAAA,6CAAsD,aAAa;EAC7E,oBAAA,EAAsB,CAAA;AAAA;AAAA,KAEZ,WAAA,6CAAwD,aAAa;EAC/E,sBAAA,EAAwB,CAAA;AAAA;AAAA,KAEd,IAAA,6CAAiD,aAAa;EAAG,eAAA,EAAiB,CAAA;AAAA;AAAA,KAClF,MAAA,6CAAmD,aAAa;EAC1E,iBAAA,EAAmB,CAAA;AAAA;AAAA,KAET,QAAA,6CAAqD,aAAa;EAC5E,mBAAA,EAAqB,CAAA;AAAA"}

package/dist/codecs-CX56Smsj.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codecs-CX56Smsj.d.mts","names":[],"sources":["../src/core/codecs.ts"],"mappings":"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"}

package/dist/descriptor-meta-runtime-BToWdas9.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-runtime-BToWdas9.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta-runtime.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\nimport type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\nimport { PostgresEnumTypeSchema } from './postgres-enum-type-schema';\n\nexport const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;\n\n/**\n * Entity type contributions surface as top-level helpers on the\n * composed-helpers shape (e.g. `helpers.enum({...})`), flattened\n * alongside the built-in `model` / `rel` helpers. Pack contributions\n * still ship via the contribution data structure\n * `authoring.entityTypes.<name>`; the composed-helpers template\n * performs the rename in the type system.\n *\n * `enum` is the first real consumer of the entities-namespace mechanism:\n * the factory constructs a `PostgresEnumType` IR-class instance from\n * the user-supplied input. Both authoring runtimes (TS DSL and PSL)\n * dispatch through this single contribution — PSL `enum Status { … }`\n * declarations are lowered by the interpreter into a factory call\n * with the parsed name + value list; TS DSL `helpers.enum({...})`\n * resolves through the same path. Removing this contribution makes\n * both surfaces fail with a \"no entity helper named `enum`\" type\n * error at the contract-definition site.\n */\n/**\n * The factory constructs a `PostgresEnumType` instance natively — the\n * `SqlStorage.types` slot accepts polymorphic IR (the framework\n * `StorageType` alphabet), so no cast is needed at the contribution\n * surface. The declared return type is the structural\n * `PostgresEnumStorageEntry` so the inferred contract type stays\n * portable (it names a type exported from\n * `@prisma-next/sql-contract/types`, a public surface every consumer\n * already imports). Sharpening the inferred contract type to surface\n * enum-specific narrowing through `EntityHelperFunction` is a\n * separable refinement and lives outside this PR.\n */\nexport const postgresAuthoringEntityTypes = {\n  enum: {\n    kind: 'entity',\n    discriminator: 'postgres-enum',\n    validatorSchema: PostgresEnumTypeSchema,\n    output: {\n      factory: (input: PostgresEnumTypeInput): PostgresEnumStorageEntry =>\n        new PostgresEnumType(input),\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 */\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","// Runtime-safe slice of the postgres target descriptor metadata.\n//\n// This file exists separately from ./descriptor-meta on purpose: the runtime\n// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the\n// `__codecTypes` phantom). The `authoring` slot lives on the pack/control\n// descriptor only, because authoring contributions are consumed at\n// contract-construction time by `assembleAuthoringContributions` (control\n// plane) and the PSL interpreter — never at runtime.\n//\n// Keeping the runtime closure free of the `./authoring` import is what lets\n// the bundler tree-shake `@prisma-next/family-sql/control` (and its\n// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not\n// add an `authoring` field here — if you need to, the pack/control meta in\n// `./descriptor-meta` is the right place. See TML-2766 for context.\nimport type { CodecTypes } from '../exports/codec-types';\n\nconst postgresTargetDescriptorMetaRuntimeBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n\nexport const postgresTargetDescriptorMetaRuntime: typeof postgresTargetDescriptorMetaRuntimeBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaRuntimeBase;\n"],"mappings":";;;;AAUA,MAAa,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCvC,MAAa,+BAA+B,EAC1C,MAAM;CACJ,MAAM;CACN,eAAe;CACf,iBAAiB;CACjB,QAAQ,EACN,UAAU,UACR,IAAI,iBAAiB,KAAK,EAC9B;AACF,EACF;;;;;;;;;;;;;;AAeA,MAAa,gCAAgC;CAC3C,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,KAAK;EACH,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,QAAQ;EACN,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,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;ACnJA,MAAa,sCAET;CAVF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,CAAC;AAKb"}

package/dist/enum-planning-D8z4FH7y.mjs

@@ -1,129 +0,0 @@
-import "./codec-ids-C_-Hj6bL.mjs";
-import { r as isPostgresSchema } from "./postgres-schema-C7c9rhGk.mjs";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
-//#region src/core/migrations/enum-planning.ts
-/**
-* Pure planning helpers for Postgres enum types: the diff/rebuild logic
-* that the verifier and planner use to walk `PostgresEnumType` instances
-* natively. Op builders live in `./operations/enums.ts`.
-*/
-function readOptionalString(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function readPgStorageTypeEntry(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return;
-	const codecId = Reflect.get(value, "codecId");
-	const typeParamsRaw = Reflect.get(value, "typeParams");
-	const typeParams = typeParamsRaw !== void 0 && typeParamsRaw !== null && typeof typeParamsRaw === "object" && !Array.isArray(typeParamsRaw) ? { values: Reflect.get(typeParamsRaw, "values") } : void 0;
-	return {
-		...typeof codecId === "string" ? { codecId } : {},
-		...typeParams !== void 0 ? { typeParams } : {}
-	};
-}
-function readPgEnumTypesMap(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return;
-	const bySchema = {};
-	for (const [schemaName, byTypeRaw] of Object.entries(value)) {
-		if (byTypeRaw === null || typeof byTypeRaw !== "object" || Array.isArray(byTypeRaw)) continue;
-		const byType = {};
-		for (const [nativeType, entryValue] of Object.entries(byTypeRaw)) {
-			const entry = readPgStorageTypeEntry(entryValue);
-			if (entry !== void 0) byType[nativeType] = entry;
-		}
-		if (Object.keys(byType).length > 0) bySchema[schemaName] = byType;
-	}
-	return Object.keys(bySchema).length > 0 ? bySchema : void 0;
-}
-/**
-* Reads the Postgres annotation envelope (`schema.annotations.pg`) from
-* family Schema IR. `SqlAnnotations` is an open target-pack extensibility
-* map (`Record<string, unknown>`); this accessor narrows the `pg` slot at
-* runtime so Postgres code can read introspection fields without casts.
-*/
-function readPostgresSchemaIrAnnotations(schema) {
-	const raw = schema.annotations?.["pg"];
-	if (raw === void 0 || raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
-	const schemaField = readOptionalString(Reflect.get(raw, "schema"));
-	const enumTypes = readPgEnumTypesMap(Reflect.get(raw, "enumTypes"));
-	return {
-		...schemaField !== void 0 ? { schema: schemaField } : {},
-		...enumTypes !== void 0 ? { enumTypes } : {}
-	};
-}
-/**
-* Resolves the live-schema name a namespace's enums are introspected under,
-* for keying `readExistingEnumValues` lookups. The unbound namespace's
-* `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a
-* real schema, so for the unbound coordinate we read the *introspected* schema
-* recorded on `annotations.pg.schema` (the live `current_schema()` the adapter
-* walked) — that is the schema the enum's `storageTypes` entry is keyed under.
-* Named namespaces resolve to their own DDL schema, which matches the
-* per-schema introspection key directly.
-*/
-function resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schemaIr) {
-	if (namespaceId === UNBOUND_NAMESPACE_ID) return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : void 0) ?? "public";
-	const namespace = storage.namespaces[namespaceId];
-	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
-	return namespaceId;
-}
-/** Contract-scoped bridge for the family verifier's enum value resolver. */
-function createResolveExistingEnumValues(storage) {
-	return (schema, enumType, namespaceId) => readExistingEnumValues(schema, resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema), enumType.nativeType);
-}
-/**
-* Reads existing enum values for `(schemaName, nativeType)` from the
-* Postgres-introspected `schema.annotations.pg.enumTypes` map, addressed by
-* the `(schema, nativeType)` coordinate.
-*
-* Schema IR's enum entries are always codec-typed
-* (`{codecId: PG_ENUM_CODEC_ID, typeParams.values}`): the introspector
-* writes that shape, and the Contract→Schema IR projector resolves
-* `PostgresEnumType` instances down to the same codec-typed triple before
-* they ever land in Schema IR. There is no second on-disk shape to
-* accept here.
-*
-* Returns `null` when no enum entry exists for the given native type.
-*/
-function readExistingEnumValues(schema, schemaName, nativeType) {
-	const existing = readPostgresSchemaIrAnnotations(schema).enumTypes?.[schemaName]?.[nativeType];
-	if (!existing || existing.codecId !== "pg/enum@1") return null;
-	const enumValues = existing.typeParams?.values;
-	if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === "string")) return null;
-	return enumValues;
-}
-/**
-* Determines what changes are needed to transform existing enum values to
-* desired values.
-*
-* Postgres enums can only have values added (not removed or reordered)
-* without a full type rebuild involving temp type creation and column
-* migration; `'rebuild'` covers the value-removal and reorder cases.
-*/
-function determineEnumDiff(existing, desired) {
-	if (arraysEqual(existing, desired)) return { kind: "unchanged" };
-	const existingSet = new Set(existing);
-	const desiredSet = new Set(desired);
-	const missingValues = desired.filter((value) => !existingSet.has(value));
-	const removedValues = existing.filter((value) => !desiredSet.has(value));
-	const orderMismatch = missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);
-	if (removedValues.length > 0 || orderMismatch) return {
-		kind: "rebuild",
-		removedValues
-	};
-	return {
-		kind: "add_values",
-		values: missingValues
-	};
-}
-/**
-* Convenience accessor — returns the enum's desired values from a
-* `PostgresEnumType` IR instance.
-*/
-function getDesiredEnumValues(typeInstance) {
-	return typeInstance.values;
-}
-//#endregion
-export { readPostgresSchemaIrAnnotations as a, readExistingEnumValues as i, determineEnumDiff as n, resolveDdlSchemaForNamespaceStorage as o, getDesiredEnumValues as r, createResolveExistingEnumValues as t };
-
-//# sourceMappingURL=enum-planning-D8z4FH7y.mjs.map

package/dist/enum-planning-D8z4FH7y.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"enum-planning-D8z4FH7y.mjs","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"sourcesContent":["/**\n * Pure planning helpers for Postgres enum types: the diff/rebuild logic\n * that the verifier and planner use to walk `PostgresEnumType` instances\n * natively. Op builders live in `./operations/enums.ts`.\n */\n\nimport { arraysEqual } from '@prisma-next/family-sql/schema-verify';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { PG_ENUM_CODEC_ID } from '../codec-ids';\nimport type { PostgresEnumType } from '../postgres-enum-type';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Codec-typed enum entry shape stored under\n * `schema.annotations.pg.enumTypes[schemaName][nativeType]`.\n */\ninterface PgStorageTypeEntry {\n  readonly codecId?: string;\n  readonly typeParams?: { readonly values?: unknown };\n}\n\n/**\n * Live enum types keyed by `(schemaName, nativeType)` as a nested map, so two\n * schemas sharing a native enum name stay distinct without packing the pair\n * into a string. This is the same `(namespace, entityName)` coordinate the\n * contract side addresses entities by.\n */\ntype PgEnumTypesMap = Readonly<Record<string, Readonly<Record<string, PgStorageTypeEntry>>>>;\n\n/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */\nexport interface PostgresSchemaIrAnnotations {\n  readonly schema?: string;\n  readonly enumTypes?: PgEnumTypesMap;\n}\n\nfunction readOptionalString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\nfunction readPgStorageTypeEntry(value: unknown): PgStorageTypeEntry | undefined {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n  const codecId = Reflect.get(value, 'codecId');\n  const typeParamsRaw = Reflect.get(value, 'typeParams');\n  const typeParams =\n    typeParamsRaw !== undefined &&\n    typeParamsRaw !== null &&\n    typeof typeParamsRaw === 'object' &&\n    !Array.isArray(typeParamsRaw)\n      ? { values: Reflect.get(typeParamsRaw, 'values') }\n      : undefined;\n  return {\n    ...(typeof codecId === 'string' ? { codecId } : {}),\n    ...(typeParams !== undefined ? { typeParams } : {}),\n  };\n}\n\nfunction readPgEnumTypesMap(value: unknown): PgEnumTypesMap | undefined {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n  const bySchema: Record<string, Record<string, PgStorageTypeEntry>> = {};\n  for (const [schemaName, byTypeRaw] of Object.entries(value)) {\n    if (byTypeRaw === null || typeof byTypeRaw !== 'object' || Array.isArray(byTypeRaw)) {\n      continue;\n    }\n    const byType: Record<string, PgStorageTypeEntry> = {};\n    for (const [nativeType, entryValue] of Object.entries(byTypeRaw)) {\n      const entry = readPgStorageTypeEntry(entryValue);\n      if (entry !== undefined) {\n        byType[nativeType] = entry;\n      }\n    }\n    if (Object.keys(byType).length > 0) {\n      bySchema[schemaName] = byType;\n    }\n  }\n  return Object.keys(bySchema).length > 0 ? bySchema : undefined;\n}\n\n/**\n * Reads the Postgres annotation envelope (`schema.annotations.pg`) from\n * family Schema IR. `SqlAnnotations` is an open target-pack extensibility\n * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at\n * runtime so Postgres code can read introspection fields without casts.\n */\nexport function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations {\n  const raw = schema.annotations?.['pg'];\n  if (raw === undefined || raw === null || typeof raw !== 'object' || Array.isArray(raw)) {\n    return {};\n  }\n  const schemaField = readOptionalString(Reflect.get(raw, 'schema'));\n  const enumTypes = readPgEnumTypesMap(Reflect.get(raw, 'enumTypes'));\n  return {\n    ...(schemaField !== undefined ? { schema: schemaField } : {}),\n    ...(enumTypes !== undefined ? { enumTypes } : {}),\n  };\n}\n\n/**\n * Resolves the live-schema name a namespace's enums are introspected under,\n * for keying `readExistingEnumValues` lookups. The unbound namespace's\n * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a\n * real schema, so for the unbound coordinate we read the *introspected* schema\n * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter\n * walked) — that is the schema the enum's `storageTypes` entry is keyed under.\n * Named namespaces resolve to their own DDL schema, which matches the\n * per-schema introspection key directly.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  schemaIr?: SqlSchemaIR,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : undefined) ?? 'public';\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/** Contract-scoped bridge for the family verifier's enum value resolver. */\nexport function createResolveExistingEnumValues(\n  storage: SqlStorage,\n): (\n  schema: SqlSchemaIR,\n  enumType: PostgresEnumStorageEntry,\n  namespaceId: string,\n) => readonly string[] | null {\n  return (schema, enumType, namespaceId) =>\n    readExistingEnumValues(\n      schema,\n      resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema),\n      enumType.nativeType,\n    );\n}\n\n/**\n * Categorisation of how an existing enum type's values relate to the\n * desired set in the contract.\n */\nexport type EnumDiff =\n  | { readonly kind: 'unchanged' }\n  | { readonly kind: 'add_values'; readonly values: readonly string[] }\n  | { readonly kind: 'rebuild'; readonly removedValues: readonly string[] };\n\n/**\n * Reads existing enum values for `(schemaName, nativeType)` from the\n * Postgres-introspected `schema.annotations.pg.enumTypes` map, addressed by\n * the `(schema, nativeType)` coordinate.\n *\n * Schema IR's enum entries are always codec-typed\n * (`{codecId: PG_ENUM_CODEC_ID, typeParams.values}`): the introspector\n * writes that shape, and the Contract→Schema IR projector resolves\n * `PostgresEnumType` instances down to the same codec-typed triple before\n * they ever land in Schema IR. There is no second on-disk shape to\n * accept here.\n *\n * Returns `null` when no enum entry exists for the given native type.\n */\nexport function readExistingEnumValues(\n  schema: SqlSchemaIR,\n  schemaName: string,\n  nativeType: string,\n): readonly string[] | null {\n  const enumTypes = readPostgresSchemaIrAnnotations(schema).enumTypes;\n  const existing = enumTypes?.[schemaName]?.[nativeType];\n  if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {\n    return null;\n  }\n  const enumValues = existing.typeParams?.values;\n  if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === 'string')) {\n    return null;\n  }\n  return enumValues;\n}\n\n/**\n * Determines what changes are needed to transform existing enum values to\n * desired values.\n *\n * Postgres enums can only have values added (not removed or reordered)\n * without a full type rebuild involving temp type creation and column\n * migration; `'rebuild'` covers the value-removal and reorder cases.\n */\nexport function determineEnumDiff(\n  existing: readonly string[],\n  desired: readonly string[],\n): EnumDiff {\n  if (arraysEqual(existing, desired)) {\n    return { kind: 'unchanged' };\n  }\n  const existingSet = new Set(existing);\n  const desiredSet = new Set(desired);\n  const missingValues = desired.filter((value) => !existingSet.has(value));\n  const removedValues = existing.filter((value) => !desiredSet.has(value));\n  const orderMismatch =\n    missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);\n  if (removedValues.length > 0 || orderMismatch) {\n    return { kind: 'rebuild', removedValues };\n  }\n  return { kind: 'add_values', values: missingValues };\n}\n\n/**\n * Convenience accessor — returns the enum's desired values from a\n * `PostgresEnumType` IR instance.\n */\nexport function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[] {\n  return typeInstance.values;\n}\n"],"mappings":";;;;;;;;;;AAqCA,SAAS,mBAAmB,OAAoC;CAC9D,OAAO,OAAO,UAAU,WAAW,QAAQ,KAAA;AAC7C;AAEA,SAAS,uBAAuB,OAAgD;CAC9E,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GACpE;CAEF,MAAM,UAAU,QAAQ,IAAI,OAAO,SAAS;CAC5C,MAAM,gBAAgB,QAAQ,IAAI,OAAO,YAAY;CACrD,MAAM,aACJ,kBAAkB,KAAA,KAClB,kBAAkB,QAClB,OAAO,kBAAkB,YACzB,CAAC,MAAM,QAAQ,aAAa,IACxB,EAAE,QAAQ,QAAQ,IAAI,eAAe,QAAQ,EAAE,IAC/C,KAAA;CACN,OAAO;EACL,GAAI,OAAO,YAAY,WAAW,EAAE,QAAQ,IAAI,CAAC;EACjD,GAAI,eAAe,KAAA,IAAY,EAAE,WAAW,IAAI,CAAC;CACnD;AACF;AAEA,SAAS,mBAAmB,OAA4C;CACtE,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GACpE;CAEF,MAAM,WAA+D,CAAC;CACtE,KAAK,MAAM,CAAC,YAAY,cAAc,OAAO,QAAQ,KAAK,GAAG;EAC3D,IAAI,cAAc,QAAQ,OAAO,cAAc,YAAY,MAAM,QAAQ,SAAS,GAChF;EAEF,MAAM,SAA6C,CAAC;EACpD,KAAK,MAAM,CAAC,YAAY,eAAe,OAAO,QAAQ,SAAS,GAAG;GAChE,MAAM,QAAQ,uBAAuB,UAAU;GAC/C,IAAI,UAAU,KAAA,GACZ,OAAO,cAAc;EAEzB;EACA,IAAI,OAAO,KAAK,MAAM,CAAC,CAAC,SAAS,GAC/B,SAAS,cAAc;CAE3B;CACA,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,SAAS,IAAI,WAAW,KAAA;AACvD;;;;;;;AAQA,SAAgB,gCAAgC,QAAkD;CAChG,MAAM,MAAM,OAAO,cAAc;CACjC,IAAI,QAAQ,KAAA,KAAa,QAAQ,QAAQ,OAAO,QAAQ,YAAY,MAAM,QAAQ,GAAG,GACnF,OAAO,CAAC;CAEV,MAAM,cAAc,mBAAmB,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACjE,MAAM,YAAY,mBAAmB,QAAQ,IAAI,KAAK,WAAW,CAAC;CAClE,OAAO;EACL,GAAI,gBAAgB,KAAA,IAAY,EAAE,QAAQ,YAAY,IAAI,CAAC;EAC3D,GAAI,cAAc,KAAA,IAAY,EAAE,UAAU,IAAI,CAAC;CACjD;AACF;;;;;;;;;;;AAYA,SAAgB,oCACd,SACA,aACA,UACQ;CACR,IAAI,gBAAgB,sBAClB,QAAQ,WAAW,gCAAgC,QAAQ,CAAC,CAAC,SAAS,KAAA,MAAc;CAEtF,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT;;AAGA,SAAgB,gCACd,SAK4B;CAC5B,QAAQ,QAAQ,UAAU,gBACxB,uBACE,QACA,oCAAoC,SAAS,aAAa,MAAM,GAChE,SAAS,UACX;AACJ;;;;;;;;;;;;;;;AAyBA,SAAgB,uBACd,QACA,YACA,YAC0B;CAE1B,MAAM,WADY,gCAAgC,MAAM,CAAC,CAAC,YAC7B,WAAW,GAAG;CAC3C,IAAI,CAAC,YAAY,SAAS,YAAA,aACxB,OAAO;CAET,MAAM,aAAa,SAAS,YAAY;CACxC,IAAI,CAAC,MAAM,QAAQ,UAAU,KAAK,CAAC,WAAW,OAAO,MAAM,OAAO,MAAM,QAAQ,GAC9E,OAAO;CAET,OAAO;AACT;;;;;;;;;AAUA,SAAgB,kBACd,UACA,SACU;CACV,IAAI,YAAY,UAAU,OAAO,GAC/B,OAAO,EAAE,MAAM,YAAY;CAE7B,MAAM,cAAc,IAAI,IAAI,QAAQ;CACpC,MAAM,aAAa,IAAI,IAAI,OAAO;CAClC,MAAM,gBAAgB,QAAQ,QAAQ,UAAU,CAAC,YAAY,IAAI,KAAK,CAAC;CACvE,MAAM,gBAAgB,SAAS,QAAQ,UAAU,CAAC,WAAW,IAAI,KAAK,CAAC;CACvE,MAAM,gBACJ,cAAc,WAAW,KAAK,cAAc,WAAW,KAAK,CAAC,YAAY,UAAU,OAAO;CAC5F,IAAI,cAAc,SAAS,KAAK,eAC9B,OAAO;EAAE,MAAM;EAAW;CAAc;CAE1C,OAAO;EAAE,MAAM;EAAc,QAAQ;CAAc;AACrD;;;;;AAMA,SAAgB,qBAAqB,cAAmD;CACtF,OAAO,aAAa;AACtB"}