@prisma-next/target-postgres 0.4.0-dev.6 → 0.4.0-dev.7

package/package.json

@@ -1,33 +1,35 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.4.0-dev.6",
+  "version": "0.4.0-dev.7",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.4.0-dev.6",
-    "@prisma-next/framework-components": "0.4.0-dev.6",
-    "@prisma-next/family-sql": "0.4.0-dev.6",
-    "@prisma-next/sql-builder": "0.4.0-dev.6",
-    "@prisma-next/sql-contract": "0.4.0-dev.6",
-    "@prisma-next/sql-operations": "0.4.0-dev.6",
-    "@prisma-next/sql-errors": "0.4.0-dev.6",
-    "@prisma-next/sql-relational-core": "0.4.0-dev.6",
-    "@prisma-next/sql-schema-ir": "0.4.0-dev.6",
-    "@prisma-next/utils": "0.4.0-dev.6",
-    "@prisma-next/sql-runtime": "0.4.0-dev.6"
+    "pathe": "^2.0.3",
+    "@prisma-next/contract": "0.4.0-dev.7",
+    "@prisma-next/family-sql": "0.4.0-dev.7",
+    "@prisma-next/framework-components": "0.4.0-dev.7",
+    "@prisma-next/sql-builder": "0.4.0-dev.7",
+    "@prisma-next/sql-contract": "0.4.0-dev.7",
+    "@prisma-next/sql-operations": "0.4.0-dev.7",
+    "@prisma-next/errors": "0.4.0-dev.7",
+    "@prisma-next/sql-errors": "0.4.0-dev.7",
+    "@prisma-next/sql-relational-core": "0.4.0-dev.7",
+    "@prisma-next/sql-runtime": "0.4.0-dev.7",
+    "@prisma-next/sql-schema-ir": "0.4.0-dev.7",
+    "@prisma-next/utils": "0.4.0-dev.7"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/adapter-postgres": "0.4.0-dev.6",
-    "@prisma-next/driver-postgres": "0.4.0-dev.6",
+    "@prisma-next/adapter-postgres": "0.4.0-dev.7",
+    "@prisma-next/driver-postgres": "0.4.0-dev.7",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/extension-pgvector": "0.4.0-dev.6",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/extension-pgvector": "0.4.0-dev.7",
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",

package/src/core/migrations/planner.ts

@@ -3,24 +3,30 @@ import {
   parsePostgresDefault,
   quoteIdentifier,
 } from '@prisma-next/adapter-postgres/control';
+import { errorPlanDoesNotSupportAuthoringSurface } from '@prisma-next/errors/migration';
 import type {
   CodecControlHooks,
   ComponentDatabaseDependency,
   MigrationOperationPolicy,
-  SqlMigrationPlanner,
   SqlMigrationPlannerPlanOptions,
   SqlMigrationPlanOperation,
   SqlPlannerConflict,
+  SqlPlannerFailureResult,
 } from '@prisma-next/family-sql/control';
 import {
   collectInitDependencies,
   createMigrationPlan,
   extractCodecControlHooks,
   plannerFailure,
-  plannerSuccess,
 } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
-import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  MigrationPlanner,
+  MigrationPlanWithAuthoringSurface,
+  MigrationScaffoldContext,
+  SchemaIssue,
+} from '@prisma-next/framework-components/control';
 import type {
   StorageColumn,
   StorageTable,
@@ -58,6 +64,7 @@ import {
   type PlanningMode,
   type PostgresPlanTargetDetails,
 } from './planner-target-details';
+import { renderDescriptorTypeScript } from './scaffolding';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
   readonly frameworkComponents: infer T;
@@ -89,17 +96,79 @@ const DEFAULT_PLANNER_CONFIG: PlannerConfig = {
 
 export function createPostgresMigrationPlanner(
   config: Partial<PlannerConfig> = {},
-): SqlMigrationPlanner<PostgresPlanTargetDetails> {
+): PostgresMigrationPlanner {
   return new PostgresMigrationPlanner({
     ...DEFAULT_PLANNER_CONFIG,
     ...config,
   });
 }
 
-class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTargetDetails> {
+/**
+ * Postgres planner success plan: the SQL-typed plan (so target-detail
+ * typing is preserved for direct SQL callers, including this package's unit
+ * tests) plus the framework-required `renderTypeScript()` stub.
+ */
+export type PostgresPlanWithRender = ReturnType<
+  typeof createMigrationPlan<PostgresPlanTargetDetails>
+> & {
+  renderTypeScript(): string;
+};
+
+/**
+ * Result of `PostgresMigrationPlanner.plan()`. A discriminated union that
+ * satisfies both the framework's `MigrationPlannerResult` (success plan
+ * carries `renderTypeScript()`) and the SQL family's typed result shape
+ * (success plan is a `SqlMigrationPlan<PostgresPlanTargetDetails>`).
+ */
+export type PostgresPlanResult =
+  | { readonly kind: 'success'; readonly plan: PostgresPlanWithRender }
+  | SqlPlannerFailureResult;
+
+/**
+ * Postgres migration planner.
+ *
+ * Implements the framework's `MigrationPlanner<'sql', 'postgres'>` directly
+ * — meaning it owns `emptyMigration()` and attaches the `renderTypeScript()`
+ * stub to success plans (Postgres uses descriptor-flow authoring, so
+ * `renderTypeScript()` throws on planner-produced plans). No external wrapper
+ * is required at the descriptor level.
+ *
+ * `plan()` accepts the framework's option shape (with `contract`/`schema`
+ * typed as `unknown`); SQL-typed callers may pass the more specific
+ * `SqlMigrationPlannerPlanOptions`, since those structurally satisfy the
+ * looser framework contract. Internally we treat options as the SQL-typed
+ * superset so the existing planner logic stays identical.
+ *
+ * `fromHash` is accepted but ignored: Postgres is descriptor-flow and never
+ * needs it (only class-flow planners like Mongo populate `describe()` from
+ * `fromHash`).
+ */
+export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
   constructor(private readonly config: PlannerConfig) {}
 
-  plan(options: SqlMigrationPlannerPlanOptions) {
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly fromHash?: string;
+    readonly schemaName?: string;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): PostgresPlanResult {
+    return this.planSql(options as SqlMigrationPlannerPlanOptions);
+  }
+
+  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {
+    return {
+      targetId: 'postgres',
+      destination: { storageHash: context.toHash },
+      operations: [],
+      renderTypeScript(): string {
+        return renderDescriptorTypeScript([], context);
+      },
+    };
+  }
+
+  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {
     const schemaName = options.schemaName ?? this.config.defaultSchema;
     const policyResult = this.ensureAdditivePolicy(options.policy);
     if (policyResult) {
@@ -176,7 +245,15 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       operations,
     });
 
-    return plannerSuccess(plan);
+    return Object.freeze({
+      kind: 'success' as const,
+      plan: Object.freeze({
+        ...plan,
+        renderTypeScript(): string {
+          throw errorPlanDoesNotSupportAuthoringSurface({ targetId: 'postgres' });
+        },
+      }),
+    });
   }
 
   private ensureAdditivePolicy(policy: MigrationOperationPolicy) {

package/src/core/migrations/scaffolding.ts

@@ -0,0 +1,140 @@
+import type {
+  MigrationScaffoldContext,
+  OperationDescriptor,
+} from '@prisma-next/framework-components/control';
+import { relative } from 'pathe';
+
+/**
+ * Postgres's internal plan shape. Happens to be descriptor-shaped today — that
+ * is a target-internal choice; the framework has no opinion.
+ */
+type PostgresPlan = readonly OperationDescriptor[];
+
+function serializeQueryInput(input: unknown): string {
+  if (typeof input === 'boolean') return String(input);
+  if (typeof input === 'symbol') return 'TODO /* fill in using db.sql.from(...) */';
+  if (input === null || input === undefined) return 'null';
+  if (Array.isArray(input)) {
+    if (input.length === 0) return '[]';
+    if (input.every((item) => typeof item === 'symbol'))
+      return '[TODO /* fill in using db.sql.from(...) */]';
+    return `[${input.map(serializeQueryInput).join(', ')}]`;
+  }
+  return JSON.stringify(input);
+}
+
+function renderDescriptor(desc: OperationDescriptor): string {
+  switch (desc.kind) {
+    case 'createTable':
+      return `createTable(${JSON.stringify(desc['table'])})`;
+    case 'dropTable':
+      return `dropTable(${JSON.stringify(desc['table'])})`;
+    case 'addColumn': {
+      const args = [JSON.stringify(desc['table']), JSON.stringify(desc['column'])];
+      if (desc['overrides']) {
+        args.push(JSON.stringify(desc['overrides']));
+      }
+      return `addColumn(${args.join(', ')})`;
+    }
+    case 'dropColumn':
+      return `dropColumn(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])})`;
+    case 'alterColumnType': {
+      const opts: Record<string, unknown> = {};
+      if (desc['using']) opts['using'] = desc['using'];
+      if (desc['toType']) opts['toType'] = desc['toType'];
+      const hasOpts = Object.keys(opts).length > 0;
+      return hasOpts
+        ? `alterColumnType(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])}, ${JSON.stringify(opts)})`
+        : `alterColumnType(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])})`;
+    }
+    case 'setNotNull':
+      return `setNotNull(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])})`;
+    case 'dropNotNull':
+      return `dropNotNull(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])})`;
+    case 'setDefault':
+      return `setDefault(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])})`;
+    case 'dropDefault':
+      return `dropDefault(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['column'])})`;
+    case 'addPrimaryKey':
+      return `addPrimaryKey(${JSON.stringify(desc['table'])})`;
+    case 'addUnique':
+      return `addUnique(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['columns'])})`;
+    case 'addForeignKey':
+      return `addForeignKey(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['columns'])})`;
+    case 'dropConstraint':
+      return `dropConstraint(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['constraintName'])})`;
+    case 'createIndex':
+      return `createIndex(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['columns'])})`;
+    case 'dropIndex':
+      return `dropIndex(${JSON.stringify(desc['table'])}, ${JSON.stringify(desc['indexName'])})`;
+    case 'createEnumType':
+      return desc['values']
+        ? `createEnumType(${JSON.stringify(desc['typeName'])}, ${JSON.stringify(desc['values'])})`
+        : `createEnumType(${JSON.stringify(desc['typeName'])})`;
+    case 'addEnumValues':
+      return `addEnumValues(${JSON.stringify(desc['typeName'])}, ${JSON.stringify(desc['values'])})`;
+    case 'dropEnumType':
+      return `dropEnumType(${JSON.stringify(desc['typeName'])})`;
+    case 'renameType':
+      return `renameType(${JSON.stringify(desc['fromName'])}, ${JSON.stringify(desc['toName'])})`;
+    case 'createDependency':
+      return `createDependency(${JSON.stringify(desc['dependencyId'])})`;
+    case 'dataTransform':
+      return `dataTransform(${JSON.stringify(desc['name'])}, {\n    check: ${serializeQueryInput(desc['check'])},\n    run: ${serializeQueryInput(desc['run'])},\n  })`;
+    default:
+      throw new Error(`Unknown Postgres descriptor kind: ${desc.kind}`);
+  }
+}
+
+function renderPreamble(
+  plan: PostgresPlan,
+  context: MigrationScaffoldContext,
+): ReadonlyArray<string> {
+  const hasDataTransform = plan.some((d) => d.kind === 'dataTransform');
+
+  if (hasDataTransform && context.contractJsonPath) {
+    const relativeContractDts = relative(context.packageDir, context.contractJsonPath).replace(
+      /\.json$/,
+      '.d',
+    );
+    const importList = [...new Set(plan.map((d) => d.kind))];
+    importList.push('TODO');
+    return [
+      `import type { Contract } from "${relativeContractDts}"`,
+      `import { createBuilders } from "@prisma-next/target-postgres/migration-builders"`,
+      '',
+      `const { ${importList.join(', ')} } = createBuilders<Contract>()`,
+    ];
+  }
+
+  const importList = [...new Set(plan.map((d) => d.kind))];
+  if (importList.length === 0) {
+    importList.push('createTable');
+  }
+  if (hasDataTransform) {
+    importList.push('TODO');
+  }
+  return [
+    `import { ${importList.join(', ')} } from "@prisma-next/target-postgres/migration-builders"`,
+  ];
+}
+
+/**
+ * Render a Postgres descriptor list to a `migration.ts` source string.
+ *
+ * Internal to the Postgres target — no longer part of the framework SPI.
+ * Invoked from two paths:
+ *  - the migrations capability's `renderDescriptorTypeScript` hook (called by
+ *    the CLI after `planWithDescriptors` to seed an editable authoring
+ *    surface, and by `emptyMigration()` to produce the `migration new` stub);
+ *  - directly by this package's unit tests.
+ */
+export function renderDescriptorTypeScript(
+  descriptors: readonly OperationDescriptor[],
+  context: MigrationScaffoldContext,
+): string {
+  const preamble = renderPreamble(descriptors, context);
+  const calls = descriptors.map((d) => `  ${renderDescriptor(d)},`);
+  const body = calls.length > 0 ? `\n${calls.join('\n')}\n` : '';
+  return [...preamble, '', `export default () => [${body}]`, ''].join('\n');
+}

package/src/exports/control.ts

@@ -17,7 +17,6 @@ import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlTargetInstance,
-  MigrationPlanner,
   MigrationRunner,
   OperationDescriptor,
 } from '@prisma-next/framework-components/control';
@@ -33,6 +32,7 @@ import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
 import { createPostgresMigrationRunner } from '../core/migrations/runner';
+import { renderDescriptorTypeScript } from '../core/migrations/scaffolding';
 
 function parseDescriptors(descriptors: readonly OperationDescriptor[]) {
   const result = MigrationDescriptorArraySchema([...descriptors]);
@@ -127,7 +127,7 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
     ...postgresTargetDescriptorMeta,
     migrations: {
       createPlanner(_family: SqlControlFamilyInstance) {
-        return createPostgresMigrationPlanner() as MigrationPlanner<'sql', 'postgres'>;
+        return createPostgresMigrationPlanner();
       },
       createRunner(family) {
         return createPostgresMigrationRunner(family) as MigrationRunner<'sql', 'postgres'>;
@@ -199,6 +199,9 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           db,
         });
       },
+      renderDescriptorTypeScript(descriptors, context) {
+        return renderDescriptorTypeScript(descriptors, context);
+      },
     },
     create(): ControlTargetInstance<'sql', 'postgres'> {
       return {