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

package/src/core/migrations/runner.ts

@@ -1,7 +1,6 @@
 import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
-  MultiSpaceRunnerResult,
   SqlControlFamilyInstance,
   SqlMigrationPlanContractInfo,
   SqlMigrationPlanOperation,
@@ -14,15 +13,19 @@ import type {
 } from '@prisma-next/family-sql/control';
 import { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
-import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import type {
+  ControlDriverInstance,
+  MigrationRunnerResult,
+} from '@prisma-next/framework-components/control';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { SqlQueryError } from '@prisma-next/sql-errors';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import { readExistingEnumValues } from './enum-planning';
+import { createResolveExistingEnumValues } from './enum-planning';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,
@@ -33,19 +36,11 @@ import {
   type SqlStatement,
 } from './statement-builders';
 
-interface RunnerConfig {
-  readonly defaultSchema: string;
-}
-
 interface ApplyPlanSuccessValue {
   readonly operationsExecuted: number;
   readonly executedOperations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[];
 }
 
-const DEFAULT_CONFIG: RunnerConfig = {
-  defaultSchema: 'public',
-};
-
 const LOCK_DOMAIN = 'prisma_next.contract.marker';
 
 /**
@@ -58,13 +53,10 @@ function cloneAndFreezeRecord<T extends Record<string, unknown>>(value: T): T {
     if (val === null || val === undefined) {
       cloned[key] = val;
     } else if (Array.isArray(val)) {
-      // Clone array (shallow clone of array elements)
       cloned[key] = Object.freeze([...val]);
     } else if (typeof val === 'object') {
-      // Recursively clone nested objects
       cloned[key] = cloneAndFreezeRecord(val as Record<string, unknown>);
     } else {
-      // Primitives are copied as-is
       cloned[key] = val;
     }
   }
@@ -73,61 +65,27 @@ function cloneAndFreezeRecord<T extends Record<string, unknown>>(value: T): T {
 
 export function createPostgresMigrationRunner(
   family: SqlControlFamilyInstance,
-  config: Partial<RunnerConfig> = {},
 ): SqlMigrationRunner<PostgresPlanTargetDetails> {
-  return new PostgresMigrationRunner(family, { ...DEFAULT_CONFIG, ...config });
+  return new PostgresMigrationRunner(family);
 }
 
 class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDetails> {
-  constructor(
-    private readonly family: SqlControlFamilyInstance,
-    private readonly config: RunnerConfig,
-  ) {}
-
-  async execute(
-    options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
-  ): Promise<SqlMigrationRunnerResult> {
-    const driver = options.driver;
-
-    // Static checks fail fast before any transaction work — no point
-    // burning a BEGIN/ROLLBACK round-trip on a destination-contract
-    // mismatch the caller can fix locally.
-    const destinationCheck = this.ensurePlanMatchesDestinationContract(
-      options.plan.destination,
-      options.destinationContract,
-    );
-    if (!destinationCheck.ok) return destinationCheck;
-
-    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
-    if (!policyCheck.ok) return policyCheck;
-
-    await this.beginTransaction(driver);
-    let committed = false;
-    try {
-      const result = await this.executeOnConnection(options);
-      if (!result.ok) {
-        return result;
-      }
-      await this.commitTransaction(driver);
-      committed = true;
-      return result;
-    } finally {
-      if (!committed) {
-        await this.rollbackTransaction(driver);
-      }
-    }
-  }
+  constructor(private readonly family: SqlControlFamilyInstance) {}
 
   /**
    * Body of the migration runner without transaction management. The
-   * caller (single-space `execute(...)` above, or the multi-space
-   * outer-tx orchestrator at the SQL family level) owns the
+   * caller ({@link PostgresMigrationRunner.execute}) owns the
    * `BEGIN`/`COMMIT`/`ROLLBACK` lifecycle.
    */
   async executeOnConnection(
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
   ): Promise<SqlMigrationRunnerResult> {
-    const schema = options.schemaName ?? this.config.defaultSchema;
+    const schema =
+      options.schemaName ??
+      Object.keys(options.destinationContract.storage.namespaces).find(
+        (id) => id !== UNBOUND_NAMESPACE_ID,
+      ) ??
+      UNBOUND_NAMESPACE_ID;
     const driver = options.driver;
     if (options.space !== undefined && options.space !== options.plan.spaceId) {
       throw new Error(
@@ -188,8 +146,9 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         frameworkComponents: options.frameworkComponents,
         normalizeDefault: parsePostgresDefault,
         normalizeNativeType: normalizeSchemaNativeType,
-        resolveExistingEnumValues: (schema, enumType) =>
-          readExistingEnumValues(schema, enumType.nativeType),
+        resolveExistingEnumValues: createResolveExistingEnumValues(
+          options.destinationContract.storage,
+        ),
       });
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
@@ -216,12 +175,12 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     });
   }
 
-  async executeAcrossSpaces(options: {
+  async execute(options: {
     readonly driver: ControlDriverInstance<'sql', string>;
     readonly perSpaceOptions: ReadonlyArray<
       SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>
     >;
-  }): Promise<MultiSpaceRunnerResult> {
+  }): Promise<MigrationRunnerResult> {
     const driver = options.driver;
     const perSpaceOptions = options.perSpaceOptions;
 

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

@@ -56,7 +56,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.

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

@@ -117,10 +117,10 @@ 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.

package/src/core/postgres-schema.ts

@@ -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"}