@prisma-next/target-postgres 0.3.0-dev.113 → 0.3.0-dev.114

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.3.0-dev.113",
+  "version": "0.3.0-dev.114",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/cli": "0.3.0-dev.113",
-    "@prisma-next/family-sql": "0.3.0-dev.113",
-    "@prisma-next/contract": "0.3.0-dev.113",
-    "@prisma-next/core-control-plane": "0.3.0-dev.113",
-    "@prisma-next/core-execution-plane": "0.3.0-dev.113",
-    "@prisma-next/sql-contract": "0.3.0-dev.113",
-    "@prisma-next/sql-errors": "0.3.0-dev.113",
-    "@prisma-next/sql-runtime": "0.3.0-dev.113",
-    "@prisma-next/utils": "0.3.0-dev.113",
-    "@prisma-next/sql-relational-core": "0.3.0-dev.113",
-    "@prisma-next/sql-schema-ir": "0.3.0-dev.113"
+    "@prisma-next/cli": "0.3.0-dev.114",
+    "@prisma-next/contract": "0.3.0-dev.114",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.114",
+    "@prisma-next/family-sql": "0.3.0-dev.114",
+    "@prisma-next/sql-contract": "0.3.0-dev.114",
+    "@prisma-next/sql-errors": "0.3.0-dev.114",
+    "@prisma-next/core-control-plane": "0.3.0-dev.114",
+    "@prisma-next/sql-runtime": "0.3.0-dev.114",
+    "@prisma-next/sql-schema-ir": "0.3.0-dev.114",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.114",
+    "@prisma-next/utils": "0.3.0-dev.114"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/adapter-postgres": "0.3.0-dev.113",
-    "@prisma-next/driver-postgres": "0.3.0-dev.113",
-    "@prisma-next/extension-pgvector": "0.3.0-dev.113",
+    "@prisma-next/extension-pgvector": "0.3.0-dev.114",
+    "@prisma-next/adapter-postgres": "0.3.0-dev.114",
     "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/driver-postgres": "0.3.0-dev.114"
   },
   "files": [
     "dist",

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

@@ -7,12 +7,17 @@ import type {
   SqlPlannerConflict,
 } from '@prisma-next/family-sql/control';
 import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
+import { invariant } from '@prisma-next/utils/assertions';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PlanningMode, PostgresPlanTargetDetails } from './planner';
 import {
+  buildColumnDefaultSql,
   buildColumnTypeSql,
+  buildExpectedFormatType,
+  columnDefaultExistsCheck,
   columnExistsCheck,
   columnNullabilityCheck,
+  columnTypeCheck,
   constraintExistsCheck,
   qualifyTableName,
   toRegclassLiteral,
@@ -189,11 +194,72 @@ function buildReconciliationOperationFromIssue(options: {
       );
     }
 
-    // Remaining issue kinds (default_missing, default_mismatch, primary_key_mismatch,
-    // unique_constraint_mismatch, index_mismatch, foreign_key_mismatch) do not yet have
-    // reconciliation operation builders. They fall through to the caller, which converts them to
-    // conflicts via convertIssueToConflict. When a new SchemaIssue kind is added, add a
-    // case here if the planner can emit an operation for it; otherwise it becomes a conflict.
+    case 'default_missing': {
+      if (!issue.table || !issue.column) {
+        return null;
+      }
+      const contractColMissing = getContractColumn(contract, issue.table, issue.column);
+      if (!contractColMissing) {
+        return null;
+      }
+      // NOTE: Being in the `default_missing` case means the verifier found the contract expects a default, so it should exist here. We must still narrow.
+      invariant(
+        contractColMissing.default !== undefined,
+        `default_missing issue for "${issue.table}"."${issue.column}" but contract column has no default`,
+      );
+      return buildDefaultOperation(
+        schemaName,
+        issue.table,
+        issue.column,
+        contractColMissing,
+        contractColMissing.default,
+        'additive',
+        'Set',
+      );
+    }
+
+    case 'default_mismatch': {
+      if (!issue.table || !issue.column) {
+        return null;
+      }
+      if (!mode.allowWidening) {
+        return null;
+      }
+      const contractColMismatch = getContractColumn(contract, issue.table, issue.column);
+      if (!contractColMismatch) {
+        return null;
+      }
+      // NOTE: Being in the `default_mismatch` case means the verifier found the contract expects a different default, so it should exist here. We must still narrow.
+      invariant(
+        contractColMismatch.default !== undefined,
+        `default_mismatch issue for "${issue.table}"."${issue.column}" but contract column has no default`,
+      );
+      return buildDefaultOperation(
+        schemaName,
+        issue.table,
+        issue.column,
+        contractColMismatch,
+        contractColMismatch.default,
+        'widening',
+        'Change',
+      );
+    }
+
+    case 'extra_default': {
+      if (!issue.table || !issue.column) {
+        return null;
+      }
+      if (!mode.allowDestructive) {
+        return null;
+      }
+      return buildDropDefaultOperation(schemaName, issue.table, issue.column);
+    }
+
+    // Remaining issue kinds (primary_key_mismatch, unique_constraint_mismatch,
+    // index_mismatch, foreign_key_mismatch) do not yet have reconciliation operation
+    // builders. They fall through to the caller, which converts them to conflicts via
+    // convertIssueToConflict. When a new SchemaIssue kind is added, add a case here if
+    // the planner can emit an operation for it; otherwise it becomes a conflict.
     default:
       return null;
   }
