@prisma-next/target-postgres 0.11.0 → 0.12.0-dev.10

package/src/core/migrations/statement-builders.ts

@@ -40,6 +40,9 @@ export const ensureLedgerTableStatement: SqlStatement = {
   sql: `create table if not exists prisma_contract.ledger (
     id bigserial primary key,
     created_at timestamptz not null default now(),
+    space text not null,
+    migration_name text not null,
+    migration_hash text not null,
     origin_core_hash text,
     origin_profile_hash text,
     destination_core_hash text not null,
@@ -56,7 +59,7 @@ export interface MergeMarkerInput {
    * Logical space identifier for this marker row. Required at every
    * call site so the type system surfaces every place that needs to
    * thread the value (rather than letting an `?? APP_SPACE_ID`
-   * fall-through silently collapse multi-space markers onto the
+   * fall-through silently collapse per-space markers onto the
    * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}
    * (`'app'`); per-extension callers (planner / runner / verifier
    * extensions over contract spaces) pass the extension's space id.
@@ -138,6 +141,9 @@ export function buildMergeMarkerStatements(input: MergeMarkerInput): {
 }
 
 export interface LedgerInsertInput {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
   readonly originStorageHash?: string | null;
   readonly originProfileHash?: string | null;
   readonly destinationStorageHash: string;
@@ -150,6 +156,9 @@ export interface LedgerInsertInput {
 export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {
   return {
     sql: `insert into prisma_contract.ledger (
+      space,
+      migration_name,
+      migration_hash,
       origin_core_hash,
       origin_profile_hash,
       destination_core_hash,
@@ -162,11 +171,17 @@ export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStateme
       $2,
       $3,
       $4,
-      $5::jsonb,
-      $6::jsonb,
-      $7::jsonb
+      $5,
+      $6,
+      $7,
+      $8::jsonb,
+      $9::jsonb,
+      $10::jsonb
     )`,
     params: [
+      input.space,
+      input.migrationName,
+      input.migrationHash,
       input.originStorageHash ?? null,
       input.originProfileHash ?? null,
       input.destinationStorageHash,

package/src/core/migrations/verify-postgres-namespaces.ts

@@ -52,12 +52,12 @@ function existingSchemasFromSchema(schema: SqlSchemaIR): readonly string[] {
  *
  * A namespace's live container is the schema returned by its
  * polymorphic `ddlSchemaName(storage)` method — named schemas resolve
- * to their own id, the unbound singleton projects to `public` (sibling
- * present) or the framework sentinel (sibling absent). Issues are
- * emitted only when the resolved name is a real, creatable schema
- * (not the unbound sentinel) and is missing from the introspected
- * list. `public` is suppressed implicitly because the introspection
- * (or its sensible default) always carries it.
+ * to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`
+ * and is skipped explicitly (late-bound namespaces have no fixed DDL
+ * schema). Issues are emitted only when the resolved name is a real,
+ * creatable schema (not the unbound sentinel) and is missing from the
+ * introspected list. `public` is suppressed implicitly because the
+ * introspection (or its sensible default) always carries it.
  *
  * Each emitted issue stamps `namespaceId` with the contract namespace
  * coordinate so the downstream `mapIssueToCall` re-resolves the DDL

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

@@ -94,19 +94,19 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     const hydrated = super.hydrateSqlNamespaceEntry(nsId, raw) as {
       id: string;
       tables: Readonly<Record<string, StorageTable>>;
-      types?: Readonly<Record<string, PostgresEnumType>>;
+      enum?: Readonly<Record<string, PostgresEnumType>>;
     };
-    const { id, tables, types: hydratedNsTypes } = hydrated;
+    const { id, tables, enum: hydratedNsEnums } = hydrated;
 
     const emptyTables = Object.keys(tables).length === 0;
-    const emptyTypes = !hydratedNsTypes || Object.keys(hydratedNsTypes).length === 0;
-    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) {
+    const emptyEnums = !hydratedNsEnums || Object.keys(hydratedNsEnums).length === 0;
+    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyEnums) {
       return PostgresSchema.unbound;
     }
     return new PostgresSchema({
       id,
       tables,
-      ...(hydratedNsTypes !== undefined ? { types: hydratedNsTypes } : {}),
+      ...(hydratedNsEnums !== undefined ? { enum: hydratedNsEnums } : {}),
     });
   }
 
