@prisma-next/target-postgres 0.3.0-pr.99.6 → 0.4.0-dev.2

package/src/core/migrations/planner-schema-lookup.ts

@@ -0,0 +1,54 @@
+import type { ForeignKey } from '@prisma-next/sql-contract/types';
+import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+
+/**
+ * Pre-computed lookup sets for a schema table's constraints.
+ * Converts O(n*m) linear scans to O(1) Set lookups per constraint check.
+ */
+export interface SchemaTableLookup {
+  readonly uniqueKeys: Set<string>;
+  readonly indexKeys: Set<string>;
+  readonly uniqueIndexKeys: Set<string>;
+  readonly fkKeys: Set<string>;
+}
+
+export function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, SchemaTableLookup> {
+  const map = new Map<string, SchemaTableLookup>();
+  for (const [tableName, table] of Object.entries(schema.tables)) {
+    map.set(tableName, buildSchemaTableLookup(table));
+  }
+  return map;
+}
+
+function buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTableLookup {
+  const uniqueKeys = new Set(table.uniques.map((u) => u.columns.join(',')));
+  const indexKeys = new Set(table.indexes.map((i) => i.columns.join(',')));
+  const uniqueIndexKeys = new Set(
+    table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),
+  );
+  const fkKeys = new Set(
+    table.foreignKeys.map(
+      (fk) => `${fk.columns.join(',')}|${fk.referencedTable}|${fk.referencedColumns.join(',')}`,
+    ),
+  );
+  return { uniqueKeys, indexKeys, uniqueIndexKeys, fkKeys };
+}
+
+export function hasUniqueConstraint(
+  lookup: SchemaTableLookup,
+  columns: readonly string[],
+): boolean {
+  const key = columns.join(',');
+  return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);
+}
+
+export function hasIndex(lookup: SchemaTableLookup, columns: readonly string[]): boolean {
+  const key = columns.join(',');
+  return lookup.indexKeys.has(key) || lookup.uniqueKeys.has(key);
+}
+
+export function hasForeignKey(lookup: SchemaTableLookup, fk: ForeignKey): boolean {
+  return lookup.fkKeys.has(
+    `${fk.columns.join(',')}|${fk.references.table}|${fk.references.columns.join(',')}`,
+  );
+}

package/src/core/migrations/planner-sql-checks.ts