@@ -338,7 +404,7 @@ function buildDropConstraintOperation(
     precheck: [
       {
         description: `ensure constraint "${constraintName}" exists`,
-        sql: constraintExistsCheck({ constraintName, schema: schemaName }),
+        sql: constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
       },
     ],
     execute: [
@@ -351,7 +417,12 @@ DROP CONSTRAINT ${quoteIdentifier(constraintName)}`,
     postcheck: [
       {
         description: `verify constraint "${constraintName}" is removed`,
-        sql: constraintExistsCheck({ constraintName, schema: schemaName, exists: false }),
+        sql: constraintExistsCheck({
+          constraintName,
+          schema: schemaName,
+          table: tableName,
+          exists: false,
+        }),
       },
     ],
   };
@@ -488,10 +559,106 @@ USING ${quoteIdentifier(columnName)}::${expectedType}`,
     ],
     postcheck: [
       {
-        description: `verify column "${columnName}" exists after type change`,
+        description: `verify column "${columnName}" has type ${expectedType}`,
+        sql: columnTypeCheck({
+          schema: schemaName,
+          table: tableName,
+          column: columnName,
+          expectedType: buildExpectedFormatType(column, codecHooks),
+        }),
+      },
+    ],
+  };
+}
+
+function buildDefaultOperation(
+  schemaName: string,
+  tableName: string,
+  columnName: string,
+  column: Omit<StorageColumn, 'default'>,
+  columnDefault: NonNullable<StorageColumn['default']>,
+  operationClass: 'additive' | 'widening',
+  verb: 'Set' | 'Change',
+): SqlMigrationPlanOperation<PostgresPlanTargetDetails> | null {
+  const qualified = qualifyTableName(schemaName, tableName);
+  const defaultClause = buildColumnDefaultSql(columnDefault, column);
+  // autoincrement defaults are handled by SERIAL types — buildColumnDefaultSql returns ''
+  // for them. Until the IR is enriched to distinguish autoincrement (TML-2107), skip.
+  if (!defaultClause) return null;
+  const verbLower = verb.toLowerCase();
+  return {
+    id: `setDefault.${tableName}.${columnName}`,
+    label: `${verb} default for ${columnName} on ${tableName}`,
+    summary: `${verb}s default on column ${columnName} of table ${tableName}`,
+    operationClass,
+    target: {
+      id: 'postgres',
+      details: buildTargetDetails('column', columnName, schemaName, tableName),
+    },
+    precheck: [
+      {
+        description: `ensure column "${columnName}" exists`,
         sql: columnExistsCheck({ schema: schemaName, table: tableName, column: columnName }),
       },
     ],
+    execute: [
+      {
+        description: `${verbLower} default on "${columnName}"`,
+        sql: `ALTER TABLE ${qualified}\nALTER COLUMN ${quoteIdentifier(columnName)} SET ${defaultClause}`,
+      },
+    ],
+    postcheck: [
+      {
+        description: `verify column "${columnName}" has a default`,
+        sql: columnDefaultExistsCheck({
+          schema: schemaName,
+          table: tableName,
+          column: columnName,
+          exists: true,
+        }),
+      },
+    ],
+  };
+}
+
+function buildDropDefaultOperation(
+  schemaName: string,
+  tableName: string,
+  columnName: string,
+): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  const qualified = qualifyTableName(schemaName, tableName);
+  return {
+    id: `dropDefault.${tableName}.${columnName}`,
+    label: `Drop default for ${columnName} on ${tableName}`,
+    summary: `Drops default on column ${columnName} of table ${tableName}`,
+    operationClass: 'destructive',
+    target: {
+      id: 'postgres',
+      details: buildTargetDetails('column', columnName, schemaName, tableName),
+    },
+    precheck: [
+      {
+        description: `ensure column "${columnName}" exists`,
+        sql: columnExistsCheck({ schema: schemaName, table: tableName, column: columnName }),
+      },
+    ],
+    execute: [
+      {
+        description: `drop default on "${columnName}"`,
+        sql: `ALTER TABLE ${qualified}\nALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`,
+      },
+    ],
+    postcheck: [
+      {
+        description: `verify column "${columnName}" has no default`,
+        sql: columnDefaultExistsCheck({
+          schema: schemaName,
+          table: tableName,
+          column: columnName,
+          exists: false,
+        }),
+      },
+    ],
   };
 }
 
