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

package/dist/control.mjs

@@ -5,6 +5,7 @@ import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CO
 import { arraysEqual, verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { bigintJsonReplacer, isTaggedBigInt } from "@prisma-next/contract/types";
+import { invariant } from "@prisma-next/utils/assertions";
 import { readMarker } from "@prisma-next/family-sql/verify";
 import { SqlQueryError } from "@prisma-next/sql-errors";
 import { ok, okVoid } from "@prisma-next/utils/result";
@@ -393,7 +394,7 @@ function collectAllEnumColumns(contract, schema, typeName, nativeType) {
 /**
 * Builds a SQL check to verify a column's type matches an expected type.
 */
-function columnTypeCheck(options) {
+function columnTypeCheck$1(options) {
 	return `SELECT EXISTS (
   SELECT 1
   FROM information_schema.columns
@@ -480,7 +481,7 @@ USING ${quoteIdentifier(ref.column)}::text::${qualifiedTemp}`
 		},
 		...columnRefs.map((ref) => ({
 			description: `verify ${ref.table}.${ref.column} uses type "${options.nativeType}"`,
-			sql: columnTypeCheck({
+			sql: columnTypeCheck$1({
 				schemaName: options.schemaName,
 				tableName: ref.table,
 				columnName: ref.column,
@@ -2009,12 +2010,13 @@ function qualifyTableName(schema, table) {
 function toRegclassLiteral(schema, name) {
 	return `'${escapeLiteral(`${quoteIdentifier(schema)}.${quoteIdentifier(name)}`)}'`;
 }
-function constraintExistsCheck({ constraintName, schema, exists = true }) {
+function constraintExistsCheck({ constraintName, schema, table, exists = true }) {
 	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
   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)}'
+  AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})
 )`;
 }
 function columnExistsCheck({ schema, table, column, exists = true }) {
@@ -2037,6 +2039,70 @@ function columnNullabilityCheck({ schema, table, column, nullable }) {
     AND is_nullable = '${expected}'
 )`;
 }
+/**
+* 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 = 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).
+*/
+function buildExpectedFormatType(column, codecHooks) {
+	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
+		});
+	}
+	if (column.typeRef) return column.nativeType !== column.nativeType.toLowerCase() ? `"${column.nativeType}"` : column.nativeType;
+	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()`. */
+function columnTypeCheck({ schema, table, column, expectedType }) {
+	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`. */
+function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
+	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}
+)`;
+}
 function tableIsEmptyCheck(qualifiedTableName) {
 	return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
 }
@@ -2243,6 +2309,25 @@ function buildReconciliationOperationFromIssue(options) {
 			if (!contractColumn) return null;
 			return buildAlterColumnTypeOperation(schemaName, issue.table, issue.column, contractColumn, codecHooks);
 		}
+		case "default_missing": {
+			if (!issue.table || !issue.column) return null;
+			const contractColMissing = getContractColumn(contract, issue.table, issue.column);
+			if (!contractColMissing) return null;
+			invariant(contractColMissing.default !== void 0, `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;
+			invariant(contractColMismatch.default !== void 0, `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);
 		default: return null;
 	}
 }
@@ -2346,7 +2431,8 @@ function buildDropConstraintOperation(schemaName, tableName, constraintName, con
 			description: `ensure constraint "${constraintName}" exists`,
 			sql: constraintExistsCheck({
 				constraintName,
-				schema: schemaName
+				schema: schemaName,
+				table: tableName
 			})
 		}],
 		execute: [{
@@ -2359,6 +2445,7 @@ DROP CONSTRAINT ${quoteIdentifier(constraintName)}`
 			sql: constraintExistsCheck({
 				constraintName,
 				schema: schemaName,
+				table: tableName,
 				exists: false
 			})
 		}]
@@ -2472,12 +2559,84 @@ TYPE ${expectedType}
 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, tableName, columnName, column, columnDefault, operationClass, verb) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const defaultClause = buildColumnDefaultSql(columnDefault, column);
+	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, tableName, columnName) {
+	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
+			})
 		}]
 	};
 }
@@ -2487,6 +2646,7 @@ function convertIssueToConflict(issue) {
 		case "nullability_mismatch": return buildConflict("nullabilityConflict", issue);
 		case "default_missing":
 		case "default_mismatch":
+		case "extra_default":
 		case "extra_table":
 		case "extra_column":
 		case "extra_primary_key":
@@ -2832,6 +2992,7 @@ PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`
 						sql: constraintExistsCheck({
 							constraintName,
 							schema: schemaName,
+							table: tableName,
 							exists: false
 						})
 					}],
@@ -2845,7 +3006,8 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 						description: `verify unique constraint "${constraintName}" exists`,
 						sql: constraintExistsCheck({
 							constraintName,
-							schema: schemaName
+							schema: schemaName,
+							table: tableName
 						})
 					}]
 				});
@@ -2948,6 +3110,7 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 						sql: constraintExistsCheck({
 							constraintName: fkName,
 							schema: schemaName,
+							table: tableName,
 							exists: false
 						})
 					}],
@@ -2959,7 +3122,8 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 						description: `verify foreign key "${fkName}" exists`,
 						sql: constraintExistsCheck({
 							constraintName: fkName,
-							schema: schemaName
+							schema: schemaName,
+							table: tableName
 						})
 					}]
 				});