@prisma-next/target-postgres 0.5.0-dev.44 → 0.5.0-dev.46

package/dist/data-transform-Be_i_DBc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transform-Be_i_DBc.mjs","names":["runClosures: readonly DataTransformClosure[]","precheck: readonly SqlMigrationPlanOperationStep[]","execute: readonly SqlMigrationPlanOperationStep[]","postcheck: readonly SqlMigrationPlanOperationStep[]"],"sources":["../src/core/migrations/operations/data-transform.ts"],"sourcesContent":["/**\n * User-facing `dataTransform` factory for the Postgres migration authoring\n * surface. Invoked directly inside a `migration.ts` file via the\n * `PostgresMigration` instance method (`this.dataTransform(...)`), which\n * supplies the control adapter from the migration's injected stack:\n *\n * ```ts\n * import endContract from './end-contract.json' with { type: 'json' };\n *\n * class M extends Migration {\n *   override get operations() {\n *     return [\n *       this.dataTransform(endContract, 'backfill emails', {\n *         check: () => db.users.select('id').where(({ email }) => email.isNull()).limit(1),\n *         run:   () => db.users.update({ email: '' }).where(({ email }) => email.isNull()),\n *       }),\n *     ];\n *   }\n * }\n * ```\n *\n * The factory accepts lazy closures (`() => SqlQueryPlan | Buildable`),\n * invokes each one, asserts that its `meta.storageHash` matches the\n * `contract` it was handed (→ `PN-MIG-2005` on mismatch), and lowers the\n * plan via the supplied control adapter to a serialized `{sql, params}`\n * payload.\n *\n * The factory then lowers the data transform to the unified migration-op\n * shape `{ precheck, execute, postcheck }`. The user's `check` plan is\n * wrapped twice with opposite truth values:\n *\n * - precheck `SELECT EXISTS (<check>) AS ok` asserts there is work to do\n *   (precheck is short-circuited by the runner's pre-satisfied-skip path\n *   when nothing remains to backfill).\n * - postcheck `SELECT NOT EXISTS (<check>) AS ok` asserts the work is\n *   complete after the run steps execute.\n *\n * The `check` plan is therefore expected to be a **rowset query whose\n * presence of any row signals \"work remains\"** — typically `select('id')\n * .where(<violation predicate>).limit(1)`. Scalar/aggregate shapes\n * (`count(*)`, `bool_and(...)`) do not work under this contract: they\n * always return exactly one row, so `EXISTS` is always true and\n * `NOT EXISTS` is always false. (This is the same row-presence contract\n * the pre-unification runner relied on; the wrapping is just lifting it\n * into SQL.)\n *\n * Each `run` plan becomes an execute step. Because the `Step.params`\n * field threads through `driver.query(sql, params)`, the user's bound\n * values flow through the driver's parameter binder rather than being\n * inlined into the SQL text.\n *\n * The free factory remains usable standalone (tests, ad-hoc tooling,\n * non-class contexts) by passing the adapter explicitly as the fourth\n * argument.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport { errorDataTransformContractMismatch } from '@prisma-next/errors/migration';\nimport type {\n  SqlMigrationPlanOperation,\n  SqlMigrationPlanOperationStep,\n} from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport type { SerializedQueryPlan } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresPlanTargetDetails } from '../planner-target-details';\n\ninterface Buildable<R = unknown> {\n  build(): SqlQueryPlan<R>;\n}\n\n/**\n * A single-closure producer of a SQL query plan. Shared between\n * `check` and each `run` entry.\n */\nexport type DataTransformClosure = () => SqlQueryPlan | Buildable;\n\nexport interface DataTransformOptions {\n  /**\n   * Optional opt-in routing identity. Presence opts the transform into\n   * invariant-aware routing; absence means it is path-dependent and\n   * not referenceable from refs.\n   */\n  readonly invariantId?: string;\n  /**\n   * Optional pre-flight query. `undefined` means \"no check\". When\n   * supplied, the closure must return a **rowset query** whose\n   * presence of any row signals \"violations remain\". Conventional\n   * shape: `db.<table>.select('id').where(<violation>).limit(1)`.\n   * Scalar/aggregate shapes do not satisfy this contract.\n   */\n  readonly check?: DataTransformClosure;\n  /** One or more mutation queries to execute. */\n  readonly run: DataTransformClosure | readonly DataTransformClosure[];\n}\n\nexport function dataTransform<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  name: string,\n  options: DataTransformOptions,\n  adapter: SqlControlAdapter<'postgres'>,\n): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n  const runClosures: readonly DataTransformClosure[] = Array.isArray(options.run)\n    ? options.run\n    : [options.run as DataTransformClosure];\n\n  const checkPlan = options.check ? invokeAndLower(options.check, contract, adapter, name) : null;\n  const runPlans = runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name));\n\n  const precheck: readonly SqlMigrationPlanOperationStep[] = checkPlan\n    ? [\n        {\n          description: `Check ${name} has work to do`,\n          sql: `SELECT EXISTS (${checkPlan.sql}) AS ok`,\n          params: checkPlan.params,\n        },\n      ]\n    : [];\n\n  const execute: readonly SqlMigrationPlanOperationStep[] = runPlans.map((plan) => ({\n    description: `Run ${name}`,\n    sql: plan.sql,\n    params: plan.params,\n  }));\n\n  const postcheck: readonly SqlMigrationPlanOperationStep[] = checkPlan\n    ? [\n        {\n          description: `Verify ${name} resolved all violations`,\n          sql: `SELECT NOT EXISTS (${checkPlan.sql}) AS ok`,\n          params: checkPlan.params,\n        },\n      ]\n    : [];\n\n  return {\n    id: `data_migration.${name}`,\n    label: `Data transform: ${name}`,\n    operationClass: 'data',\n    ...ifDefined('invariantId', options.invariantId),\n    target: { id: 'postgres' },\n    precheck,\n    execute,\n    postcheck,\n  };\n}\n\nfunction invokeAndLower(\n  closure: DataTransformClosure,\n  contract: Contract<SqlStorage>,\n  adapter: SqlControlAdapter<'postgres'>,\n  name: string,\n): SerializedQueryPlan {\n  const result = closure();\n  const plan = isBuildable(result) ? result.build() : result;\n  assertContractMatches(plan, contract, name);\n  const lowered = adapter.lower(plan.ast, { contract });\n  return { sql: lowered.sql, params: lowered.params };\n}\n\nfunction isBuildable(value: unknown): value is Buildable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'build' in value &&\n    typeof (value as { build: unknown }).build === 'function'\n  );\n}\n\nfunction assertContractMatches(\n  plan: SqlQueryPlan,\n  contract: Contract<SqlStorage>,\n  name: string,\n): void {\n  if (plan.meta.storageHash !== contract.storage.storageHash) {\n    throw errorDataTransformContractMismatch({\n      dataTransformName: name,\n      expected: contract.storage.storageHash,\n      actual: plan.meta.storageHash,\n    });\n  }\n}\n"],"mappings":";;;;AAkGA,SAAgB,cACd,UACA,MACA,SACA,SACsD;CACtD,MAAMA,cAA+C,MAAM,QAAQ,QAAQ,IAAI,GAC3E,QAAQ,MACR,CAAC,QAAQ,IAA4B;CAEzC,MAAM,YAAY,QAAQ,QAAQ,eAAe,QAAQ,OAAO,UAAU,SAAS,KAAK,GAAG;CAC3F,MAAM,WAAW,YAAY,KAAK,YAAY,eAAe,SAAS,UAAU,SAAS,KAAK,CAAC;CAE/F,MAAMC,WAAqD,YACvD,CACE;EACE,aAAa,SAAS,KAAK;EAC3B,KAAK,kBAAkB,UAAU,IAAI;EACrC,QAAQ,UAAU;EACnB,CACF,GACD,EAAE;CAEN,MAAMC,UAAoD,SAAS,KAAK,UAAU;EAChF,aAAa,OAAO;EACpB,KAAK,KAAK;EACV,QAAQ,KAAK;EACd,EAAE;CAEH,MAAMC,YAAsD,YACxD,CACE;EACE,aAAa,UAAU,KAAK;EAC5B,KAAK,sBAAsB,UAAU,IAAI;EACzC,QAAQ,UAAU;EACnB,CACF,GACD,EAAE;AAEN,QAAO;EACL,IAAI,kBAAkB;EACtB,OAAO,mBAAmB;EAC1B,gBAAgB;EAChB,GAAG,UAAU,eAAe,QAAQ,YAAY;EAChD,QAAQ,EAAE,IAAI,YAAY;EAC1B;EACA;EACA;EACD;;AAGH,SAAS,eACP,SACA,UACA,SACA,MACqB;CACrB,MAAM,SAAS,SAAS;CACxB,MAAM,OAAO,YAAY,OAAO,GAAG,OAAO,OAAO,GAAG;AACpD,uBAAsB,MAAM,UAAU,KAAK;CAC3C,MAAM,UAAU,QAAQ,MAAM,KAAK,KAAK,EAAE,UAAU,CAAC;AACrD,QAAO;EAAE,KAAK,QAAQ;EAAK,QAAQ,QAAQ;EAAQ;;AAGrD,SAAS,YAAY,OAAoC;AACvD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,WAAW,SACX,OAAQ,MAA6B,UAAU;;AAInD,SAAS,sBACP,MACA,UACA,MACM;AACN,KAAI,KAAK,KAAK,gBAAgB,SAAS,QAAQ,YAC7C,OAAM,mCAAmC;EACvC,mBAAmB;EACnB,UAAU,SAAS,QAAQ;EAC3B,QAAQ,KAAK,KAAK;EACnB,CAAC"}