@@ -507,6 +674,7 @@ function convertIssueToConflict(issue: SchemaIssue): SqlPlannerConflict | null {
       return buildConflict('nullabilityConflict', issue);
     case 'default_missing':
     case 'default_mismatch':
+    case 'extra_default':
     case 'extra_table':
     case 'extra_column':
     case 'extra_primary_key':

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

@@ -126,7 +126,7 @@ function renderParameterizedTypeSql(
   return expanded !== column.nativeType ? expanded : null;
 }
 
-function buildColumnDefaultSql(
+export function buildColumnDefaultSql(
   columnDefault: PostgresColumnDefault | undefined,
   column?: StorageColumn,
 ): string {
@@ -192,10 +192,12 @@ export function toRegclassLiteral(schema: string, name: string): string {
 export function constraintExistsCheck({
   constraintName,
   schema,
+  table,
   exists = true,
 }: {
   constraintName: string;
   schema: string;
+  table: string;
   exists?: boolean;
 }): string {
   const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';
@@ -204,6 +206,7 @@ export function constraintExistsCheck({
   JOIN pg_namespace n ON c.connamespace = n.oid
   WHERE c.conname = '${escapeLiteral(constraintName)}'
   AND n.nspname = '${escapeLiteral(schema)}'
+  AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})
 )`;
 }
 
@@ -250,6 +253,111 @@ export function columnNullabilityCheck({
 )`;
 }
 
+/**
+ * Maps contract native type names to the display form returned by PostgreSQL's
+ * `format_type()`. Base types use short names in the contract (e.g., `int4`)
+ * but `format_type()` returns SQL-standard names (e.g., `integer`).
+ *
+ * NOTE: The inverse mapping lives in `normalizeFormattedType` in control-adapter.ts.
+ * These two maps must stay in sync. A shared bidirectional map in
+ * @prisma-next/adapter-postgres would eliminate the drift risk.
+ */
+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'],
+]);
+
+/**
+ * Builds the string that `format_type(atttypid, atttypmod)` would return for a
+ * contract column. Used for postchecks — separate from `buildColumnTypeSql` which
+ * produces DDL-safe strings (e.g., quoted identifiers, SERIAL).
+ */
+export function buildExpectedFormatType(
+  column: StorageColumn,
+  codecHooks: Map<string, CodecControlHooks>,
+): string {
+  // Parameterized types: expand with typeParams.
+  // format_type() returns the same form (e.g., 'character varying(255)').
+  if (column.typeParams && column.codecId) {
+    const hooks = codecHooks.get(column.codecId);
+    if (hooks?.expandNativeType) {
+      return hooks.expandNativeType({
+        nativeType: column.nativeType,
+        codecId: column.codecId,
+        typeParams: column.typeParams,
+      });
+    }
+  }
+
+  // User-defined types (enums, composites): format_type() double-quotes names
+  // that contain uppercase characters (e.g., "StatusType") but returns lowercase
+  // names bare (e.g., status_type). We can't use quoteIdentifier() here because
+  // it always quotes, which would break the lowercase case.
+  if (column.typeRef) {
+    const needsQuoting = column.nativeType !== column.nativeType.toLowerCase();
+    return needsQuoting ? `"${column.nativeType}"` : column.nativeType;
+  }
+
+  // Base types: map contract short names to format_type() display names.
+  return FORMAT_TYPE_DISPLAY.get(column.nativeType) ?? column.nativeType;
+}
+
+/** Checks that the column's full type (including typmods) matches the expected type via `format_type()`. */
+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
+)`;
+}
+
+/** Checks that a column default exists (or does not exist) via `information_schema.columns.column_default`. */
+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 tableIsEmptyCheck(qualifiedTableName: string): string {
   return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
 }

package/src/core/migrations/planner.ts

@@ -525,7 +525,12 @@ PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,
           precheck: [
             {
               description: `ensure unique constraint "${constraintName}" is missing`,
-              sql: constraintExistsCheck({ constraintName, schema: schemaName, exists: false }),
+              sql: constraintExistsCheck({
+                constraintName,
+                schema: schemaName,
+                table: tableName,
+                exists: false,
+              }),
             },
           ],
           execute: [
@@ -539,7 +544,7 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
           postcheck: [
             {
               description: `verify unique constraint "${constraintName}" exists`,
-              sql: constraintExistsCheck({ constraintName, schema: schemaName }),
+              sql: constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
             },
           ],
         });
@@ -685,6 +690,7 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
               sql: constraintExistsCheck({
                 constraintName: fkName,
                 schema: schemaName,
+                table: tableName,
                 exists: false,
               }),
             },
@@ -698,7 +704,11 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
           postcheck: [
             {
               description: `verify foreign key "${fkName}" exists`,
-              sql: constraintExistsCheck({ constraintName: fkName, schema: schemaName }),
+              sql: constraintExistsCheck({
+                constraintName: fkName,
+                schema: schemaName,
+                table: tableName,
+              }),
             },
           ],
         });