@@ -117,15 +117,15 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
       if (isPostgresSchema(ns)) {
         namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
       } else {
-        // Family-level SqlNamespacePayload / SqlUnboundNamespace haven't
-        // been promoted to a PostgresSchema instance yet (e.g. they came
-        // straight from the TS builder, which uses the family-shared
-        // SqlStorage constructor). Serialise them as postgres-schema /
+        // Family-level SqlUnboundNamespace or other family-built SQL
+        // namespaces haven't been promoted to a PostgresSchema instance
+        // yet (e.g. they came straight from the TS builder before a target
+        // `createNamespace` factory ran). Serialise them as postgres-schema /
         // postgres-unbound-schema so the round-trip through
         // deserializeContract hydrates them back into PostgresSchema
         // instances.
         const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;
-        const nsTypes = (ns as { readonly types?: Readonly<Record<string, unknown>> }).types ?? {};
+        const nsEnums = (ns as { readonly enum?: Readonly<Record<string, unknown>> }).enum ?? {};
         namespacesJson[nsId] = {
           id: nsId,
           kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
@@ -135,8 +135,8 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
               this.serializeJsonValue(table) as JsonObject,
             ]),
           ),
-          types: Object.fromEntries(
-            Object.entries(nsTypes).map(([typeName, entry]) => [
+          enum: Object.fromEntries(
+            Object.entries(nsEnums).map(([typeName, entry]) => [
               typeName,
               this.serializeJsonValue(entry) as JsonObject,
             ]),
@@ -166,15 +166,15 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     for (const [tableName, table] of Object.entries(ns.tables)) {
       tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
     }
-    const typesOut: Record<string, JsonObject> = {};
-    for (const [typeName, ty] of Object.entries(ns.types)) {
-      typesOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
+    const enumOut: Record<string, JsonObject> = {};
+    for (const [typeName, ty] of Object.entries(ns.enum)) {
+      enumOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
     }
     return {
       id: ns.id,
       kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
       tables: tablesOut,
-      types: typesOut,
+      enum: enumOut,
     };
   }
 

package/src/core/postgres-enum-type.ts

@@ -1,3 +1,4 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
@@ -18,6 +19,7 @@ export interface PostgresEnumTypeInput<
    */
   readonly nativeType?: string;
   readonly values: TValues;
+  readonly control?: ControlPolicy;
 }
 
 /** Codec id used by Postgres enum-typed columns (text wire format). */
@@ -64,6 +66,7 @@ export class PostgresEnumType<
    * dispatching through the prototype-only `codecBinding` accessor.
    */
   readonly codecId: typeof PG_ENUM_CODEC_ID = PG_ENUM_CODEC_ID;
+  declare readonly control?: ControlPolicy;
 
   constructor(input: PostgresEnumTypeInput<TName, TValues>) {
     super();
@@ -73,6 +76,7 @@ export class PostgresEnumType<
     // `TValues` literal tuple. Cast preserves the caller-supplied
     // tuple shape so inferred contract types retain literal narrowing.
     this.values = Object.freeze([...input.values] as unknown as TValues);
+    if (input.control !== undefined) this.control = input.control;
     freezeNode(this);
   }
 

package/src/core/postgres-schema.ts

@@ -15,7 +15,7 @@ import { escapeLiteral } from './sql-utils';
 export interface PostgresSchemaInput {
   readonly id: string;
   readonly tables?: Record<string, StorageTable | StorageTableInput>;
-  readonly types?: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
+  readonly enum?: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
 }
 
 /**
@@ -44,7 +44,7 @@ export class PostgresSchema extends NamespaceBase {
   declare readonly kind: 'schema';
   readonly id: string;
   readonly tables: Readonly<Record<string, StorageTable>>;
-  readonly types: Readonly<Record<string, PostgresEnumType>>;
+  readonly enum: Readonly<Record<string, PostgresEnumType>>;
 
   constructor(input: PostgresSchemaInput) {
     super();
@@ -57,9 +57,9 @@ export class PostgresSchema extends NamespaceBase {
         ]),
       ),
     );
-    this.types = Object.freeze(
+    this.enum = Object.freeze(
       Object.fromEntries(
-        Object.entries(input.types ?? {}).map(([name, ty]) => [
+        Object.entries(input.enum ?? {}).map(([name, ty]) => [
           name,
           ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty),
         ]),
@@ -120,10 +120,11 @@ export class PostgresSchema extends NamespaceBase {
    * statements that need to identify this namespace in the live
    * database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
    * catalog filters, planner conflict lookups). Named schemas resolve
-   * to their own id; the unbound singleton overrides this to project
-   * to `'public'` when a sibling public namespace exists in the same
-   * contract — and falls back to the framework sentinel otherwise so
-   * the planner can detect the missing-projection case explicitly.
+   * to their own id. The `PostgresUnboundSchema` singleton inherits
+   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
+   * through `qualifyTableName` / `toRegclassLiteral` route through the
+   * polymorphic `PostgresUnboundSchema` overrides and produce
+   * unqualified (search-path-resolved) output automatically.
    */
   ddlSchemaName(_storage: SqlStorage): string {
     return this.id;
@@ -143,6 +144,11 @@ export class PostgresSchema extends NamespaceBase {
  * sentinel; Postgres decides what late-bound means here (the table
  * name, naked — the schema is supplied by the live connection's
  * `search_path`).
+ *
+ * `ddlSchemaName` is inherited from `PostgresSchema` and returns
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,
+ * `toRegclassLiteral`) route through the polymorphic factory and
+ * produce unqualified output automatically.
  */
 export class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();
@@ -162,22 +168,6 @@ export class PostgresUnboundSchema extends PostgresSchema {
   override schemaSqlExpression(): string {
     return 'current_schema()';
   }
-
-  /**
-   * The unbound slot has no schema name of its own, so DDL emission
-   * projects it onto a sibling when one is available: if the contract
-   * carries a `public` namespace, the late-bound slot resolves to
-   * `'public'` (the default Postgres landing schema); otherwise it
-   * resolves to the framework sentinel `UNBOUND_NAMESPACE_ID` so the
-   * planner can recognise the unprojected case and route accordingly
-   * (e.g. emit a conflict instead of silently picking a schema).
-   */
-  override ddlSchemaName(storage: SqlStorage): string {
-    if (storage.namespaces['public'] !== undefined) {
-      return 'public';
-    }
-    return UNBOUND_NAMESPACE_ID;
-  }
 }
 
 PostgresSchema.unbound = PostgresUnboundSchema.instance;

package/src/exports/control.ts

@@ -12,6 +12,10 @@ 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 {
+  enumStorageCompoundKey,
+  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';
@@ -78,6 +82,18 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           annotationNamespace: 'pg',
           ...ifDefined('expandNativeType', expander),
           renderDefault: postgresRenderDefault,
+          // Schema-qualify enum annotation keys so the projected "from" IR's
+          // `storageTypes` match `readExistingEnumValues` on the read side
+          // (the contract-to-contract `migration plan` path). The DDL-schema
+          // resolution + compound-key format stay here in the target layer;
+          // the family projector treats the returned string as opaque.
+          // `undefined` schema IR ⇒ the unbound coordinate resolves to the
+          // default `public` landing schema, matching the read-side fallback.
+          resolveEnumStorageKey: (storage, namespaceId, nativeType) =>
+            enumStorageCompoundKey(
+              resolveDdlSchemaForNamespaceStorage(storage, namespaceId, undefined),
+              nativeType,
+            ),
         });
       },
     },

package/src/exports/enum-planning.ts

@@ -1,6 +1,11 @@
 export {
+  createResolveExistingEnumValues,
   determineEnumDiff,
   type EnumDiff,
+  enumStorageCompoundKey,
   getDesiredEnumValues,
+  type PostgresSchemaIrAnnotations,
   readExistingEnumValues,
+  readPostgresSchemaIrAnnotations,
+  resolveDdlSchemaForNamespaceStorage,
 } from '../core/migrations/enum-planning';

package/src/exports/runtime.ts

@@ -3,7 +3,7 @@ import type {
   RuntimeTargetDescriptor,
   RuntimeTargetInstance,
 } from '@prisma-next/framework-components/execution';
-import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
+import { postgresTargetDescriptorMetaRuntime } from '../core/descriptor-meta-runtime';
 
 export { PostgresContractSerializer } from '../core/postgres-contract-serializer';
 
@@ -22,7 +22,7 @@ const postgresRuntimeTargetDescriptor: RuntimeTargetDescriptor<
 > & {
   readonly codecs: () => readonly AnyCodecDescriptor[];
 } = {
-  ...postgresTargetDescriptorMeta,
+  ...postgresTargetDescriptorMetaRuntime,
   codecs: () => [],
   create(): PostgresRuntimeTargetInstance {
     return {

package/dist/codec-types-CRlHq7Cz.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-CRlHq7Cz.d.mts","names":[],"sources":["../src/core/codec-type-map.ts","../src/exports/codec-types.ts"],"mappings":";;;;;;cA4Ca,kBAAA;EAAA,eA8BH,uCAAA,CAAA,iBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEE,OAAA,6BAAoC,CAAA,0BAA2B,CAAA,CAAE,CAAA,IAAK,CAAA,CAAE,CAAA,EAAG,CAAA;AAAA,KAE3E,kBAAA,UAA4B,kBAAA;AAAA,KAE5B,mBAAA,GAAsB,iBAAA,CAAkB,kBAAA;;;KCrExC,UAAA,GAAa,OAAA,CAAQ,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;EAAgB,YAAA,EAAc,CAAA;AAAA;AAAA,KACvD,OAAA,qBAA4B,aAAA;EAAgB,eAAA,EAAiB,CAAA;AAAA;AAAA,KAC7D,OAAA,+DAAsE,aAAA;EAChF,kBAAA,EAAoB,CAAA;EACpB,cAAA,EAAgB,CAAA;AAAA;AAAA,KAEN,GAAA,qBAAwB,aAAA;EAAgB,WAAA,EAAa,CAAA;AAAA;AAAA,KACrD,MAAA,qBAA2B,aAAA;EAAgB,cAAA,EAAgB,CAAA;AAAA;AAAA,KAC3D,SAAA,6CAAsD,aAAA;EAChE,oBAAA,EAAsB,CAAA;AAAA;AAAA,KAEZ,WAAA,6CAAwD,aAAA;EAClE,sBAAA,EAAwB,CAAA;AAAA;AAAA,KAEd,IAAA,6CAAiD,aAAA;EAAgB,eAAA,EAAiB,CAAA;AAAA;AAAA,KAClF,MAAA,6CAAmD,aAAA;EAC7D,iBAAA,EAAmB,CAAA;AAAA;AAAA,KAET,QAAA,6CAAqD,aAAA;EAC/D,mBAAA,EAAqB,CAAA;AAAA"}

package/dist/data-transform-bmOKkygi.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-transform-bmOKkygi.d.mts","names":[],"sources":["../src/core/migrations/operations/data-transform.ts"],"mappings":";;;;;;;;UAqEU,SAAA;EACR,KAAA,IAAS,YAAA,CAAa,CAAA;AAAA;;;;;KAOZ,oBAAA,SAA6B,YAAA,GAAe,SAAA;AAAA,UAEvC,oBAAA;;;;;;WAMN,WAAA;;;;;;;;WAQA,KAAA,GAAQ,oBAAA;;WAER,GAAA,EAAK,oBAAA,YAAgC,oBAAA;AAAA;AAAA,iBAGhC,aAAA,mBAAgC,QAAA,CAAS,UAAA,EAAA,CACvD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,EAAS,iBAAA,eACR,yBAAA,CAA0B,yBAAA"}

package/dist/descriptor-meta-DLA2xV6B.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-DLA2xV6B.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.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 { PostgresEnumTypeSchema } from '@prisma-next/sql-contract/validators';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\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 */\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: temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n} as const satisfies AuthoringFieldNamespace;\n","import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringTypes,\n} from './authoring';\n\nconst postgresTargetDescriptorMetaBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";;;;AAUA,MAAa,yBAAyB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCxC,MAAa,+BAA+B,EAC1C,MAAM;CACJ,MAAM;CACN,eAAe;CACf,iBAAiB;CACjB,QAAQ,EACN,UAAU,UACR,IAAI,iBAAiB,MAAM,EAC9B;CACF,EACF;AC/BD,MAAa,+BAET;CAfF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CAChB,WAAW;EACT,MAAM;EACN,OAAO;GD+CT,MAAM;IACJ,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,KAAK;IACH,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,QAAQ;IACN,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,OAAO;IACL,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,SAAS;IACP,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,SAAS;IACP,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,MAAM;IACJ,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,OAAO;IACL,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,UAAU;IACR,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,UAAU,yBAAyB;IACjC,SAAS;IACT,YAAY;IACb,CAAC;GCjHO;EACP,aAAa;EACd;CAKC"}

package/dist/enum-planning-Bqp96iIw.mjs

@@ -1,63 +0,0 @@
-import "./codec-ids-C5qzBqus.mjs";
-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`.
-*/
-/**
-* Reads existing enum values for `nativeType` from the
-* Postgres-introspected `schema.annotations.pg.storageTypes` map.
-*
-* Schema IR's `storageTypes` slots 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, nativeType) {
-	const existing = ((schema.annotations?.["pg"])?.["storageTypes"])?.[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 { getDesiredEnumValues as n, readExistingEnumValues as r, determineEnumDiff as t };
-
-//# sourceMappingURL=enum-planning-Bqp96iIw.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"enum-planning-Bqp96iIw.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 type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { PG_ENUM_CODEC_ID } from '../codec-ids';\nimport type { PostgresEnumType } from '../postgres-enum-type';\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 `nativeType` from the\n * Postgres-introspected `schema.annotations.pg.storageTypes` map.\n *\n * Schema IR's `storageTypes` slots 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  nativeType: string,\n): readonly string[] | null {\n  const storageTypes = (schema.annotations?.['pg'] as Record<string, unknown> | undefined)?.[\n    'storageTypes'\n  ] as\n    | Record<\n        string,\n        {\n          codecId?: string;\n          typeParams?: { values?: unknown };\n        }\n      >\n    | undefined;\n  const existing = storageTypes?.[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 as readonly string[];\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":";;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,uBACd,QACA,YAC0B;CAY1B,MAAM,aAXgB,OAAO,cAAc,SACzC,mBAU8B;CAChC,IAAI,CAAC,YAAY,SAAS,YAAA,aACxB,OAAO;CAET,MAAM,aAAa,SAAS,YAAY;CACxC,IAAI,CAAC,MAAM,QAAQ,WAAW,IAAI,CAAC,WAAW,OAAO,MAAM,OAAO,MAAM,SAAS,EAC/E,OAAO;CAET,OAAO;;;;;;;;;;AAWT,SAAgB,kBACd,UACA,SACU;CACV,IAAI,YAAY,UAAU,QAAQ,EAChC,OAAO,EAAE,MAAM,aAAa;CAE9B,MAAM,cAAc,IAAI,IAAI,SAAS;CACrC,MAAM,aAAa,IAAI,IAAI,QAAQ;CACnC,MAAM,gBAAgB,QAAQ,QAAQ,UAAU,CAAC,YAAY,IAAI,MAAM,CAAC;CACxE,MAAM,gBAAgB,SAAS,QAAQ,UAAU,CAAC,WAAW,IAAI,MAAM,CAAC;CACxE,MAAM,gBACJ,cAAc,WAAW,KAAK,cAAc,WAAW,KAAK,CAAC,YAAY,UAAU,QAAQ;CAC7F,IAAI,cAAc,SAAS,KAAK,eAC9B,OAAO;EAAE,MAAM;EAAW;EAAe;CAE3C,OAAO;EAAE,MAAM;EAAc,QAAQ;EAAe;;;;;;AAOtD,SAAgB,qBAAqB,cAAmD;CACtF,OAAO,aAAa"}