@prisma-next/target-postgres 0.11.0-dev.7 → 0.11.0-dev.70

package/src/core/migrations/planner-strategies.ts

@@ -37,7 +37,11 @@ import {
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { PostgresEnumType } from '../postgres-enum-type';
 import { isPostgresSchema } from '../postgres-schema';
-import { determineEnumDiff, readExistingEnumValues } from './enum-planning';
+import {
+  determineEnumDiff,
+  readExistingEnumValues,
+  resolveDdlSchemaForNamespaceStorage,
+} from './enum-planning';
 import {
   AddColumnCall,
   AddEnumValuesCall,
@@ -123,21 +127,57 @@ export function resolveDdlSchemaForNamespace(ctx: StrategyContext, namespaceId:
   return namespaceId;
 }
 
+/** Default Postgres enum landing namespace — where contract-level (`types:`)
+ * enums are placed by the authoring builder when no explicit namespace is
+ * given. Mirrors `POSTGRES_ENUM_NAMESPACE_ID` in the contract-ts builder. */
+const DEFAULT_ENUM_NAMESPACE_ID = 'public';
+
+function namespaceHasEnum(storage: SqlStorage, namespaceId: string, typeName: string): boolean {
+  const ns = storage.namespaces[namespaceId];
+  if (!ns || !('enum' in ns) || ns.enum == null) return false;
+  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName] !== undefined;
+}
+
 /**
- * Finds a type entry by name across all namespace type registries.
- * Namespace types (e.g. Postgres enums) live under
- * `storage.namespaces[nsId].enum`, not under `storage.types`.
+ * Resolves which namespace's enum a column's bare `typeRef` binds to.
+ *
+ * Columns carry a bare (non-namespace-qualified) `typeRef`; the enum it names
+ * may live in a different namespace than the column's own (the authoring
+ * builder places contract-level `types:` enums in the default `public`
+ * namespace while a model's table may sit in the unbound namespace). The
+ * binding rule: an enum declared in the column's *own* namespace shadows
+ * everything; otherwise the column references the ambient enum — the sole
+ * namespace that defines `typeName`, preferring the default `public`
+ * namespace when several do. Returns `undefined` when no namespace defines it.
+ */
+function resolveColumnEnumNamespace(
+  storage: SqlStorage,
+  columnNamespaceId: string,
+  typeName: string,
+): string | undefined {
+  if (namespaceHasEnum(storage, columnNamespaceId, typeName)) return columnNamespaceId;
+  const owners = Object.keys(storage.namespaces).filter((nsId) =>
+    namespaceHasEnum(storage, nsId, typeName),
+  );
+  if (owners.length === 1) return owners[0];
+  if (owners.includes(DEFAULT_ENUM_NAMESPACE_ID)) return DEFAULT_ENUM_NAMESPACE_ID;
+  return owners[0];
+}
+
+/**
+ * Finds a type entry by explicit namespace coordinate. Namespace types (e.g.
+ * Postgres enums) live under `storage.namespaces[nsId].enum`. Returns the
+ * entry from the named namespace only — never scans other namespaces, so two
+ * namespaces that hold an enum with the same name resolve independently.
  */
 function locateNamespaceType(
   storage: SqlStorage,
+  namespaceId: string,
   typeName: string,
 ): PostgresEnumStorageEntry | undefined {
-  for (const ns of Object.values(storage.namespaces)) {
-    if (!('enum' in ns) || ns.enum == null) continue;
-    const entry = (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName];
-    if (entry !== undefined) return entry;
-  }
-  return undefined;
+  const ns = storage.namespaces[namespaceId];
+  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
+  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName];
 }
 
 // ============================================================================
