@prisma-next/target-postgres 0.5.0-dev.9 → 0.5.1

package/src/core/migrations/planner.ts

@@ -1,9 +1,14 @@
+import type { Contract } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
   SqlMigrationPlannerPlanOptions,
   SqlPlannerFailureResult,
 } from '@prisma-next/family-sql/control';
-import { extractCodecControlHooks, plannerFailure } from '@prisma-next/family-sql/control';
+import {
+  extractCodecControlHooks,
+  planFieldEventOperations,
+  plannerFailure,
+} from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
@@ -83,30 +88,48 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     readonly contract: unknown;
     readonly schema: unknown;
     readonly policy: MigrationOperationPolicy;
-    readonly fromHash?: string;
     /**
      * The "from" contract (state the planner assumes the database starts
-     * at). Only `migration plan` supplies this; `db update` / `db init`
-     * reconcile against the live schema with no old contract. When present
-     * alongside the `'data'` operation class, strategies that need from/to
-     * column shape comparisons (unsafe type change, nullability tightening)
-     * activate.
+     * at), or `null` for reconciliation flows. Only `migration plan` ever
+     * supplies a non-null value; `db update` / `db init` reconcile against
+     * the live schema and pass `null`. When present alongside the
+     * `'data'` operation class, strategies that need from/to column-shape
+     * comparisons (unsafe type change, nullability tightening) activate.
+     *
+     * Typed as the framework `Contract | null` to satisfy the
+     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL
+     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate
+     * `describe().from` on the produced plan as
+     * `fromContract?.storage.storageHash ?? null`.
      */
-    readonly fromContract?: unknown;
+    readonly fromContract: Contract | null;
     readonly schemaName?: string;
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+    /**
+     * Contract space this plan applies to. Stamped onto the produced
+     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys
+     * the marker row by the right space.
+     */
+    readonly spaceId: string;
   }): PostgresPlanResult {
-    return this.planSql(options as SqlMigrationPlannerPlanOptions, options.fromHash ?? '');
+    return this.planSql(options as SqlMigrationPlannerPlanOptions);
   }
 
-  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {
-    return new TypeScriptRenderablePostgresMigration([], {
-      from: context.fromHash,
-      to: context.toHash,
-    });
+  emptyMigration(
+    context: MigrationScaffoldContext,
+    spaceId: string,
+  ): MigrationPlanWithAuthoringSurface {
+    return new TypeScriptRenderablePostgresMigration(
+      [],
+      {
+        from: context.fromHash,
+        to: context.toHash,
+      },
+      spaceId,
+    );
   }
 
-  private planSql(options: SqlMigrationPlannerPlanOptions, fromHash: string): PostgresPlanResult {
+  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {
     const schemaName = options.schemaName ?? this.config.defaultSchema;
     const policyResult = this.ensureAdditivePolicy(options.policy);
     if (policyResult) {
@@ -125,7 +148,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       // from/to comparisons (unsafe type change, nullable tightening) are
       // inapplicable there — reconciliation falls through to
       // `mapIssueToCall`'s direct destructive handlers.
-      fromContract: options.fromContract ?? null,
+      fromContract: options.fromContract,
       schemaName,
       codecHooks,
       storageTypes,
@@ -139,12 +162,31 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       return plannerFailure(result.failure);
     }
 
+    // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed
+    // ordering is `structural → added → dropped → altered`, with
+    // within-group sorting by `(tableName, fieldName)` so re-emits are
+    // byte-stable. The hook fires only at the application emitter —
+    // extension-space planning never reaches this helper.
+    const fieldEventOps = planFieldEventOperations({
+      priorContract: options.fromContract,
+      newContract: options.contract,
+      codecHooks,
+    });
+    // Codec-emitted calls already conform to `OpFactoryCall` — render +
+    // toOp + importRequirements ride directly through the same emit path
+    // as structural ops, no `RawSqlCall` wrap.
+    const calls = [...result.value.calls, ...fieldEventOps];
+
     return Object.freeze({
       kind: 'success' as const,
-      plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {
-        from: fromHash,
-        to: options.contract.storage.storageHash,
-      }),
+      plan: new TypeScriptRenderablePostgresMigration(
+        calls,
+        {
+          from: options.fromContract?.storage.storageHash ?? null,
+          to: options.contract.storage.storageHash,
+        },
+        options.spaceId,
+      ),
     });
   }
 

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();
     }

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

@@ -1,9 +1,32 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { PostgresOpFactoryCall } from './op-factory-call';
+import type { OpFactoryCall } from '@prisma-next/framework-components/control';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 
-export function renderOps(calls: readonly PostgresOpFactoryCall[]): Op[] {
-  return calls.map((c) => c.toOp());
+/**
+ * Asserts an op materialised by an `OpFactoryCall` targets postgres. The
+ * extension surface lets any contributor emit calls, so this is the
+ * integration boundary where a stray non-postgres op would otherwise
+ * silently flow through to postgres-shaped renderers — exactly the
+ * place to fail loudly with op metadata (`id` + `target.id`).
+ */
+function assertPostgresOp(
+  op: ReturnType<OpFactoryCall['toOp']>,
+  callFactoryName: string,
+): asserts op is Op {
+  const targetId = (op as Partial<Op>).target?.id;
+  if (targetId !== 'postgres') {
+    throw new Error(
+      `renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,
+    );
+  }
+}
+
+export function renderOps(calls: readonly OpFactoryCall[]): Op[] {
+  return calls.map((c) => {
+    const op = c.toOp();
+    assertPostgresOp(op, c.factoryName);
+    return op;
+  });
 }

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

@@ -1,7 +1,7 @@
 /**
  * Polymorphic TypeScript emitter for the Postgres migration IR.
  *
- * Each `PostgresOpFactoryCall` renders itself via `renderTypeScript()` and
+ * Each `OpFactoryCall` renders itself via `renderTypeScript()` and
  * declares its own `importRequirements()`; this file just composes the module
  * source around those contributions. The design mirrors the Mongo target's
  * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required
@@ -9,14 +9,13 @@
  * shape is, so future consolidation to a framework-level helper is mechanical.
  */
 
+import type { OpFactoryCall } from '@prisma-next/framework-components/control';
 import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
 import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';
-import type { PostgresOpFactoryCall } from './op-factory-call';
 
 export interface RenderMigrationMeta {
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly kind?: string;
   readonly labels?: readonly string[];
 }
 
@@ -44,7 +43,7 @@ const BASE_IMPORTS: readonly ImportRequirement[] = [
 ];
 
 export function renderCallsToTypeScript(
-  calls: ReadonlyArray<PostgresOpFactoryCall>,
+  calls: ReadonlyArray<OpFactoryCall>,
   meta: RenderMigrationMeta,
 ): string {
   const imports = buildImports(calls);
@@ -68,7 +67,7 @@ export function renderCallsToTypeScript(
   ].join('\n');
 }
 
-function buildImports(calls: ReadonlyArray<PostgresOpFactoryCall>): string {
+function buildImports(calls: ReadonlyArray<OpFactoryCall>): string {
   const requirements: ImportRequirement[] = [...BASE_IMPORTS];
   for (const call of calls) {
     for (const req of call.importRequirements()) {
@@ -84,9 +83,6 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
   lines.push('    return {');
   lines.push(`      from: ${JSON.stringify(meta.from)},`);
   lines.push(`      to: ${JSON.stringify(meta.to)},`);
-  if (meta.kind) {
-    lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
-  }
   if (meta.labels && meta.labels.length > 0) {
     lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
   }