@@ -0,0 +1,322 @@
+import { escapeLiteral, quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import type { CodecControlHooks } from '@prisma-next/family-sql/control';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import { resolveColumnTypeMetadata } from './planner-type-resolution';
+
+export function qualifyTableName(schema: string, table: string): string {
+  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+
+export function toRegclassLiteral(schema: string, name: string): string {
+  const regclass = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+  return `'${escapeLiteral(regclass)}'`;
+}
+
+/**
+ * When `table` is omitted the check matches by name + schema across all tables.
+ * Pass `table` to scope the check to a single table (prevents false matches on
+ * identically-named constraints in different tables).
+ */
+export function constraintExistsCheck({
+  constraintName,
+  schema,
+  table,
+  exists = true,
+}: {
+  constraintName: string;
+  schema: string;
+  table?: string;
+  exists?: boolean;
+}): string {
+  const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';
+  const tableFilter = table
+    ? `AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})`
+    : '';
+  return `SELECT ${existsClause} (
+  SELECT 1 FROM pg_constraint c
+  JOIN pg_namespace n ON c.connamespace = n.oid
+  WHERE c.conname = '${escapeLiteral(constraintName)}'
+  AND n.nspname = '${escapeLiteral(schema)}'
+  ${tableFilter}
+)`;
+}
+
+export function columnExistsCheck({
+  schema,
+  table,
+  column,
+  exists = true,
+}: {
+  schema: string;
+  table: string;
+  column: string;
+  exists?: boolean;
+}): string {
+  const existsClause = exists ? '' : 'NOT ';
+  return `SELECT ${existsClause}EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(schema)}'
+    AND table_name = '${escapeLiteral(table)}'
+    AND column_name = '${escapeLiteral(column)}'
+)`;
+}
+
+export function columnNullabilityCheck({
+  schema,
+  table,
+  column,
+  nullable,
+}: {
+  schema: string;
+  table: string;
+  column: string;
+  nullable: boolean;
+}): string {
+  const expected = nullable ? 'YES' : 'NO';
+  return `SELECT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(schema)}'
+    AND table_name = '${escapeLiteral(table)}'
+    AND column_name = '${escapeLiteral(column)}'
+    AND is_nullable = '${expected}'
+)`;
+}
+
+export function tableIsEmptyCheck(qualifiedTableName: string): string {
+  return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
+}
+
+export function columnHasNoDefaultCheck(opts: {
+  schema: string;
+  table: string;
+  column: string;
+}): string {
+  return `SELECT NOT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(opts.schema)}'
+    AND table_name = '${escapeLiteral(opts.table)}'
+    AND column_name = '${escapeLiteral(opts.column)}'
+    AND column_default IS NOT NULL
+)`;
+}
+
+const FORMAT_TYPE_DISPLAY: ReadonlyMap<string, string> = new Map([
+  ['int2', 'smallint'],
+  ['int4', 'integer'],
+  ['int8', 'bigint'],
+  ['float4', 'real'],
+  ['float8', 'double precision'],
+  ['bool', 'boolean'],
+  ['timestamp', 'timestamp without time zone'],
+  ['timestamptz', 'timestamp with time zone'],
+  ['time', 'time without time zone'],
+  ['timetz', 'time with time zone'],
+]);
+
+const UNQUOTED_POSTGRES_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/;
+
+const POSTGRES_RESERVED_IDENTIFIER_WORDS = new Set([
+  'all',
+  'analyse',
+  'analyze',
+  'and',
+  'any',
+  'array',
+  'as',
+  'asc',
+  'asymmetric',
+  'authorization',
+  'between',
+  'binary',
+  'both',
+  'case',
+  'cast',
+  'check',
+  'collate',
+  'column',
+  'constraint',
+  'create',
+  'current_catalog',
+  'current_date',
+  'current_role',
+  'current_time',
+  'current_timestamp',
+  'current_user',
+  'default',
+  'deferrable',
+  'desc',
+  'distinct',
+  'do',
+  'else',
+  'end',
+  'except',
+  'false',
+  'fetch',
+  'for',
+  'foreign',
+  'freeze',
+  'from',
+  'full',
+  'grant',
+  'group',
+  'having',
+  'ilike',
+  'in',
+  'initially',
+  'inner',
+  'intersect',
+  'into',
+  'is',
+  'isnull',
+  'join',
+  'lateral',
+  'leading',
+  'left',
+  'like',
+  'limit',
+  'localtime',
+  'localtimestamp',
+  'natural',
+  'not',
+  'notnull',
+  'null',
+  'offset',
+  'on',
+  'only',
+  'or',
+  'order',
+  'outer',
+  'overlaps',
+  'placing',
+  'primary',
+  'references',
+  'right',
+  'select',
+  'session_user',
+  'similar',
+  'some',
+  'symmetric',
+  'table',
+  'then',
+  'to',
+  'trailing',
+  'true',
+  'union',
+  'unique',
+  'user',
+  'using',
+  'variadic',
+  'verbose',
+  'when',
+  'where',
+  'window',
+  'with',
+]);
+
+function formatUserDefinedTypeName(identifier: string): string {
+  if (
+    UNQUOTED_POSTGRES_IDENTIFIER_PATTERN.test(identifier) &&
+    !POSTGRES_RESERVED_IDENTIFIER_WORDS.has(identifier)
+  ) {
+    return identifier;
+  }
+
+  return quoteIdentifier(identifier);
+}
+
+export function buildExpectedFormatType(
+  column: StorageColumn,
+  codecHooks: Map<string, CodecControlHooks>,
+  storageTypes: Record<string, StorageTypeInstance> = {},
+): string {
+  const resolved = resolveColumnTypeMetadata(column, storageTypes);
+
+  if (resolved.typeParams && resolved.codecId) {
+    const hooks = codecHooks.get(resolved.codecId);
+    if (hooks?.expandNativeType) {
+      return hooks.expandNativeType({
+        nativeType: resolved.nativeType,
+        codecId: resolved.codecId,
+        typeParams: resolved.typeParams,
+      });
+    }
+  }
+
+  if (column.typeRef) {
+    return formatUserDefinedTypeName(resolved.nativeType);
+  }
+
+  return FORMAT_TYPE_DISPLAY.get(resolved.nativeType) ?? resolved.nativeType;
+}
+
+export function columnTypeCheck({
+  schema,
+  table,
+  column,
+  expectedType,
+}: {
+  schema: string;
+  table: string;
+  column: string;
+  expectedType: string;
+}): string {
+  return `SELECT EXISTS (
+  SELECT 1
+  FROM pg_attribute a
+  JOIN pg_class c ON c.oid = a.attrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE n.nspname = '${escapeLiteral(schema)}'
+    AND c.relname = '${escapeLiteral(table)}'
+    AND a.attname = '${escapeLiteral(column)}'
+    AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
+    AND NOT a.attisdropped
+)`;
+}
+
+export function columnDefaultExistsCheck({
+  schema,
+  table,
+  column,
+  exists = true,
+}: {
+  schema: string;
+  table: string;
+  column: string;
+  exists?: boolean;
+}): string {
+  const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';
+  return `SELECT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(schema)}'
+    AND table_name = '${escapeLiteral(table)}'
+    AND column_name = '${escapeLiteral(column)}'
+    AND column_default ${nullCheck}
+)`;
+}
+
+export function tableHasPrimaryKeyCheck(
+  schema: string,
+  table: string,
+  exists: boolean,
+  constraintName?: string,
+): string {
+  const comparison = exists ? '' : 'NOT ';
+  const constraintFilter = constraintName
+    ? `AND c2.relname = '${escapeLiteral(constraintName)}'`
+    : '';
+  return `SELECT ${comparison}EXISTS (
+  SELECT 1
+  FROM pg_index i
+  JOIN pg_class c ON c.oid = i.indrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid
+  WHERE n.nspname = '${escapeLiteral(schema)}'
+    AND c.relname = '${escapeLiteral(table)}'
+    AND i.indisprimary
+    ${constraintFilter}
+)`;
+}

package/src/core/migrations/planner-strategies.ts

@@ -0,0 +1,262 @@
+/**
+ * Migration strategies for the descriptor-based planner.
+ *
+ * Each strategy examines the issue list, consumes issues it handles,
+ * and returns the ops to handle them. The planner chains strategies,
+ * then handles whatever's left with default issue-to-descriptor mapping.
+ *
+ * Different strategy sets are used for different contexts:
+ * - `migration plan`: data-safe strategies (dataTransform for NOT NULL, type changes, etc.)
+ * - `db update`: dev-push strategies (temp defaults, destructive type changes, no data transforms)
+ */
+
+import type { Contract } from '@prisma-next/contract/types';
+import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import {
+  addColumn,
+  addEnumValues,
+  alterColumnType,
+  createEnumType,
+  dataTransform,
+  dropEnumType,
+  type PostgresMigrationOpDescriptor,
+  renameType,
+  setNotNull,
+  TODO,
+} from './operation-descriptors';
+
+// ============================================================================
+// Strategy types
+// ============================================================================
+
+/** Context passed to each migration strategy — the from/to contracts for the migration. */
+export interface StrategyContext {
+  readonly toContract: Contract<SqlStorage>;
+  readonly fromContract: Contract<SqlStorage> | null;
+}
+
+/**
+ * A migration strategy examines schema issues, consumes the ones it handles,
+ * and returns the descriptor ops to address them. Returns `'no_match'` if
+ * none of the issues are relevant. The planner chains strategies in order —
+ * earlier strategies consume issues before later ones see them.
+ */
+export type MigrationStrategy = (
+  issues: readonly SchemaIssue[],
+  context: StrategyContext,
+) =>
+  | { kind: 'match'; issues: readonly SchemaIssue[]; ops: readonly PostgresMigrationOpDescriptor[] }
+  | { kind: 'no_match' };
+
+// ============================================================================
+// Recipes
+// ============================================================================
+
+const REBUILD_SUFFIX = '__prisma_next_new';
+
+/**
+ * Produces the descriptor sequence for rebuilding a Postgres enum type:
+ *   createEnumType(temp, values) → alterColumnType(USING cast) per column → dropEnumType(old) → renameType(temp, old)
+ *
+ * Used by the enum change strategy for value removal and reorder scenarios.
+ * Finds all columns referencing the enum via `typeRef` in the destination contract.
+ */
+function enumRebuildRecipe(
+  typeName: string,
+  ctx: StrategyContext,
+): readonly PostgresMigrationOpDescriptor[] {
+  const toType = ctx.toContract.storage.types?.[typeName];
+  if (!toType) return [];
+  const nativeType = toType.nativeType;
+  const desiredValues = (toType.typeParams['values'] ?? []) as readonly string[];
+  const tempName = `${nativeType}${REBUILD_SUFFIX}`;
+
+  const columnRefs: { table: string; column: string }[] = [];
+  for (const [tableName, table] of Object.entries(ctx.toContract.storage.tables)) {
+    for (const [columnName, column] of Object.entries(table.columns)) {
+      if (column.typeRef === typeName) {
+        columnRefs.push({ table: tableName, column: columnName });
+      }
+    }
+  }
+
+  return [
+    createEnumType(tempName, desiredValues),
+    ...columnRefs.map((ref) =>
+      alterColumnType(ref.table, ref.column, {
+        toType: tempName,
+        using: `${ref.column}::text::${tempName}`,
+      }),
+    ),
+    dropEnumType(nativeType),
+    renameType(tempName, nativeType),
+  ];
+}
+
+// ============================================================================
+// Data-safe strategies (for `migration plan`)
+// ============================================================================
+
+/**
+ * NOT NULL backfill strategy.
+ *
+ * When a missing column is NOT NULL without a default, the planner can't just
+ * add it — existing rows would violate the constraint. Instead, emit:
+ *   addColumn(nullable) → dataTransform (user fills in backfill) → setNotNull
+ */
+export const notNullBackfillStrategy: MigrationStrategy = (issues, ctx) => {
+  const matched: SchemaIssue[] = [];
+  const ops: PostgresMigrationOpDescriptor[] = [];
+
+  for (const issue of issues) {
+    if (issue.kind !== 'missing_column' || !issue.table || !issue.column) continue;
+
+    const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+    if (!column) continue;
+    if (column.nullable === true || column.default !== undefined) continue;
+
+    matched.push(issue);
+    ops.push(
+      addColumn(issue.table, issue.column, { nullable: true }),
+      dataTransform(`backfill-${issue.table}-${issue.column}`, {
+        check: TODO,
+        run: TODO,
+      }),
+      setNotNull(issue.table, issue.column),
+    );
+  }
+
+  if (matched.length === 0) return { kind: 'no_match' };
+  return {
+    kind: 'match',
+    issues: issues.filter((i) => !matched.includes(i)),
+    ops,
+  };
+};
+
+/**
+ * Unsafe type change strategy.
+ *
+ * Safe widenings (int4 → int8) emit alterColumnType directly.
+ * Unsafe changes emit dataTransform for user to handle conversion.
+ */
+export const typeChangeStrategy: MigrationStrategy = (issues, ctx) => {
+  const matched: SchemaIssue[] = [];
+  const ops: PostgresMigrationOpDescriptor[] = [];
+
+  const SAFE_WIDENINGS = new Set(['int2→int4', 'int2→int8', 'int4→int8', 'float4→float8']);
+  function isSafeWidening(fromType: string, toType: string): boolean {
+    return SAFE_WIDENINGS.has(`${fromType}→${toType}`);
+  }
+
+  for (const issue of issues) {
+    if (issue.kind !== 'type_mismatch') continue;
+    if (!issue.table || !issue.column) continue;
+    const fromColumn = ctx.fromContract?.storage.tables[issue.table]?.columns[issue.column];
+    const toColumn = ctx.toContract?.storage.tables[issue.table]?.columns[issue.column];
+    if (!fromColumn || !toColumn) continue;
+    const fromType = fromColumn.nativeType;
+    const toType = toColumn.nativeType;
+    if (fromType === toType) continue;
+    matched.push(issue);
+    if (isSafeWidening(fromType, toType)) {
+      ops.push(alterColumnType(issue.table, issue.column));
+    } else {
+      ops.push(
+        dataTransform(`typechange-${issue.table}-${issue.column}`, {
+          check: TODO,
+          run: TODO,
+        }),
+        alterColumnType(issue.table, issue.column),
+      );
+    }
+  }
+  if (matched.length === 0) return { kind: 'no_match' };
+  return {
+    kind: 'match',
+    issues: issues.filter((i) => !matched.includes(i)),
+    ops,
+  };
+};
+
+/**
+ * Nullable → NOT NULL tightening strategy.
+ *
+ * When an existing column changes from nullable to NOT NULL, existing rows
+ * may have NULLs that violate the constraint. Emit:
+ *   dataTransform (user fills in NULL handling) → setNotNull
+ */
+export const nullableTighteningStrategy: MigrationStrategy = (issues, ctx) => {
+  const matched: SchemaIssue[] = [];
+  const ops: PostgresMigrationOpDescriptor[] = [];
+
+  for (const issue of issues) {
+    if (issue.kind !== 'nullability_mismatch' || !issue.table || !issue.column) continue;
+
+    const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+    if (!column) continue;
+    if (column.nullable === true) continue;
+
+    matched.push(issue);
+    ops.push(
+      dataTransform(`handle-nulls-${issue.table}-${issue.column}`, {
+        check: TODO,
+        run: TODO,
+      }),
+      setNotNull(issue.table, issue.column),
+    );
+  }
+
+  if (matched.length === 0) return { kind: 'no_match' };
+  return {
+    kind: 'match',
+    issues: issues.filter((i) => !matched.includes(i)),
+    ops,
+  };
+};
+
+/**
+ * Enum value change strategy.
+ *
+ * When enum values change between contracts:
+ * - Add only → addEnumValues
+ * - Reorder (same values, different order) → rebuild recipe (no data transform)
+ * - Removal → dataTransform (user migrates rows) + rebuild recipe
+ */
+export const enumChangeStrategy: MigrationStrategy = (issues, ctx) => {
+  const matched: SchemaIssue[] = [];
+  const ops: PostgresMigrationOpDescriptor[] = [];
+
+  for (const issue of issues) {
+    if (issue.kind !== 'enum_values_changed') continue;
+    matched.push(issue);
+
+    if (issue.removedValues.length > 0) {
+      ops.push(
+        dataTransform(`migrate-${issue.typeName}-values`, { check: TODO, run: TODO }),
+        ...enumRebuildRecipe(issue.typeName, ctx),
+      );
+    } else if (issue.addedValues.length === 0) {
+      // Reorder only — rebuild without data transform
+      ops.push(...enumRebuildRecipe(issue.typeName, ctx));
+    } else {
+      ops.push(addEnumValues(issue.typeName, issue.addedValues));
+    }
+  }
+
+  if (matched.length === 0) return { kind: 'no_match' };
+  return {
+    kind: 'match',
+    issues: issues.filter((i) => !matched.includes(i)),
+    ops,
+  };
+};
+
+/** Default strategy set for `migration plan` — data-safe, requires user input for destructive changes. */
+export const migrationPlanStrategies: readonly MigrationStrategy[] = [
+  enumChangeStrategy,
+  notNullBackfillStrategy,
+  typeChangeStrategy,
+  nullableTighteningStrategy,
+];

package/src/core/migrations/planner-target-details.ts

@@ -0,0 +1,38 @@
+import { ifDefined } from '@prisma-next/utils/defined';
+
+export type OperationClass =
+  | 'dependency'
+  | 'type'
+  | 'table'
+  | 'column'
+  | 'primaryKey'
+  | 'unique'
+  | 'index'
+  | 'foreignKey';
+
+export interface PostgresPlanTargetDetails {
+  readonly schema: string;
+  readonly objectType: OperationClass;
+  readonly name: string;
+  readonly table?: string;
+}
+
+export interface PlanningMode {
+  readonly includeExtraObjects: boolean;
+  readonly allowWidening: boolean;
+  readonly allowDestructive: boolean;
+}
+
+export function buildTargetDetails(
+  objectType: OperationClass,
+  name: string,
+  schema: string,
+  table?: string,
+): PostgresPlanTargetDetails {
+  return {
+    schema,
+    objectType,
+    name,
+    ...ifDefined('table', table),
+  };
+}

package/src/core/migrations/planner-type-resolution.ts

@@ -0,0 +1,26 @@
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+
+export type ResolvedColumnTypeMetadata = Pick<
+  StorageColumn,
+  'nativeType' | 'codecId' | 'typeParams'
+>;
+
+export function resolveColumnTypeMetadata(
+  column: StorageColumn,
+  storageTypes: Record<string, StorageTypeInstance>,
+): ResolvedColumnTypeMetadata {
+  if (!column.typeRef) {
+    return column;
+  }
+
+  const referencedType = storageTypes[column.typeRef];
+  if (!referencedType) {
+    return column;
+  }
+
+  return {
+    codecId: referencedType.codecId,
+    nativeType: referencedType.nativeType,
+    typeParams: referencedType.typeParams,
+  };
+}