@prisma-next/target-postgres 0.8.0 → 0.9.0-dev.1

package/dist/descriptor-meta-DFUCClk_.mjs

@@ -0,0 +1,124 @@
+import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
+import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
+//#region src/core/authoring.ts
+const postgresAuthoringTypes = {};
+/**
+* Entity type contributions surface as top-level helpers on the
+* composed-helpers shape (e.g. `helpers.enum({...})`), flattened
+* alongside the built-in `model` / `rel` helpers. Pack contributions
+* still ship via the contribution data structure
+* `authoring.entityTypes.<name>`; the composed-helpers template
+* performs the rename in the type system.
+*
+* `enum` is the first real consumer of the entities-namespace mechanism:
+* the factory constructs a `PostgresEnumType` IR-class instance from
+* the user-supplied input. Both authoring runtimes (TS DSL and PSL)
+* dispatch through this single contribution — PSL `enum Status { … }`
+* declarations are lowered by the interpreter into a factory call
+* with the parsed name + value list; TS DSL `helpers.enum({...})`
+* resolves through the same path. Removing this contribution makes
+* both surfaces fail with a "no entity helper named `enum`" type
+* error at the contract-definition site.
+*/
+/**
+* The factory constructs a `PostgresEnumType` instance natively — the
+* `SqlStorage.types` slot accepts polymorphic IR (the framework
+* `StorageType` alphabet), so no cast is needed at the contribution
+* surface. The declared return type is the structural
+* `PostgresEnumStorageEntry` so the inferred contract type stays
+* portable (it names a type exported from
+* `@prisma-next/sql-contract/types`, a public surface every consumer
+* already imports). Sharpening the inferred contract type to surface
+* enum-specific narrowing through `EntityHelperFunction` is a
+* separable refinement and lives outside this PR.
+*/
+const postgresAuthoringEntityTypes = { enum: {
+	kind: "entity",
+	discriminator: "postgres-enum",
+	output: { factory: (input) => new PostgresEnumType(input) }
+} };
+const postgresTargetDescriptorMeta = {
+	kind: "target",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {},
+	authoring: {
+		type: postgresAuthoringTypes,
+		field: {
+			text: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/text@1",
+					nativeType: "text"
+				}
+			},
+			int: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/int4@1",
+					nativeType: "int4"
+				}
+			},
+			bigint: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/int8@1",
+					nativeType: "int8"
+				}
+			},
+			float: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/float8@1",
+					nativeType: "float8"
+				}
+			},
+			decimal: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/numeric@1",
+					nativeType: "numeric"
+				}
+			},
+			boolean: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/bool@1",
+					nativeType: "bool"
+				}
+			},
+			json: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/jsonb@1",
+					nativeType: "jsonb"
+				}
+			},
+			bytes: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/bytea@1",
+					nativeType: "bytea"
+				}
+			},
+			dateTime: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/timestamptz@1",
+					nativeType: "timestamptz"
+				}
+			},
+			temporal: temporalAuthoringPresets({
+				codecId: "pg/timestamptz@1",
+				nativeType: "timestamptz"
+			})
+		},
+		entityTypes: postgresAuthoringEntityTypes
+	}
+};
+//#endregion
+export { postgresAuthoringEntityTypes as n, postgresTargetDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-DFUCClk_.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DFUCClk_.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 { 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    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":";;;AASA,MAAa,yBAAyB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCxC,MAAa,+BAA+B,EAC1C,MAAM;CACJ,MAAM;CACN,eAAe;CACf,QAAQ,EACN,UAAU,UACR,IAAI,iBAAiB,MAAM,EAC9B;CACF,EACF;AC7BD,MAAa,+BAET;CAfF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CAChB,WAAW;EACT,MAAM;EACN,OAAO;GD6CT,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;GC/GO;EACP,aAAa;EACd;CAKC"}

package/dist/enum-planning-Bqp96iIw.mjs

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/enum-planning.d.mts

@@ -0,0 +1,48 @@
+import { t as PostgresEnumType } from "./postgres-enum-type-CrKq8au9.mjs";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/migrations/enum-planning.d.ts
+/**
+ * Categorisation of how an existing enum type's values relate to the
+ * desired set in the contract.
+ */
+type EnumDiff = {
+  readonly kind: 'unchanged';
+} | {
+  readonly kind: 'add_values';
+  readonly values: readonly string[];
+} | {
+  readonly kind: 'rebuild';
+  readonly removedValues: readonly string[];
+};
+/**
+ * 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.
+ */
+declare function readExistingEnumValues(schema: SqlSchemaIR, nativeType: string): readonly string[] | null;
+/**
+ * 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.
+ */
+declare function determineEnumDiff(existing: readonly string[], desired: readonly string[]): EnumDiff;
+/**
+ * Convenience accessor — returns the enum's desired values from a
+ * `PostgresEnumType` IR instance.
+ */
+declare function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[];
+//#endregion
+export { type EnumDiff, determineEnumDiff, getDesiredEnumValues, readExistingEnumValues };
+//# sourceMappingURL=enum-planning.d.mts.map

package/dist/enum-planning.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-planning.d.mts","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"mappings":";;;;;;;;KAeY,QAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA6B,MAAA;AAAA;EAAA,SAC7B,IAAA;EAAA,SAA0B,aAAA;AAAA;;;;;AAiDzC;;;;;;;;;iBAlCgB,sBAAA,CACd,MAAA,EAAQ,WAAA,EACR,UAAA;;;;;;;;;iBAgCc,iBAAA,CACd,QAAA,qBACA,OAAA,sBACC,QAAA;;;;;iBAoBa,oBAAA,CAAqB,YAAA,EAAc,gBAAA"}

package/dist/enum-planning.mjs

@@ -0,0 +1,2 @@
+import { n as getDesiredEnumValues, r as readExistingEnumValues, t as determineEnumDiff } from "./enum-planning-Bqp96iIw.mjs";
+export { determineEnumDiff, getDesiredEnumValues, readExistingEnumValues };

package/dist/{errors-Chm2bKcS.mjs → errors-BiOloWUh.mjs}

@@ -30,4 +30,4 @@ function errorPostgresMigrationStackMissing() {
 //#endregion
 export { errorPostgresMigrationStackMissing as t };
 
-//# sourceMappingURL=errors-Chm2bKcS.mjs.map
+//# sourceMappingURL=errors-BiOloWUh.mjs.map

package/dist/{errors-Chm2bKcS.mjs.map → errors-BiOloWUh.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"errors-Chm2bKcS.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,EAAE;EACT,CACF"}
+{"version":3,"file":"errors-BiOloWUh.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,EAAE;EACT,CACF"}

package/dist/errors.mjs

@@ -1,2 +1,2 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-Chm2bKcS.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-BiOloWUh.mjs";
 export { errorPostgresMigrationStackMissing };

package/dist/{issue-planner-DQ6WJkad.mjs → issue-planner-BhWVYyE1.mjs}

@@ -1,10 +1,13 @@
-import { i as quoteIdentifier } from "./sql-utils-CggjWNij.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-DwZvGlV4.mjs";
-import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-DeaFxa8_.mjs";
-import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-CLB7Umhh.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-DTx0gePL.mjs";
-import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-B1ags8ys.mjs";
+import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
+import { r as readExistingEnumValues, t as determineEnumDiff } from "./enum-planning-Bqp96iIw.mjs";
+import { i as quoteIdentifier } from "./sql-utils-BewXAnsG.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-Cd016Ycs.mjs";
+import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-DerP9BoT.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-5QIyhBUF.mjs";
+import { n as resolveIdentityValue } from "./planner-identity-values-BUYNOCwb.mjs";
+import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup--u9whY_Y.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/migrations/planner-target-details.ts
@@ -186,8 +189,9 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 function enumRebuildCallRecipe(typeName, ctx) {
 	const toType = ctx.toContract.storage.types?.[typeName];
 	if (!toType) return [];
+	const isEnum = isPostgresEnumStorageEntry(toType);
 	const nativeType = toType.nativeType;
-	const desiredValues = toType.typeParams["values"] ?? [];
+	const desiredValues = isEnum ? toType.values : toType.typeParams["values"] ?? [];
 	const tempName = `${nativeType}${REBUILD_SUFFIX}`;
 	const columnRefs = [];
 	for (const [tableName, table] of Object.entries(ctx.toContract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName) columnRefs.push({
@@ -209,38 +213,92 @@ function enumRebuildCallRecipe(typeName, ctx) {
 		new RenameTypeCall(ctx.schemaName, tempName, nativeType)
 	];
 }
-const enumChangeCallStrategy = (issues, ctx) => {
-	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
-	const matched = [];
+/**
+* Single planner strategy for `PostgresEnumType` instances. Walks
+* `toContract.storage.types` directly (no codec-hook dispatch) and
+* resolves existing values via `readExistingEnumValues`, the same
+* Postgres bridging adapter the verifier uses.
+*
+* Per-enum dispatch:
+*
+* - No existing type → `CreateEnumTypeCall` with the contract's desired
+*   values.
+* - Diff is `unchanged` → no calls emitted (consumes the matching
+*   `enum_values_changed` issue if present).
+* - Diff is `add_values` → `AddEnumValuesCall` with the new labels.
+* - Diff is `rebuild` → the create-temp / migrate-columns /
+*   drop-original / rename rebuild recipe. When
+*   `policy.allowedOperationClasses` includes `'data'` and the rebuild
+*   removes labels (`removedValues.length > 0`), prepend a
+*   `DataTransformCall` placeholder so the user can author the value
+*   remap before the destructive recipe runs. Without `'data'` in the
+*   policy (`db update` / `db init`), the rebuild's PG `USING ::text`
+*   cast surfaces any value-removal data loss as a runtime error rather
+*   than silent loss.
+*
+* Returns `recipe: true` only when a rebuild recipe was emitted (its
+* `createEnumType(temp) → alterColumnType → dropEnumType(orig) →
+* renameType` sequence mixes `dep`-class and `alter`-class calls that
+* would mis-order if the planner hoisted them into its DDL sequencing
+* buckets). For the create-only and add-values paths the strategy
+* returns `recipe: false` so the planner hoists `CreateEnumTypeCall`
+* into the `dep` bucket — i.e. `CREATE TYPE` runs before any
+* `CreateTableCall` that references the new enum.
+*/
+const nativeEnumPlanCallStrategy = (issues, ctx) => {
+	const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage.types);
+	if (enumTypes.size === 0) return { kind: "no_match" };
+	const dataAllowed = ctx.policy.allowedOperationClasses.includes("data");
 	const calls = [];
-	for (const issue of issues) {
-		if (issue.kind !== "enum_values_changed") continue;
-		matched.push(issue);
-		if (issue.removedValues.length > 0) calls.push(new DataTransformCall(`migrate-${issue.typeName}-values`, `migrate-${issue.typeName}-values:check`, `migrate-${issue.typeName}-values:run`), ...enumRebuildCallRecipe(issue.typeName, ctx));
-		else if (issue.addedValues.length === 0) calls.push(...enumRebuildCallRecipe(issue.typeName, ctx));
-		else {
-			const toType = ctx.toContract.storage.types?.[issue.typeName];
-			if (toType) calls.push(new AddEnumValuesCall(ctx.schemaName, issue.typeName, toType.nativeType, issue.addedValues));
+	const handledTypeNames = /* @__PURE__ */ new Set();
+	const introducedTypeNames = /* @__PURE__ */ new Set();
+	const rebuiltTypeNames = /* @__PURE__ */ new Set();
+	let emittedRebuildRecipe = false;
+	for (const [typeName, enumType] of enumTypes) {
+		const desired = enumType.values;
+		const existing = readExistingEnumValues(ctx.schema, enumType.nativeType);
+		if (!existing) {
+			calls.push(new CreateEnumTypeCall(ctx.schemaName, typeName, desired, enumType.nativeType));
+			handledTypeNames.add(typeName);
+			introducedTypeNames.add(typeName);
+			continue;
 		}
+		const diff = determineEnumDiff(existing, desired);
+		if (diff.kind === "unchanged") {
+			handledTypeNames.add(typeName);
+			continue;
+		}
+		if (diff.kind === "add_values") {
+			calls.push(new AddEnumValuesCall(ctx.schemaName, typeName, enumType.nativeType, diff.values));
+			handledTypeNames.add(typeName);
+			continue;
+		}
+		if (dataAllowed && diff.removedValues.length > 0) calls.push(new DataTransformCall(`migrate-${typeName}-values`, `migrate-${typeName}-values:check`, `migrate-${typeName}-values:run`));
+		calls.push(...enumRebuildCallRecipe(typeName, ctx));
+		emittedRebuildRecipe = true;
+		handledTypeNames.add(typeName);
+		rebuiltTypeNames.add(typeName);
 	}
-	if (matched.length === 0) return { kind: "no_match" };
+	if (introducedTypeNames.size > 0 && rebuiltTypeNames.size > 0) 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.`);
+	const remaining = issues.filter((issue) => !((issue.kind === "type_missing" || issue.kind === "enum_values_changed") && issue.typeName && handledTypeNames.has(issue.typeName)));
+	if (calls.length === 0 && remaining.length === issues.length) return { kind: "no_match" };
 	return {
 		kind: "match",
-		issues: issues.filter((i) => !matched.includes(i)),
+		issues: remaining,
 		calls,
-		recipe: true
+		recipe: emittedRebuildRecipe
 	};
 };
+function collectPostgresEnumTypes(storageTypes) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [name, instance] of Object.entries(storageTypes ?? {}).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(name, instance);
+	return result;
+}
 /**
-* Dispatches storage types through their codec's `planTypeOperations` hook.
-* Replaces the walk-schema `buildStorageTypeOperations` path: the hook is
-* the authoritative source for codec-driven DDL (enum create/rebuild/add-
-* value, custom type creation, etc.).
-*
-* Runs after `enumChangeCallStrategy` so the structured enum path (value
-* add, rebuild recipe) gets first pick at `enum_values_changed` issues;
-* this strategy then handles remaining `type_missing` / `enum_values_changed`
-* issues for types whose hook produced at least one op.
+* Dispatches non-enum codec-typed storage types through their codec's
+* `planTypeOperations` hook (the authoritative source for codec-driven DDL
+* such as custom type creation). Enum dispatch lives in
+* `nativeEnumPlanCallStrategy` and no longer relies on codec hooks.
 */
 const storageTypePlanCallStrategy = (issues, ctx) => {
 	const storageTypes = ctx.toContract.storage.types ?? {};
@@ -248,11 +306,13 @@ const storageTypePlanCallStrategy = (issues, ctx) => {
 	const calls = [];
 	const handledTypeNames = /* @__PURE__ */ new Set();
 	for (const [typeName, typeInstance] of Object.entries(storageTypes).sort(([a], [b]) => a.localeCompare(b))) {
-		const hook = ctx.codecHooks.get(typeInstance.codecId);
+		if (isPostgresEnumStorageEntry(typeInstance)) continue;
+		const codecInstance = typeInstance;
+		const hook = ctx.codecHooks.get(codecInstance.codecId);
 		if (!hook?.planTypeOperations) continue;
 		const planResult = hook.planTypeOperations({
 			typeName,
-			typeInstance,
+			typeInstance: codecInstance,
 			contract: ctx.toContract,
 			schema: ctx.schema,
 			schemaName: ctx.schemaName,
@@ -397,25 +457,33 @@ function canUseSharedTemporaryDefaultStrategy(options) {
 * `policy.allowedOperationClasses`:
 *
 * - When `'data'` is allowed (`migration plan`), the data-safe strategies
-*   (`enumChangeCallStrategy`, `notNullBackfillCallStrategy`,
-*   `typeChangeCallStrategy`, `nullableTighteningCallStrategy`) consume their
-*   matching issues and emit `DataTransformCall` placeholders or recipe ops.
+*   (`notNullBackfillCallStrategy`, `typeChangeCallStrategy`,
+*   `nullableTighteningCallStrategy`) and the enum walk
+*   (`nativeEnumPlanCallStrategy`) consume their matching issues and emit
+*   `DataTransformCall` placeholders or recipe ops.
 *
-* - When `'data'` is not allowed (`db update` / `db init`), each data-safe
-*   strategy short-circuits to `no_match`, leaving the issue for the
-*   downstream walk-schema strategies (`storageTypePlanCallStrategy`,
-*   `notNullAddColumnCallStrategy`) or the `mapIssueToCall` default to handle
-*   with direct DDL.
+* - When `'data'` is not allowed (`db update` / `db init`), the
+*   placeholder-emitting strategies short-circuit to `no_match`, leaving
+*   the issue for the downstream walk-schema strategies
+*   (`storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) or the
+*   `mapIssueToCall` default to handle with direct DDL.
+*   `nativeEnumPlanCallStrategy` runs in both modes; under `db update` /
+*   `db init` it emits the rebuild recipe without the data-transform
+*   placeholder so value-removal data loss surfaces as a runtime cast
+*   error rather than silent loss.
 *
-* Order matters: data-safe strategies must run before the walk-schema
-* strategies on overlapping issue kinds (e.g. `enum_values_changed`,
-* `missing_column` for NOT NULL) so they take priority when active.
+* Enum dispatch is unified into a single strategy: the
+* `nativeEnumPlanCallStrategy` decides per-emission whether to emit a
+* rebuild recipe (`recipe: true`, contiguous slot) or hoist the call
+* into the `dep` bucket (`recipe: false`, so a brand-new
+* `CreateEnumTypeCall` runs before any `CreateTableCall` referencing
+* it). Codec-typed entries continue through `storageTypePlanCallStrategy`.
 */
 const postgresPlannerStrategies = [
-	enumChangeCallStrategy,
 	notNullBackfillCallStrategy,
 	typeChangeCallStrategy,
 	nullableTighteningCallStrategy,
+	nativeEnumPlanCallStrategy,
 	storageTypePlanCallStrategy,
 	notNullAddColumnCallStrategy
 ];
@@ -637,10 +705,7 @@ function mapIssueToCall(issue, ctx) {
 			if (!issue.typeName) return notOk(issueConflict("unsupportedOperation", "Type missing issue has no typeName"));
 			const typeInstance = ctx.toContract.storage.types?.[issue.typeName];
 			if (!typeInstance) return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" reported missing but not found in destination contract`));
-			if (typeInstance.codecId.startsWith("pg/enum")) {
-				const values = typeInstance.typeParams["values"] ?? [];
-				return ok([new CreateEnumTypeCall(schemaName, typeInstance.nativeType, values)]);
-			}
+			if (typeInstance instanceof PostgresEnumType) return ok([new CreateEnumTypeCall(schemaName, issue.typeName, typeInstance.values, typeInstance.nativeType)]);
 			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only enum types are supported`));
 		}
 		case "type_values_mismatch": return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName ?? "unknown"}" values differ — type alteration not yet supported`));
@@ -809,4 +874,4 @@ function planIssues(options) {
 //#endregion
 export { postgresPlannerStrategies as n, planIssues as t };
 
-//# sourceMappingURL=issue-planner-DQ6WJkad.mjs.map
+//# sourceMappingURL=issue-planner-BhWVYyE1.mjs.map