package/dist/{data-transform-D8x5m1YV.d.mts → data-transform-CrpmG4uJ.d.mts}

@@ -1,7 +1,8 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { Contract } from "@prisma-next/contract/types";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
-import { DataTransformOperation } from "@prisma-next/framework-components/control";
 import { SqlQueryPlan } from "@prisma-next/sql-relational-core/plan";
 
 //#region src/core/migrations/operations/data-transform.d.ts
@@ -21,18 +22,18 @@ interface DataTransformOptions {
    * not referenceable from refs.
    */
   readonly invariantId?: string;
-  /** Optional pre-flight query. `undefined` means "no check". */
+  /**
+   * Optional pre-flight query. `undefined` means "no check". When
+   * supplied, the closure must return a **rowset query** whose
+   * presence of any row signals "violations remain". Conventional
+   * shape: `db.<table>.select('id').where(<violation>).limit(1)`.
+   * Scalar/aggregate shapes do not satisfy this contract.
+   */
   readonly check?: DataTransformClosure;
   /** One or more mutation queries to execute. */
   readonly run: DataTransformClosure | readonly DataTransformClosure[];
 }
-/**
- * Concrete Postgres flavor of `DataTransformOperation`, re-exported so the
- * `PostgresMigration.dataTransform` instance method can name it without
- * leaking the framework-components symbol into call sites.
- */
-type PostgresDataTransformOperation = DataTransformOperation;
-declare function dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions, adapter: SqlControlAdapter<'postgres'>): DataTransformOperation;
+declare function dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions, adapter: SqlControlAdapter<'postgres'>): SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 //#endregion
-export { dataTransform as i, DataTransformOptions as n, PostgresDataTransformOperation as r, DataTransformClosure as t };
-//# sourceMappingURL=data-transform-D8x5m1YV.d.mts.map
+export { DataTransformOptions as n, dataTransform as r, DataTransformClosure as t };
+//# sourceMappingURL=data-transform-CrpmG4uJ.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data-transform-CrpmG4uJ.d.mts","names":[],"sources":["../src/core/migrations/operations/data-transform.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAqEU;WACC,aAAa;;;;;;KAOZ,oBAAA,SAA6B,eAAe;UAEvC,oBAAA;;;;;;;;;;;;;;mBAcE;;gBAEH,gCAAgC;;iBAGhC,gCAAgC,SAAS,uBAC7C,kCAED,+BACA,gCACR,0BAA0B"}