@@ -369,10 +409,11 @@ export const nullableTighteningCallStrategy: CallMigrationStrategy = (issues, ct
 };
 
 function enumRebuildCallRecipe(
+  namespaceId: string,
   typeName: string,
   ctx: StrategyContext,
 ): readonly PostgresOpFactoryCall[] {
-  const toType = locateNamespaceType(ctx.toContract.storage, typeName);
+  const toType = locateNamespaceType(ctx.toContract.storage, namespaceId, typeName);
   if (!toType) return [];
   const isEnum = isPostgresEnumStorageEntry(toType);
   const nativeType = toType.nativeType;
@@ -380,13 +421,28 @@ function enumRebuildCallRecipe(
     ? toType.values
     : (((toType as StorageTypeInstance).typeParams['values'] ?? []) as readonly string[]);
   const tempName = `${nativeType}${REBUILD_SUFFIX}`;
+  // Type DDL targets the enum's real schema — the unbound coordinate resolves
+  // to the introspected `current_schema()`, never the `__unbound__` sentinel.
+  const ddlSchema = resolveDdlSchemaForNamespaceStorage(
+    ctx.toContract.storage,
+    namespaceId,
+    ctx.schema,
+  );
 
+  // Migrate every column whose `typeRef` binds to *this* enum. The column's
+  // bare `typeRef` resolves to an enum namespace (own-namespace shadows;
+  // otherwise the ambient/default `public` enum), so a column in the unbound
+  // namespace correctly binds to a `public`-namespace enum, while two
+  // same-named enums in distinct namespaces keep their columns disjoint.
   const columnRefs: { namespaceId: string; table: string; column: string }[] = [];
   for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
     for (const [tableName, tableNode] of Object.entries(ns.tables)) {
       const table = tableNode as StorageTable;
       for (const [columnName, column] of Object.entries(table.columns)) {
-        if (column.typeRef === typeName) {
+        if (
+          column.typeRef === typeName &&
+          resolveColumnEnumNamespace(ctx.toContract.storage, nsId, typeName) === namespaceId
+        ) {
           columnRefs.push({ namespaceId: nsId, table: tableName, column: columnName });
         }
       }
@@ -394,7 +450,7 @@ function enumRebuildCallRecipe(
   }
 
   return [
-    new CreateEnumTypeCall(ctx.schemaName, tempName, desiredValues),
+    new CreateEnumTypeCall(ddlSchema, tempName, desiredValues),
     ...columnRefs.map((ref) => {
       const using = `${ref.column}::text::${tempName}`;
       return new AlterColumnTypeCall(
@@ -409,8 +465,8 @@ function enumRebuildCallRecipe(
         },
       );
     }),
-    new DropEnumTypeCall(ctx.schemaName, nativeType),
-    new RenameTypeCall(ctx.schemaName, tempName, nativeType),
+    new DropEnumTypeCall(ddlSchema, nativeType),
+    new RenameTypeCall(ddlSchema, tempName, nativeType),
   ];
 }
 
@@ -450,6 +506,18 @@ function enumRebuildCallRecipe(
  * into the `dep` bucket — i.e. `CREATE TYPE` runs before any
  * `CreateTableCall` that references the new enum.
  */
+/**
+ * Separator character for compound enum map keys (`namespaceId\u0000typeName`).
+ * NUL (`\u0000`) is invalid in both Postgres identifiers and TypeScript symbol
+ * names so it cannot appear in either component — unambiguous separator.
+ */
+const COMPOUND_KEY_SEP = '\u0000';
+
+/** Builds the compound map key for a namespace-qualified enum entry. */
+function enumCompoundKey(namespaceId: string, typeName: string): string {
+  return `${namespaceId}${COMPOUND_KEY_SEP}${typeName}`;
+}
+
 export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) => {
   const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage);
   if (enumTypes.size === 0) return { kind: 'no_match' };
@@ -457,28 +525,42 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
   const dataAllowed = ctx.policy.allowedOperationClasses.includes('data');
 
   const calls: PostgresOpFactoryCall[] = [];
-  const handledTypeNames = new Set<string>();
-  const introducedTypeNames = new Set<string>();
-  const rebuiltTypeNames = new Set<string>();
+  const handledKeys = new Set<string>();
+  const introducedKeys = new Set<string>();
+  const rebuiltKeys = new Set<string>();
   let emittedRebuildRecipe = false;
 
-  for (const [typeName, enumType] of enumTypes) {
+  for (const [key, enumType] of enumTypes) {
+    const sepIdx = key.indexOf(COMPOUND_KEY_SEP);
+    const enumNamespaceId = key.slice(0, sepIdx);
+    const typeName = key.slice(sepIdx + 1);
+
     const desired = enumType.values;
-    const existing = readExistingEnumValues(ctx.schema, enumType.nativeType);
+    // The enum's live schema: for the unbound coordinate this resolves to the
+    // introspected `current_schema()` (e.g. `public`), never the `__unbound__`
+    // DDL-emit sentinel — so both the existing-values lookup key and the
+    // emitted `CREATE TYPE` / `ALTER TYPE` target the real schema the type
+    // lives in. Named namespaces resolve to their own DDL schema.
+    const ddlSchema = resolveDdlSchemaForNamespaceStorage(
+      ctx.toContract.storage,
+      enumNamespaceId,
+      ctx.schema,
+    );
+    const existing = readExistingEnumValues(ctx.schema, ddlSchema, enumType.nativeType);
     if (!existing) {
-      calls.push(new CreateEnumTypeCall(ctx.schemaName, typeName, desired, enumType.nativeType));
-      handledTypeNames.add(typeName);
-      introducedTypeNames.add(typeName);
+      calls.push(new CreateEnumTypeCall(ddlSchema, typeName, desired, enumType.nativeType));
+      handledKeys.add(key);
+      introducedKeys.add(key);
       continue;
     }
     const diff = determineEnumDiff(existing, desired);
     if (diff.kind === 'unchanged') {
-      handledTypeNames.add(typeName);
+      handledKeys.add(key);
       continue;
     }
     if (diff.kind === 'add_values') {
-      calls.push(new AddEnumValuesCall(ctx.schemaName, typeName, enumType.nativeType, diff.values));
-      handledTypeNames.add(typeName);
+      calls.push(new AddEnumValuesCall(ddlSchema, typeName, enumType.nativeType, diff.values));
+      handledKeys.add(key);
       continue;
     }
     if (dataAllowed && diff.removedValues.length > 0) {
@@ -490,10 +572,10 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
         ),
       );
     }
-    calls.push(...enumRebuildCallRecipe(typeName, ctx));
+    calls.push(...enumRebuildCallRecipe(enumNamespaceId, typeName, ctx));
     emittedRebuildRecipe = true;
-    handledTypeNames.add(typeName);
-    rebuiltTypeNames.add(typeName);
+    handledKeys.add(key);
+    rebuiltKeys.add(key);
   }
 
   // The strategy emits a single `recipe` flag for the entire pass,
@@ -505,9 +587,17 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
   // enum would fail at runtime with a confusing `type "X" does not
   // exist` error. Surface the unrepresentable case here as a
   // planner-time error so the failure mode is loud, not silent.
-  if (introducedTypeNames.size > 0 && rebuiltTypeNames.size > 0) {
+  if (introducedKeys.size > 0 && rebuiltKeys.size > 0) {
+    const introducedDisplay = [...introducedKeys]
+      .sort()
+      .map((k) => k.replace(COMPOUND_KEY_SEP, '.'))
+      .join(', ');
+    const rebuiltDisplay = [...rebuiltKeys]
+      .sort()
+      .map((k) => k.replace(COMPOUND_KEY_SEP, '.'))
+      .join(', ');
     throw new Error(
-      `nativeEnumPlanCallStrategy: cannot emit both a brand-new enum and a rebuild on a different enum in the same plan; the single recipe flag cannot route them to different buckets. Introduced: [${[...introducedTypeNames].sort().join(', ')}]; rebuilt: [${[...rebuiltTypeNames].sort().join(', ')}]. Split the strategy or grow the \`match\` return type before this case lands.`,
+      `nativeEnumPlanCallStrategy: cannot emit both a brand-new enum and a rebuild on a different enum in the same plan; the single recipe flag cannot route them to different buckets. Introduced: [${introducedDisplay}]; rebuilt: [${rebuiltDisplay}]. Split the strategy or grow the \`match\` return type before this case lands.`,
     );
   }
 
@@ -516,7 +606,7 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
       !(
         (issue.kind === 'type_missing' || issue.kind === 'enum_values_changed') &&
         issue.typeName &&
-        handledTypeNames.has(issue.typeName)
+        handledKeys.has(enumCompoundKey(resolveNamespaceIdForIssue(issue), issue.typeName))
       ),
   );
 
@@ -538,14 +628,22 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
   return { kind: 'match', issues: remaining, calls, recipe: emittedRebuildRecipe };
 };
 
+/**
+ * Collects every `PostgresEnumType` instance across all declared namespaces,
+ * returning a compound-keyed map (`${namespaceId}\u0000${typeName}`). Two
+ * namespaces that declare an enum with the same name produce two distinct
+ * entries — no name collision, no last-write-wins.
+ *
+ * Entries within each namespace are sorted by name for deterministic ordering.
+ */
 function collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, PostgresEnumType> {
   const result = new Map<string, PostgresEnumType>();
-  for (const ns of Object.values(storage.namespaces)) {
+  for (const [nsId, ns] of Object.entries(storage.namespaces)) {
     if (!('enum' in ns) || ns.enum == null) continue;
     const nsEnums = ns.enum as Record<string, unknown>;
     for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) {
       if (instance instanceof PostgresEnumType) {
-        result.set(name, instance);
+        result.set(enumCompoundKey(nsId, name), instance);
       }
     }
   }

package/src/core/migrations/planner.ts

@@ -19,7 +19,7 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import { readExistingEnumValues } from './enum-planning';
+import { createResolveExistingEnumValues } from './enum-planning';
 import { planIssues } from './issue-planner';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
 import { postgresPlannerStrategies } from './planner-strategies';
@@ -219,8 +219,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       frameworkComponents: options.frameworkComponents,
       normalizeDefault: parsePostgresDefault,
       normalizeNativeType: normalizeSchemaNativeType,
-      resolveExistingEnumValues: (schema, enumType) =>
-        readExistingEnumValues(schema, enumType.nativeType),
+      resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),
     };
     const verifyResult = verifySqlSchema(verifyOptions);
     // Schema presence is a Postgres-specific concern (no equivalent in

package/src/core/migrations/render-typescript.ts

@@ -11,12 +11,11 @@
 
 import type { OpFactoryCall } from '@prisma-next/framework-components/control';
 import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
-import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';
+import { type ImportRequirement, renderImports } from '@prisma-next/ts-render';
 
 export interface RenderMigrationMeta {
   readonly from: string | null;
   readonly to: string;
-  readonly labels?: readonly string[];
 }
 
 /**
@@ -83,9 +82,6 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
   lines.push('    return {');
   lines.push(`      from: ${JSON.stringify(meta.from)},`);
   lines.push(`      to: ${JSON.stringify(meta.to)},`);
-  if (meta.labels && meta.labels.length > 0) {
-    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
-  }
   lines.push('    };');
   lines.push('  }');
   lines.push('');

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,7 +13,10 @@ 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 { SqlQueryError } from '@prisma-next/sql-errors';
 import { ifDefined } from '@prisma-next/utils/defined';
@@ -22,7 +24,7 @@ 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,
@@ -84,44 +86,9 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     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);
-      }
-    }
-  }
-
   /**
    * 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(
@@ -188,8 +155,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 +184,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/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/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/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"}