@prisma-next/target-postgres 0.4.0-dev.8 → 0.4.1

package/src/core/migrations/operations/enums.ts

@@ -0,0 +1,113 @@
+import { escapeLiteral, qualifyName, quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import { type Op, step, targetDetails } from './shared';
+
+function enumTypeExistsCheck(schemaName: string, nativeType: string, exists = true): string {
+  const clause = exists ? 'EXISTS' : 'NOT EXISTS';
+  return `SELECT ${clause} (
+  SELECT 1
+  FROM pg_type t
+  JOIN pg_namespace n ON t.typnamespace = n.oid
+  WHERE n.nspname = '${escapeLiteral(schemaName)}'
+    AND t.typname = '${escapeLiteral(nativeType)}'
+)`;
+}
+
+export function createEnumType(
+  schemaName: string,
+  typeName: string,
+  values: readonly string[],
+): Op {
+  const qualifiedType = qualifyName(schemaName, typeName);
+  const literalValues = values.map((v) => `'${escapeLiteral(v)}'`).join(', ');
+  return {
+    id: `type.${typeName}`,
+    label: `Create enum type "${typeName}"`,
+    operationClass: 'additive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [
+      step(
+        `ensure type "${typeName}" does not exist`,
+        enumTypeExistsCheck(schemaName, typeName, false),
+      ),
+    ],
+    execute: [
+      step(
+        `create enum type "${typeName}"`,
+        `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`,
+      ),
+    ],
+    postcheck: [
+      step(`verify type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName)),
+    ],
+  };
+}
+
+/**
+ * `typeName` is the contract-facing type name (used for id/label).
+ * `nativeType` is the Postgres type name to mutate (may differ for external types).
+ */
+export function addEnumValues(
+  schemaName: string,
+  typeName: string,
+  nativeType: string,
+  values: readonly string[],
+): Op {
+  const qualifiedType = qualifyName(schemaName, nativeType);
+  return {
+    id: `type.${typeName}.addValues`,
+    label: `Add values to enum type "${typeName}": ${values.join(', ')}`,
+    operationClass: 'additive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [
+      step(`ensure type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType)),
+    ],
+    execute: values.map((value) =>
+      step(
+        `add value '${value}' to enum "${nativeType}"`,
+        `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`,
+      ),
+    ),
+    postcheck: [
+      step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType)),
+    ],
+  };
+}
+
+export function dropEnumType(schemaName: string, typeName: string): Op {
+  const qualified = qualifyName(schemaName, typeName);
+  return {
+    id: `type.${typeName}.drop`,
+    label: `Drop enum type "${typeName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [step(`ensure type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))],
+    execute: [step(`drop enum type "${typeName}"`, `DROP TYPE ${qualified}`)],
+    postcheck: [
+      step(`verify type "${typeName}" removed`, enumTypeExistsCheck(schemaName, typeName, false)),
+    ],
+  };
+}
+
+export function renameType(schemaName: string, fromName: string, toName: string): Op {
+  const qualifiedFrom = qualifyName(schemaName, fromName);
+  return {
+    id: `type.${fromName}.rename`,
+    label: `Rename type "${fromName}" to "${toName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('type', fromName, schemaName),
+    precheck: [
+      step(`ensure type "${fromName}" exists`, enumTypeExistsCheck(schemaName, fromName)),
+      step(
+        `ensure type "${toName}" does not already exist`,
+        enumTypeExistsCheck(schemaName, toName, false),
+      ),
+    ],
+    execute: [
+      step(
+        `rename type "${fromName}" to "${toName}"`,
+        `ALTER TYPE ${qualifiedFrom} RENAME TO ${quoteIdentifier(toName)}`,
+      ),
+    ],
+    postcheck: [step(`verify type "${toName}" exists`, enumTypeExistsCheck(schemaName, toName))],
+  };
+}

package/src/core/migrations/operations/indexes.ts

@@ -0,0 +1,61 @@
+import { quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
+import { type Op, step, targetDetails } from './shared';
+
+export function createIndex(
+  schemaName: string,
+  tableName: string,
+  indexName: string,
+  columns: readonly string[],
+): Op {
+  const qualified = qualifyTableName(schemaName, tableName);
+  const columnList = columns.map(quoteIdentifier).join(', ');
+  return {
+    id: `index.${tableName}.${indexName}`,
+    label: `Create index "${indexName}" on "${tableName}"`,
+    operationClass: 'additive',
+    target: targetDetails('index', indexName, schemaName, tableName),
+    precheck: [
+      step(
+        `ensure index "${indexName}" does not exist`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
+      ),
+    ],
+    execute: [
+      step(
+        `create index "${indexName}"`,
+        `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified} (${columnList})`,
+      ),
+    ],
+    postcheck: [
+      step(
+        `verify index "${indexName}" exists`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
+      ),
+    ],
+  };
+}
+
+export function dropIndex(schemaName: string, tableName: string, indexName: string): Op {
+  return {
+    id: `dropIndex.${tableName}.${indexName}`,
+    label: `Drop index "${indexName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('index', indexName, schemaName, tableName),
+    precheck: [
+      step(
+        `ensure index "${indexName}" exists`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
+      ),
+    ],
+    execute: [
+      step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`),
+    ],
+    postcheck: [
+      step(
+        `verify index "${indexName}" does not exist`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
+      ),
+    ],
+  };
+}

package/src/core/migrations/operations/raw.ts

@@ -0,0 +1,15 @@
+import type { Op } from './shared';
+
+/**
+ * Identity factory for an already-materialized `SqlMigrationPlanOperation`.
+ *
+ * The planner uses this via `liftOpToCall` to carry ops produced by SQL
+ * family methods, codec control hooks, and component database dependencies
+ * alongside migration IR without reverse-engineering them. Users writing
+ * raw migrations can pass a full op shape directly — typically built by
+ * composing SQL family helpers — to author a migration that bypasses the
+ * structured call classes.
+ */
+export function rawSql(op: Op): Op {
+  return op;
+}

package/src/core/migrations/operations/shared.ts

@@ -0,0 +1,67 @@
+import { quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { ReferentialAction } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { OperationClass, PostgresPlanTargetDetails } from '../planner-target-details';
+
+export type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+
+/**
+ * Literal-args shape for a column definition consumed by `createTable` and
+ * `addColumn`. Fully materialized: codec expansion and default rendering have
+ * already happened in the wrapper.
+ *
+ * - `typeSql` is the column's DDL type string (e.g. `"integer"`, `"SERIAL"`,
+ *   `"varchar(100)"`), already produced by `buildColumnTypeSql` in the
+ *   call-factory wrapper.
+ * - `defaultSql` is the full `DEFAULT …` clause (e.g. `"DEFAULT 42"`) or an
+ *   empty string when the column has no default, matching
+ *   `buildColumnDefaultSql`'s output.
+ */
+export interface ColumnSpec {
+  readonly name: string;
+  readonly typeSql: string;
+  readonly defaultSql: string;
+  readonly nullable: boolean;
+}
+
+/**
+ * Literal-args shape for a foreign key definition. The referenced table is
+ * assumed to live in the same schema as the constrained table.
+ */
+export interface ForeignKeySpec {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly table: string;
+    readonly columns: readonly string[];
+  };
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+}
+
+export function step(description: string, sql: string) {
+  return { description, sql };
+}
+
+export function targetDetails(
+  objectType: OperationClass,
+  name: string,
+  schema: string,
+  table?: string,
+): { readonly id: 'postgres'; readonly details: PostgresPlanTargetDetails } {
+  return {
+    id: 'postgres',
+    details: { schema, objectType, name, ...ifDefined('table', table) },
+  };
+}
+
+export function renderColumnDefinition(column: ColumnSpec): string {
+  const parts = [
+    quoteIdentifier(column.name),
+    column.typeSql,
+    column.defaultSql,
+    column.nullable ? '' : 'NOT NULL',
+  ].filter(Boolean);
+  return parts.join(' ');
+}

package/src/core/migrations/operations/tables.ts

@@ -0,0 +1,63 @@
+import { quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
+import { type ColumnSpec, type Op, renderColumnDefinition, step, targetDetails } from './shared';
+
+export function createTable(
+  schemaName: string,
+  tableName: string,
+  columns: ReadonlyArray<ColumnSpec>,
+  primaryKey?: { readonly columns: readonly string[] },
+): Op {
+  const qualified = qualifyTableName(schemaName, tableName);
+  const columnDefs = columns.map(renderColumnDefinition);
+  const constraintDefs: string[] = [];
+  if (primaryKey) {
+    constraintDefs.push(`PRIMARY KEY (${primaryKey.columns.map(quoteIdentifier).join(', ')})`);
+  }
+  const allDefs = [...columnDefs, ...constraintDefs];
+  const createSql = `CREATE TABLE ${qualified} (\n  ${allDefs.join(',\n  ')}\n)`;
+
+  return {
+    id: `table.${tableName}`,
+    label: `Create table "${tableName}"`,
+    summary: `Creates table "${tableName}"`,
+    operationClass: 'additive',
+    target: targetDetails('table', tableName, schemaName),
+    precheck: [
+      step(
+        `ensure table "${tableName}" does not exist`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
+      ),
+    ],
+    execute: [step(`create table "${tableName}"`, createSql)],
+    postcheck: [
+      step(
+        `verify table "${tableName}" exists`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`,
+      ),
+    ],
+  };
+}
+
+export function dropTable(schemaName: string, tableName: string): Op {
+  const qualified = qualifyTableName(schemaName, tableName);
+  return {
+    id: `dropTable.${tableName}`,
+    label: `Drop table "${tableName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('table', tableName, schemaName),
+    precheck: [
+      step(
+        `ensure table "${tableName}" exists`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`,
+      ),
+    ],
+    execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
+    postcheck: [
+      step(
+        `verify table "${tableName}" does not exist`,
+        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
+      ),
+    ],
+  };
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Planner-produced Postgres migration.
+ *
+ * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.
+ * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside
+ * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)
+ * and the TypeScript authoring view (`renderTypeScript()`). Satisfies
+ * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any
+ * planner result back to `migration.ts`.
+ *
+ * Extends the family-level `SqlMigration` alias rather than the target-local
+ * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`
+ * shape and keeps CLI wiring one step removed from target internals.
+ *
+ * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds
+ * `() => placeholder("slot")` at each stub. `operations`, in contrast, is
+ * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`
+ * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered
+ * to a runtime op. Callers that know a plan may carry stubs must render to
+ * `migration.ts`, let the user fill the slots, and re-load the edited
+ * migration before enumerating ops. The walk-schema planner does not emit
+ * `DataTransformCall`s today, so this asymmetry is invisible until the
+ * issue-planner integration lands in Phase 2.
+ */
+
+import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';
+import type { MigrationMeta } from '@prisma-next/migration-tools/migration';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { PostgresOpFactoryCall } from './op-factory-call';
+import type { PostgresPlanTargetDetails } from './planner-target-details';
+import { PostgresMigration } from './postgres-migration';
+import { renderOps } from './render-ops';
+import { renderCallsToTypeScript } from './render-typescript';
+
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+
+export class TypeScriptRenderablePostgresMigration
+  extends PostgresMigration
+  implements MigrationPlanWithAuthoringSurface
+{
+  readonly #calls: readonly PostgresOpFactoryCall[];
+  readonly #meta: MigrationMeta;
+
+  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {
+    super();
+    this.#calls = calls;
+    this.#meta = meta;
+  }
+
+  override get operations(): readonly Op[] {
+    return renderOps(this.#calls);
+  }
+
+  override describe(): MigrationMeta {
+    return this.#meta;
+  }
+
+  renderTypeScript(): string {
+    return renderCallsToTypeScript(this.#calls, {
+      from: this.#meta.from,
+      to: this.#meta.to,
+      ...ifDefined('kind', this.#meta.kind),
+      ...ifDefined('labels', this.#meta.labels),
+    });
+  }
+}