package/dist/data-transform.d.mts

@@ -1,2 +1,2 @@
-import { i as dataTransform } from "./data-transform-D8x5m1YV.mjs";
+import { r as dataTransform } from "./data-transform-CrpmG4uJ.mjs";
 export { dataTransform };

package/dist/data-transform.mjs

@@ -1,3 +1,3 @@
-import { t as dataTransform } from "./data-transform-C83dy0vk.mjs";
+import { t as dataTransform } from "./data-transform-Be_i_DBc.mjs";
 
 export { dataTransform };

package/dist/issue-planner.d.mts

@@ -4,8 +4,8 @@ import { CodecControlHooks, MigrationOperationPolicy, SqlPlannerConflict } from
 import { Result } from "@prisma-next/utils/result";
 import { Contract } from "@prisma-next/contract/types";
 import { SqlStorage, StorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { SchemaIssue } from "@prisma-next/framework-components/control";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+import { SchemaIssue } from "@prisma-next/framework-components/control";
 import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 
 //#region src/core/migrations/planner-strategies.d.ts

package/dist/migration.d.mts

@@ -1,6 +1,6 @@
-import { i as dataTransform, n as DataTransformOptions, t as DataTransformClosure } from "./data-transform-D8x5m1YV.mjs";
+import { n as DataTransformOptions, r as dataTransform, t as DataTransformClosure } from "./data-transform-CrpmG4uJ.mjs";
 import { n as ForeignKeySpec, r as Op, t as ColumnSpec } from "./shared-Bxkt8pNO.mjs";
-import { t as PostgresMigration } from "./postgres-migration-DcfWGqhe.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BFjbb25b.mjs";
 import { placeholder } from "@prisma-next/errors/migration";
 import { MigrationCLI } from "@prisma-next/cli/migration-cli";
 

package/dist/migration.mjs

@@ -1,6 +1,6 @@
 import { _ as dropColumn, a as addEnumValues, b as setDefault, c as renameType, d as addForeignKey, f as addPrimaryKey, g as alterColumnType, h as addColumn, i as dropIndex, l as createExtension, m as dropConstraint, n as dropTable, o as createEnumType, p as addUnique, r as createIndex, s as dropEnumType, t as createTable, u as createSchema, v as dropDefault, x as setNotNull, y as dropNotNull } from "./tables-BmdW_FWO.mjs";
-import { t as dataTransform } from "./data-transform-C83dy0vk.mjs";
-import { t as PostgresMigration } from "./postgres-migration-EGSlO4jO.mjs";
+import { t as dataTransform } from "./data-transform-Be_i_DBc.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BS9vQW97.mjs";
 import { placeholder } from "@prisma-next/errors/migration";
 import { MigrationCLI } from "@prisma-next/cli/migration-cli";
 

package/dist/pack.d.mts

@@ -1,4 +1,4 @@
-import { t as CodecTypes } from "./codecs-CE5EUsNM.mjs";
+import { t as CodecTypes } from "./codecs-B03dFv94.mjs";
 
 //#region src/core/descriptor-meta.d.ts
 declare const postgresTargetDescriptorMetaBase: {

package/dist/{planner-B4ZSLHRI.mjs → planner-Cm-ZLutk.mjs}

@@ -1,7 +1,7 @@
 import { t as parsePostgresDefault } from "./default-normalizer-DNOpRoOF.mjs";
 import { t as normalizeSchemaNativeType } from "./native-type-normalizer-CInai_oY.mjs";
 import { n as postgresPlannerStrategies, t as planIssues } from "./issue-planner-CFjB0_oO.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-C0GNhHGw.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Bi-RWO4-.mjs";
 import { extractCodecControlHooks, plannerFailure } from "@prisma-next/family-sql/control";
 import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
 
@@ -95,4 +95,4 @@ var PostgresMigrationPlanner = class {
 
 //#endregion
 export { createPostgresMigrationPlanner as t };
-//# sourceMappingURL=planner-B4ZSLHRI.mjs.map
+//# sourceMappingURL=planner-Cm-ZLutk.mjs.map

package/dist/{planner-B4ZSLHRI.mjs.map → planner-Cm-ZLutk.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-B4ZSLHRI.mjs","names":["DEFAULT_PLANNER_CONFIG: PlannerConfig","config: PlannerConfig"],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport { extractCodecControlHooks, plannerFailure } from '@prisma-next/family-sql/control';\nimport { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport { planIssues } from './issue-planner';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ntype VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0] & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ninterface PlannerConfig {\n  readonly defaultSchema: string;\n}\n\nconst DEFAULT_PLANNER_CONFIG: PlannerConfig = {\n  defaultSchema: 'public',\n};\n\nexport function createPostgresMigrationPlanner(\n  config: Partial<PlannerConfig> = {},\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner({\n    ...DEFAULT_PLANNER_CONFIG,\n    ...config,\n  });\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the unified\n * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,\n * type-change, nullable-tightening, codec-hook storage types,\n * component-declared dependency installs, and shared-temp-default /\n * empty-table-guarded NOT-NULL add-column. The same strategy list runs for\n * `migration plan`, `db update`, and `db init`; behavior diverges purely on\n * `policy.allowedOperationClasses` (the data-safe strategies short-circuit\n * when `'data'` is excluded). The issue planner applies operation-class\n * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both\n * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`\n * authoring surface.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  constructor(private readonly config: PlannerConfig) {}\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration([], {\n      from: context.fromHash,\n      to: context.toHash,\n    });\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName = options.schemaName ?? this.config.defaultSchema;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    const schemaIssues = this.collectSchemaIssues(options);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n\n    const result = planIssues({\n      issues: schemaIssues,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      schema: options.schema,\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {\n        from: options.fromContract?.storage.storageHash ?? null,\n        to: options.contract.storage.storageHash,\n      }),\n    });\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {\n    // `db init` uses additive-only policy and intentionally ignores extra\n    // schema objects. Any reconciliation-capable policy (widening or\n    // destructive) must inspect extras to reconcile strict equality.\n    const allowed = options.policy.allowedOperationClasses;\n    const strict = allowed.includes('widening') || allowed.includes('destructive');\n    const verifyOptions: VerifySqlSchemaOptionsWithComponents = {\n      contract: options.contract,\n      schema: options.schema,\n      strict,\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n      normalizeDefault: parsePostgresDefault,\n      normalizeNativeType: normalizeSchemaNativeType,\n    };\n    const verifyResult = verifySqlSchema(verifyOptions);\n    return verifyResult.schema.issues;\n  }\n}\n"],"mappings":";;;;;;;;AAuCA,MAAMA,yBAAwC,EAC5C,eAAe,UAChB;AAED,SAAgB,+BACd,SAAiC,EAAE,EACT;AAC1B,QAAO,IAAI,yBAAyB;EAClC,GAAG;EACH,GAAG;EACJ,CAAC;;;;;;;;;;;;;;;;;;AA8BJ,IAAa,2BAAb,MAAqF;CACnF,YAAY,AAAiBC,QAAuB;EAAvB;;CAE7B,KAAK,SAqBkB;AACrB,SAAO,KAAK,QAAQ,QAA0C;;CAGhE,eAAe,SAAsE;AACnF,SAAO,IAAI,sCAAsC,EAAE,EAAE;GACnD,MAAM,QAAQ;GACd,IAAI,QAAQ;GACb,CAAC;;CAGJ,AAAQ,QAAQ,SAA6D;EAC3E,MAAM,aAAa,QAAQ,cAAc,KAAK,OAAO;EACrD,MAAM,eAAe,KAAK,qBAAqB,QAAQ,OAAO;AAC9D,MAAI,aACF,QAAO;EAGT,MAAM,eAAe,KAAK,oBAAoB,QAAQ;EACtD,MAAM,aAAa,yBAAyB,QAAQ,oBAAoB;EACxE,MAAM,eAAe,QAAQ,SAAS,QAAQ,SAAS,EAAE;EAEzD,MAAM,SAAS,WAAW;GACxB,QAAQ;GACR,YAAY,QAAQ;GAMpB,cAAc,QAAQ;GACtB;GACA;GACA;GACA,QAAQ,QAAQ;GAChB,QAAQ,QAAQ;GAChB,qBAAqB,QAAQ;GAC7B,YAAY;GACb,CAAC;AAEF,MAAI,CAAC,OAAO,GACV,QAAO,eAAe,OAAO,QAAQ;AAGvC,SAAO,OAAO,OAAO;GACnB,MAAM;GACN,MAAM,IAAI,sCAAsC,OAAO,MAAM,OAAO;IAClE,MAAM,QAAQ,cAAc,QAAQ,eAAe;IACnD,IAAI,QAAQ,SAAS,QAAQ;IAC9B,CAAC;GACH,CAAC;;CAGJ,AAAQ,qBAAqB,QAAkC;AAC7D,MAAI,CAAC,OAAO,wBAAwB,SAAS,WAAW,CACtD,QAAO,eAAe,CACpB;GACE,MAAM;GACN,SAAS;GACT,KAAK;GACN,CACF,CAAC;AAEJ,SAAO;;CAGT,AAAQ,oBAAoB,SAA+D;EAIzF,MAAM,UAAU,QAAQ,OAAO;EAC/B,MAAM,SAAS,QAAQ,SAAS,WAAW,IAAI,QAAQ,SAAS,cAAc;AAW9E,SADqB,gBATuC;GAC1D,UAAU,QAAQ;GAClB,QAAQ,QAAQ;GAChB;GACA,sCAAsB,IAAI,KAAK;GAC/B,qBAAqB,QAAQ;GAC7B,kBAAkB;GAClB,qBAAqB;GACtB,CACkD,CAC/B,OAAO"}
+{"version":3,"file":"planner-Cm-ZLutk.mjs","names":["DEFAULT_PLANNER_CONFIG: PlannerConfig","config: PlannerConfig"],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport { extractCodecControlHooks, plannerFailure } from '@prisma-next/family-sql/control';\nimport { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport { planIssues } from './issue-planner';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ntype VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0] & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ninterface PlannerConfig {\n  readonly defaultSchema: string;\n}\n\nconst DEFAULT_PLANNER_CONFIG: PlannerConfig = {\n  defaultSchema: 'public',\n};\n\nexport function createPostgresMigrationPlanner(\n  config: Partial<PlannerConfig> = {},\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner({\n    ...DEFAULT_PLANNER_CONFIG,\n    ...config,\n  });\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the unified\n * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,\n * type-change, nullable-tightening, codec-hook storage types,\n * component-declared dependency installs, and shared-temp-default /\n * empty-table-guarded NOT-NULL add-column. The same strategy list runs for\n * `migration plan`, `db update`, and `db init`; behavior diverges purely on\n * `policy.allowedOperationClasses` (the data-safe strategies short-circuit\n * when `'data'` is excluded). The issue planner applies operation-class\n * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both\n * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`\n * authoring surface.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  constructor(private readonly config: PlannerConfig) {}\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration([], {\n      from: context.fromHash,\n      to: context.toHash,\n    });\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName = options.schemaName ?? this.config.defaultSchema;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    const schemaIssues = this.collectSchemaIssues(options);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n\n    const result = planIssues({\n      issues: schemaIssues,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      schema: options.schema,\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {\n        from: options.fromContract?.storage.storageHash ?? null,\n        to: options.contract.storage.storageHash,\n      }),\n    });\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {\n    // `db init` uses additive-only policy and intentionally ignores extra\n    // schema objects. Any reconciliation-capable policy (widening or\n    // destructive) must inspect extras to reconcile strict equality.\n    const allowed = options.policy.allowedOperationClasses;\n    const strict = allowed.includes('widening') || allowed.includes('destructive');\n    const verifyOptions: VerifySqlSchemaOptionsWithComponents = {\n      contract: options.contract,\n      schema: options.schema,\n      strict,\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n      normalizeDefault: parsePostgresDefault,\n      normalizeNativeType: normalizeSchemaNativeType,\n    };\n    const verifyResult = verifySqlSchema(verifyOptions);\n    return verifyResult.schema.issues;\n  }\n}\n"],"mappings":";;;;;;;;AAuCA,MAAMA,yBAAwC,EAC5C,eAAe,UAChB;AAED,SAAgB,+BACd,SAAiC,EAAE,EACT;AAC1B,QAAO,IAAI,yBAAyB;EAClC,GAAG;EACH,GAAG;EACJ,CAAC;;;;;;;;;;;;;;;;;;AA8BJ,IAAa,2BAAb,MAAqF;CACnF,YAAY,AAAiBC,QAAuB;EAAvB;;CAE7B,KAAK,SAqBkB;AACrB,SAAO,KAAK,QAAQ,QAA0C;;CAGhE,eAAe,SAAsE;AACnF,SAAO,IAAI,sCAAsC,EAAE,EAAE;GACnD,MAAM,QAAQ;GACd,IAAI,QAAQ;GACb,CAAC;;CAGJ,AAAQ,QAAQ,SAA6D;EAC3E,MAAM,aAAa,QAAQ,cAAc,KAAK,OAAO;EACrD,MAAM,eAAe,KAAK,qBAAqB,QAAQ,OAAO;AAC9D,MAAI,aACF,QAAO;EAGT,MAAM,eAAe,KAAK,oBAAoB,QAAQ;EACtD,MAAM,aAAa,yBAAyB,QAAQ,oBAAoB;EACxE,MAAM,eAAe,QAAQ,SAAS,QAAQ,SAAS,EAAE;EAEzD,MAAM,SAAS,WAAW;GACxB,QAAQ;GACR,YAAY,QAAQ;GAMpB,cAAc,QAAQ;GACtB;GACA;GACA;GACA,QAAQ,QAAQ;GAChB,QAAQ,QAAQ;GAChB,qBAAqB,QAAQ;GAC7B,YAAY;GACb,CAAC;AAEF,MAAI,CAAC,OAAO,GACV,QAAO,eAAe,OAAO,QAAQ;AAGvC,SAAO,OAAO,OAAO;GACnB,MAAM;GACN,MAAM,IAAI,sCAAsC,OAAO,MAAM,OAAO;IAClE,MAAM,QAAQ,cAAc,QAAQ,eAAe;IACnD,IAAI,QAAQ,SAAS,QAAQ;IAC9B,CAAC;GACH,CAAC;;CAGJ,AAAQ,qBAAqB,QAAkC;AAC7D,MAAI,CAAC,OAAO,wBAAwB,SAAS,WAAW,CACtD,QAAO,eAAe,CACpB;GACE,MAAM;GACN,SAAS;GACT,KAAK;GACN,CACF,CAAC;AAEJ,SAAO;;CAGT,AAAQ,oBAAoB,SAA+D;EAIzF,MAAM,UAAU,QAAQ,OAAO;EAC/B,MAAM,SAAS,QAAQ,SAAS,WAAW,IAAI,QAAQ,SAAS,cAAc;AAW9E,SADqB,gBATuC;GAC1D,UAAU,QAAQ;GAClB,QAAQ,QAAQ;GAChB;GACA,sCAAsB,IAAI,KAAK;GAC/B,qBAAqB,QAAQ;GAC7B,kBAAkB;GAClB,qBAAqB;GACtB,CACkD,CAC/B,OAAO"}

package/dist/{planner-produced-postgres-migration-C0GNhHGw.mjs → planner-produced-postgres-migration-Bi-RWO4-.mjs}

@@ -1,4 +1,4 @@
-import { t as PostgresMigration } from "./postgres-migration-EGSlO4jO.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BS9vQW97.mjs";
 import { t as renderOps } from "./render-ops-D6_DHdOK.mjs";
 import { t as renderCallsToTypeScript } from "./render-typescript-Co3Emwgz.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -29,4 +29,4 @@ var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
 
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
-//# sourceMappingURL=planner-produced-postgres-migration-C0GNhHGw.mjs.map
+//# sourceMappingURL=planner-produced-postgres-migration-Bi-RWO4-.mjs.map

package/dist/{planner-produced-postgres-migration-C0GNhHGw.mjs.map → planner-produced-postgres-migration-Bi-RWO4-.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-C0GNhHGw.mjs","names":["#calls","#meta"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly PostgresOpFactoryCall[];\n  readonly #meta: MigrationMeta;\n\n  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n      ...ifDefined('labels', this.#meta.labels),\n    });\n  }\n}\n"],"mappings":";;;;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE,CAASA;CACT,CAASC;CAET,YAAY,OAAyC,MAAqB;AACxE,SAAO;AACP,QAAKD,QAAS;AACd,QAAKC,OAAQ;;CAGf,IAAa,aAA4B;AACvC,SAAO,UAAU,MAAKD,MAAO;;CAG/B,AAAS,WAA0B;AACjC,SAAO,MAAKC;;CAGd,mBAA2B;AACzB,SAAO,wBAAwB,MAAKD,OAAQ;GAC1C,MAAM,MAAKC,KAAM;GACjB,IAAI,MAAKA,KAAM;GACf,GAAG,UAAU,UAAU,MAAKA,KAAM,OAAO;GAC1C,CAAC"}
+{"version":3,"file":"planner-produced-postgres-migration-Bi-RWO4-.mjs","names":["#calls","#meta"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly PostgresOpFactoryCall[];\n  readonly #meta: MigrationMeta;\n\n  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n      ...ifDefined('labels', this.#meta.labels),\n    });\n  }\n}\n"],"mappings":";;;;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE,CAASA;CACT,CAASC;CAET,YAAY,OAAyC,MAAqB;AACxE,SAAO;AACP,QAAKD,QAAS;AACd,QAAKC,OAAQ;;CAGf,IAAa,aAA4B;AACvC,SAAO,UAAU,MAAKD,MAAO;;CAG/B,AAAS,WAA0B;AACjC,SAAO,MAAKC;;CAGd,mBAA2B;AACzB,SAAO,wBAAwB,MAAKD,OAAQ;GAC1C,MAAM,MAAKC,KAAM;GACjB,IAAI,MAAKA,KAAM;GACf,GAAG,UAAU,UAAU,MAAKA,KAAM,OAAO;GAC1C,CAAC"}

package/dist/{planner-produced-postgres-migration-Dw_mPMKt.d.mts → planner-produced-postgres-migration-M3EfhWSS.d.mts}

@@ -1,6 +1,6 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
 import { b as PostgresOpFactoryCall } from "./op-factory-call-C3bWXKSP.mjs";
-import { t as PostgresMigration } from "./postgres-migration-DcfWGqhe.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BFjbb25b.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface } from "@prisma-next/framework-components/control";
 import { MigrationMeta } from "@prisma-next/migration-tools/migration";
@@ -17,4 +17,4 @@ declare class TypeScriptRenderablePostgresMigration extends PostgresMigration im
 }
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
-//# sourceMappingURL=planner-produced-postgres-migration-Dw_mPMKt.d.mts.map
+//# sourceMappingURL=planner-produced-postgres-migration-M3EfhWSS.d.mts.map

package/dist/planner-produced-postgres-migration-M3EfhWSS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-postgres-migration-M3EfhWSS.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAmCK,EAAA,GAAK,0BAA0B;cAEvB,qCAAA,SACH,iBAAA,YACG;;8BAKiB,+BAA+B;6BAMvB;cAIf"}

package/dist/planner-produced-postgres-migration.d.mts

@@ -1,5 +1,6 @@
+import "./data-transform-CrpmG4uJ.mjs";
 import "./shared-Bxkt8pNO.mjs";
 import "./op-factory-call-C3bWXKSP.mjs";
-import "./postgres-migration-DcfWGqhe.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Dw_mPMKt.mjs";
+import "./postgres-migration-BFjbb25b.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-M3EfhWSS.mjs";
 export { TypeScriptRenderablePostgresMigration };

package/dist/planner-produced-postgres-migration.mjs

@@ -1,3 +1,3 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-C0GNhHGw.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Bi-RWO4-.mjs";
 
 export { TypeScriptRenderablePostgresMigration };

package/dist/planner.d.mts

@@ -1,11 +1,12 @@
+import "./data-transform-CrpmG4uJ.mjs";
 import "./shared-Bxkt8pNO.mjs";
 import "./op-factory-call-C3bWXKSP.mjs";
-import "./postgres-migration-DcfWGqhe.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Dw_mPMKt.mjs";
+import "./postgres-migration-BFjbb25b.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-M3EfhWSS.mjs";
 import { MigrationOperationPolicy, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
 import { Contract } from "@prisma-next/contract/types";
-import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
 
 //#region src/core/migrations/planner.d.ts
 interface PlannerConfig {

package/dist/planner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAmCU,aAAA;;;iBAQM,8BAAA,UACN,QAAQ,iBACf;;AA3B2F;AAyB9F;;;;;AAgBY,KAAA,kBAAA,GAAkB;EAoBjB,SAAA,IAAA,EAAA,SAAA;EAC0B,SAAA,IAAA,EApBQ,qCAoBR;CAKlB,GAxBjB,uBAwBiB;;;;;;;;;;;;;;;;;cANR,wBAAA,YAAoC;;sBACV;;;;qBAKlB;;;;;;;;;;;;;;;2BAeM;;kCAEO,cAAc;MAC1C;0BAIoB,2BAA2B"}
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;UAmCU,aAAA;;;iBAQM,8BAAA,UACN,QAAQ,iBACf;;;AA3B2F;AAyB9F;;;;AAE2B,KAcf,kBAAA,GAde;EAcf,SAAA,IAAA,EAAA,SAAkB;EAoBjB,SAAA,IAAA,EAnBkC,qCAmBT;CACC,GAnBnC,uBAmBmC;;;;;;;;;;;;;;;;;cAD1B,wBAAA,YAAoC;;sBACV;;;;qBAKlB;;;;;;;;;;;;;;;2BAeM;;kCAEO,cAAc;MAC1C;0BAIoB,2BAA2B"}

package/dist/planner.mjs

@@ -1,4 +1,4 @@
 import "./issue-planner-CFjB0_oO.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-B4ZSLHRI.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-Cm-ZLutk.mjs";
 
 export { createPostgresMigrationPlanner };

package/dist/{postgres-migration-DcfWGqhe.d.mts → postgres-migration-BFjbb25b.d.mts}

@@ -1,5 +1,6 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
-import { n as DataTransformOptions, r as PostgresDataTransformOperation } from "./data-transform-D8x5m1YV.mjs";
+import { n as DataTransformOptions } from "./data-transform-CrpmG4uJ.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { Migration } from "@prisma-next/family-sql/migration";
 import { Contract } from "@prisma-next/contract/types";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
@@ -43,8 +44,8 @@ declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDet
    * supplies the stored control adapter. Authors call this from inside
    * `get operations()`; the adapter argument is hidden from the call site.
    */
-  protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): PostgresDataTransformOperation;
+  protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 }
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-DcfWGqhe.d.mts.map
+//# sourceMappingURL=postgres-migration-BFjbb25b.d.mts.map

package/dist/postgres-migration-BFjbb25b.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-BFjbb25b.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;AA8BA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,UAC9C;;;;;;;;qCAWmC;sBAEf;;;;;;4CAesB,SAAS,uBACvC,kCAED,uBACR,0BAA0B"}

package/dist/{postgres-migration-EGSlO4jO.mjs → postgres-migration-BS9vQW97.mjs}

@@ -1,5 +1,5 @@
 import { t as errorPostgresMigrationStackMissing } from "./errors-AFvEPZ1R.mjs";
-import { t as dataTransform } from "./data-transform-C83dy0vk.mjs";
+import { t as dataTransform } from "./data-transform-Be_i_DBc.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
 
 //#region src/core/migrations/postgres-migration.ts
@@ -49,4 +49,4 @@ var PostgresMigration = class extends Migration {
 
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-EGSlO4jO.mjs.map
+//# sourceMappingURL=postgres-migration-BS9vQW97.mjs.map

package/dist/postgres-migration-BS9vQW97.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-BS9vQW97.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a target-specific re-export of this\n * class from `@prisma-next/target-postgres/migration`, keeping the\n * authoring surface target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,AAAS,WAAW;;;;;;;CAQpB,AAAmB;CAEnB,YAAY,OAAyC;AACnD,QAAM,MAAM;AAIZ,OAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,MAAM,GAC5B;;;;;;;CAQN,AAAU,cACR,UACA,MACA,SACsD;AACtD,MAAI,CAAC,KAAK,eACR,OAAM,oCAAoC;AAE5C,SAAO,cAAc,UAAU,MAAM,SAAS,KAAK,eAAe"}

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.5.0-dev.44",
+  "version": "0.5.0-dev.46",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
     "pathe": "^2.0.3",
-    "@prisma-next/cli": "0.5.0-dev.44",
-    "@prisma-next/errors": "0.5.0-dev.44",
-    "@prisma-next/contract": "0.5.0-dev.44",
-    "@prisma-next/family-sql": "0.5.0-dev.44",
-    "@prisma-next/framework-components": "0.5.0-dev.44",
-    "@prisma-next/migration-tools": "0.5.0-dev.44",
-    "@prisma-next/ts-render": "0.5.0-dev.44",
-    "@prisma-next/sql-errors": "0.5.0-dev.44",
-    "@prisma-next/sql-contract": "0.5.0-dev.44",
-    "@prisma-next/sql-operations": "0.5.0-dev.44",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.44",
-    "@prisma-next/utils": "0.5.0-dev.44",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.44"
+    "@prisma-next/cli": "0.5.0-dev.46",
+    "@prisma-next/contract": "0.5.0-dev.46",
+    "@prisma-next/errors": "0.5.0-dev.46",
+    "@prisma-next/family-sql": "0.5.0-dev.46",
+    "@prisma-next/migration-tools": "0.5.0-dev.46",
+    "@prisma-next/framework-components": "0.5.0-dev.46",
+    "@prisma-next/sql-contract": "0.5.0-dev.46",
+    "@prisma-next/sql-operations": "0.5.0-dev.46",
+    "@prisma-next/sql-errors": "0.5.0-dev.46",
+    "@prisma-next/ts-render": "0.5.0-dev.46",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.46",
+    "@prisma-next/utils": "0.5.0-dev.46",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.46"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/test-utils": "0.0.1"
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",

package/src/core/codec-ids.ts

@@ -28,3 +28,4 @@ export const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;
 export const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;
 export const PG_JSON_CODEC_ID = 'pg/json@1' as const;
 export const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;
+export const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;

package/src/core/codecs.ts

@@ -19,6 +19,7 @@ import { type as arktype } from 'arktype';
 import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
+  PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
@@ -502,6 +503,40 @@ const pgVarbitCodec = codec<
   },
 });
 
+const pgByteaCodec = codec({
+  typeId: PG_BYTEA_CODEC_ID,
+  targetTypes: ['bytea'],
+  traits: ['equality'],
+  encode: (value: Uint8Array): Uint8Array => value,
+  decode: (wire: Uint8Array): Uint8Array =>
+    // Postgres node drivers commonly return Buffer instances (which extend
+    // Uint8Array) — normalize to a plain Uint8Array view so engine-agnostic
+    // consumers don't accidentally observe Buffer-specific APIs.
+    wire instanceof Uint8Array && wire.constructor === Uint8Array
+      ? wire
+      : new Uint8Array(wire.buffer, wire.byteOffset, wire.byteLength),
+  encodeJson: (value: Uint8Array): string => Buffer.from(value).toString('base64'),
+  decodeJson: (json): Uint8Array => {
+    if (typeof json !== 'string') {
+      throw new Error(`Expected base64 string for pg/bytea@1, got ${typeof json}`);
+    }
+    const decoded = Buffer.from(json, 'base64');
+    if (decoded.toString('base64') !== json) {
+      throw new Error(`Invalid base64 string for pg/bytea@1 (length: ${json.length})`);
+    }
+    return new Uint8Array(decoded);
+  },
+  meta: {
+    db: {
+      sql: {
+        postgres: {
+          nativeType: 'bytea',
+        },
+      },
+    },
+  },
+});
+
 const pgEnumCodec = codec({
   typeId: PG_ENUM_CODEC_ID,
   targetTypes: ['enum'],
@@ -610,6 +645,7 @@ const codecs = defineCodecs()
   .add('bool', pgBoolCodec)
   .add('bit', pgBitCodec)
   .add('bit varying', pgVarbitCodec)
+  .add('bytea', pgByteaCodec)
   .add('interval', pgIntervalCodec)
   .add('enum', pgEnumCodec)
   .add('json', pgJsonCodec)

package/src/core/migrations/operations/data-transform.ts

@@ -11,7 +11,7 @@
  *   override get operations() {
  *     return [
  *       this.dataTransform(endContract, 'backfill emails', {
- *         check: () => db.users.count().where(({ email }) => email.isNull()),
+ *         check: () => db.users.select('id').where(({ email }) => email.isNull()).limit(1),
  *         run:   () => db.users.update({ email: '' }).where(({ email }) => email.isNull()),
  *       }),
  *     ];
@@ -23,21 +23,49 @@
  * invokes each one, asserts that its `meta.storageHash` matches the
  * `contract` it was handed (→ `PN-MIG-2005` on mismatch), and lowers the
  * plan via the supplied control adapter to a serialized `{sql, params}`
- * payload for `ops.json`. The free factory remains usable standalone
- * (tests, ad-hoc tooling, non-class contexts) by passing the adapter
- * explicitly as the fourth argument.
+ * payload.
+ *
+ * The factory then lowers the data transform to the unified migration-op
+ * shape `{ precheck, execute, postcheck }`. The user's `check` plan is
+ * wrapped twice with opposite truth values:
+ *
+ * - precheck `SELECT EXISTS (<check>) AS ok` asserts there is work to do
+ *   (precheck is short-circuited by the runner's pre-satisfied-skip path
+ *   when nothing remains to backfill).
+ * - postcheck `SELECT NOT EXISTS (<check>) AS ok` asserts the work is
+ *   complete after the run steps execute.
+ *
+ * The `check` plan is therefore expected to be a **rowset query whose
+ * presence of any row signals "work remains"** — typically `select('id')
+ * .where(<violation predicate>).limit(1)`. Scalar/aggregate shapes
+ * (`count(*)`, `bool_and(...)`) do not work under this contract: they
+ * always return exactly one row, so `EXISTS` is always true and
+ * `NOT EXISTS` is always false. (This is the same row-presence contract
+ * the pre-unification runner relied on; the wrapping is just lifting it
+ * into SQL.)
+ *
+ * Each `run` plan becomes an execute step. Because the `Step.params`
+ * field threads through `driver.query(sql, params)`, the user's bound
+ * values flow through the driver's parameter binder rather than being
+ * inlined into the SQL text.
+ *
+ * The free factory remains usable standalone (tests, ad-hoc tooling,
+ * non-class contexts) by passing the adapter explicitly as the fourth
+ * argument.
  */
 
 import type { Contract } from '@prisma-next/contract/types';
 import { errorDataTransformContractMismatch } from '@prisma-next/errors/migration';
-import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import type {
-  DataTransformOperation,
-  SerializedQueryPlan,
-} from '@prisma-next/framework-components/control';
+  SqlMigrationPlanOperation,
+  SqlMigrationPlanOperationStep,
+} from '@prisma-next/family-sql/control';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import type { SerializedQueryPlan } from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
 import { ifDefined } from '@prisma-next/utils/defined';
+import type { PostgresPlanTargetDetails } from '../planner-target-details';
 
 interface Buildable<R = unknown> {
   build(): SqlQueryPlan<R>;
@@ -56,37 +84,66 @@ export interface DataTransformOptions {
    * not referenceable from refs.
    */
   readonly invariantId?: string;
-  /** Optional pre-flight query. `undefined` means "no check". */
+  /**
+   * Optional pre-flight query. `undefined` means "no check". When
+   * supplied, the closure must return a **rowset query** whose
+   * presence of any row signals "violations remain". Conventional
+   * shape: `db.<table>.select('id').where(<violation>).limit(1)`.
+   * Scalar/aggregate shapes do not satisfy this contract.
+   */
   readonly check?: DataTransformClosure;
   /** One or more mutation queries to execute. */
   readonly run: DataTransformClosure | readonly DataTransformClosure[];
 }
 
-/**
- * Concrete Postgres flavor of `DataTransformOperation`, re-exported so the
- * `PostgresMigration.dataTransform` instance method can name it without
- * leaking the framework-components symbol into call sites.
- */
-export type PostgresDataTransformOperation = DataTransformOperation;
-
 export function dataTransform<TContract extends Contract<SqlStorage>>(
   contract: TContract,
   name: string,
   options: DataTransformOptions,
   adapter: SqlControlAdapter<'postgres'>,
-): DataTransformOperation {
+): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
   const runClosures: readonly DataTransformClosure[] = Array.isArray(options.run)
     ? options.run
     : [options.run as DataTransformClosure];
+
+  const checkPlan = options.check ? invokeAndLower(options.check, contract, adapter, name) : null;
+  const runPlans = runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name));
+
+  const precheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
+    ? [
+        {
+          description: `Check ${name} has work to do`,
+          sql: `SELECT EXISTS (${checkPlan.sql}) AS ok`,
+          params: checkPlan.params,
+        },
+      ]
+    : [];
+
+  const execute: readonly SqlMigrationPlanOperationStep[] = runPlans.map((plan) => ({
+    description: `Run ${name}`,
+    sql: plan.sql,
+    params: plan.params,
+  }));
+
+  const postcheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
+    ? [
+        {
+          description: `Verify ${name} resolved all violations`,
+          sql: `SELECT NOT EXISTS (${checkPlan.sql}) AS ok`,
+          params: checkPlan.params,
+        },
+      ]
+    : [];
+
   return {
     id: `data_migration.${name}`,
     label: `Data transform: ${name}`,
     operationClass: 'data',
-    name,
     ...ifDefined('invariantId', options.invariantId),
-    source: 'migration.ts',
-    check: options.check ? invokeAndLower(options.check, contract, adapter, name) : null,
-    run: runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),
+    target: { id: 'postgres' },
+    precheck,
+    execute,
+    postcheck,
   };
 }
 

package/src/core/migrations/postgres-migration.ts

@@ -1,14 +1,11 @@
 import type { Contract } from '@prisma-next/contract/types';
+import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
 import type { ControlStack } from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import { errorPostgresMigrationStackMissing } from '../errors';
-import {
-  type DataTransformOptions,
-  dataTransform,
-  type PostgresDataTransformOperation,
-} from './operations/data-transform';
+import { type DataTransformOptions, dataTransform } from './operations/data-transform';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 /**
@@ -64,7 +61,7 @@ export abstract class PostgresMigration extends SqlMigration<
     contract: TContract,
     name: string,
     options: DataTransformOptions,
-  ): PostgresDataTransformOperation {
+  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }