@prisma-next/target-postgres 0.13.0-dev.35 → 0.13.0-dev.37

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

@@ -1,8 +1,23 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import { constraintExistsAst } from '../../../contract-free/checks';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
-import { constraintExistsCheck, qualifyTableName } from '../planner-sql-checks';
+import { qualifyTableName } from '../planner-sql-checks';
 import { type ForeignKeySpec, type Op, step, targetDetails } from './shared';
 
+async function constraintCheckSteps(
+  lowerer: ExecuteRequestLowerer,
+  options: { constraintName: string; schema: string; table: string },
+): Promise<{
+  absent: { sql: string; params?: readonly unknown[] };
+  present: { sql: string; params?: readonly unknown[] };
+}> {
+  const checks = constraintExistsAst(options);
+  const absent = await lowerer.lowerToExecuteRequest(checks.constraintAbsent());
+  const present = await lowerer.lowerToExecuteRequest(checks.constraintPresent());
+  return { absent, present };
+}
+
 function renderForeignKeySql(schemaName: string, tableName: string, fk: ForeignKeySpec): string {
   let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
 ADD CONSTRAINT ${quoteIdentifier(fk.name)}
@@ -28,29 +43,27 @@ REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.
   return sql;
 }
 
-export function addPrimaryKey(
+export async function addPrimaryKey(
   schemaName: string,
   tableName: string,
   constraintName: string,
   columns: readonly string[],
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `primaryKey.${tableName}.${constraintName}`,
     label: `Add primary key on "${tableName}"`,
     operationClass: 'additive',
     target: targetDetails('primaryKey', constraintName, schemaName, tableName),
     precheck: [
-      step(
-        `ensure primary key "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`ensure primary key "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -58,38 +71,31 @@ export function addPrimaryKey(
         `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} PRIMARY KEY (${columnList})`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify primary key "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    postcheck: [step(`verify primary key "${constraintName}" exists`, present.sql, present.params)],
   };
 }
 
-export function addUnique(
+export async function addUnique(
   schemaName: string,
   tableName: string,
   constraintName: string,
   columns: readonly string[],
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `unique.${tableName}.${constraintName}`,
     label: `Add unique constraint on "${tableName}" (${columns.join(', ')})`,
     operationClass: 'additive',
     target: targetDetails('unique', constraintName, schemaName, tableName),
     precheck: [
-      step(
-        `ensure constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -97,70 +103,54 @@ export function addUnique(
         `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} UNIQUE (${columnList})`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)],
   };
 }
 
-export function addForeignKey(schemaName: string, tableName: string, fk: ForeignKeySpec): Op {
+export async function addForeignKey(
+  schemaName: string,
+  tableName: string,
+  fk: ForeignKeySpec,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName: fk.name,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `foreignKey.${tableName}.${fk.name}`,
     label: `Add foreign key "${fk.name}" on "${tableName}"`,
     operationClass: 'additive',
     target: targetDetails('foreignKey', fk.name, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure FK "${fk.name}" does not exist`,
-        constraintExistsCheck({
-          constraintName: fk.name,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
-    ],
+    precheck: [step(`ensure FK "${fk.name}" does not exist`, absent.sql, absent.params)],
     execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
-    postcheck: [
-      step(
-        `verify FK "${fk.name}" exists`,
-        constraintExistsCheck({
-          constraintName: fk.name,
-          schema: schemaName,
-          table: tableName,
-        }),
-      ),
-    ],
+    postcheck: [step(`verify FK "${fk.name}" exists`, present.sql, present.params)],
   };
 }
 
-export function addCheckConstraint(
+export async function addCheckConstraint(
   schemaName: string,
   tableName: string,
   constraintName: string,
   column: string,
   values: readonly string[],
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const valueList = values.map((v) => `'${escapeLiteral(v)}'`).join(', ');
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `checkConstraint.${tableName}.${constraintName}`,
     label: `Add check constraint "${constraintName}" on "${tableName}"."${column}"`,
     operationClass: 'additive',
     target: targetDetails('checkConstraint', constraintName, schemaName, tableName),
     precheck: [
-      step(
-        `ensure constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -168,32 +158,28 @@ export function addCheckConstraint(
         `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} CHECK (${quoteIdentifier(column)} IN (${valueList}))`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropCheckConstraint(
+export async function dropCheckConstraint(
   schemaName: string,
   tableName: string,
   constraintName: string,
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `dropCheckConstraint.${tableName}.${constraintName}`,
     label: `Drop check constraint "${constraintName}" on "${tableName}"`,
     operationClass: 'destructive',
     target: targetDetails('checkConstraint', constraintName, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    precheck: [step(`ensure constraint "${constraintName}" exists`, present.sql, present.params)],
     execute: [
       step(
         `drop check constraint "${constraintName}"`,
@@ -201,15 +187,7 @@ export function dropCheckConstraint(
       ),
     ],
     postcheck: [
-      step(
-        `verify constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
   };
 }
@@ -221,24 +199,25 @@ export function dropCheckConstraint(
  * (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
  * that produced the drop.
  */
-export function dropConstraint(
+export async function dropConstraint(
   schemaName: string,
   tableName: string,
   constraintName: string,
+  lowerer: ExecuteRequestLowerer,
   kind: 'foreignKey' | 'unique' | 'primaryKey' = 'unique',
-): Op {
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `dropConstraint.${tableName}.${constraintName}`,
     label: `Drop constraint "${constraintName}" on "${tableName}"`,
     operationClass: 'destructive',
     target: targetDetails(kind, constraintName, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    precheck: [step(`ensure constraint "${constraintName}" exists`, present.sql, present.params)],
     execute: [
       step(
         `drop constraint "${constraintName}"`,
@@ -246,15 +225,7 @@ export function dropConstraint(
       ),
     ],
     postcheck: [
-      step(
-        `verify constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
   };
 }

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

@@ -1,3 +1,5 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { extensionExistsAst } from '../../../contract-free/checks';
 import { quoteIdentifier } from '../../sql-utils';
 import { type Op, step } from './shared';
 
@@ -32,14 +34,20 @@ export function createExtension(extensionName: string): Op {
  * use the bare {@link createExtension} for planner-emitted ops where the
  * caller already controls idempotency through the surrounding plan.
  */
-export function installExtension(options: {
-  readonly extensionName: string;
-  readonly invariantId: string;
-  readonly id: string;
-  readonly label?: string;
-}): Op {
+export async function installExtension(
+  options: {
+    readonly extensionName: string;
+    readonly invariantId: string;
+    readonly id: string;
+    readonly label?: string;
+  },
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const { extensionName, invariantId, id } = options;
   const label = options.label ?? `Enable extension "${extensionName}"`;
+  const checks = extensionExistsAst(extensionName);
+  const absent = await lowerer.lowerToExecuteRequest(checks.extensionAbsent());
+  const present = await lowerer.lowerToExecuteRequest(checks.extensionPresent());
   return {
     id,
     label,
@@ -50,10 +58,7 @@ export function installExtension(options: {
       details: { schema: 'public', objectType: 'dependency', name: extensionName },
     },
     precheck: [
-      step(
-        `verify extension "${extensionName}" is not already enabled`,
-        `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`,
-      ),
+      step(`verify extension "${extensionName}" is not already enabled`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -62,10 +67,7 @@ export function installExtension(options: {
       ),
     ],
     postcheck: [
-      step(
-        `confirm extension "${extensionName}" is enabled`,
-        `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`,
-      ),
+      step(`confirm extension "${extensionName}" is enabled`, present.sql, present.params),
     ],
   };
 }

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

@@ -1,7 +1,22 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { indexExistsAst } from '../../../contract-free/checks';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
-import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
+import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 
+type CheckStep = { sql: string; params?: readonly unknown[] };
+
+async function indexExistsSteps(
+  lowerer: ExecuteRequestLowerer,
+  schemaName: string,
+  indexName: string,
+): Promise<{ present: CheckStep; absent: CheckStep }> {
+  const checks = indexExistsAst(schemaName, indexName);
+  const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+  return { present, absent };
+}
+
 export interface CreateIndexExtras {
   readonly type?: string;
   readonly options?: Record<string, unknown>;
@@ -22,65 +37,53 @@ function renderIndexOptions(options: Record<string, unknown>): string {
     .join(', ');
 }
 
-export function createIndex(
+export async function createIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
   columns: readonly string[],
+  lowerer: ExecuteRequestLowerer,
   extras?: CreateIndexExtras,
-): Op {
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
   const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : '';
   const options = extras?.options;
   const withClause =
     options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : '';
+  const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   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`,
-      ),
-    ],
+    precheck: [step(`ensure index "${indexName}" does not exist`, absent.sql, absent.params)],
     execute: [
       step(
         `create index "${indexName}"`,
         `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify index "${indexName}" exists`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
-      ),
-    ],
+    postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropIndex(schemaName: string, tableName: string, indexName: string): Op {
+export async function dropIndex(
+  schemaName: string,
+  tableName: string,
+  indexName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   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`,
-      ),
-    ],
+    precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
     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`,
-      ),
-    ],
+    postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)],
   };
 }

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

@@ -42,8 +42,8 @@ export interface ForeignKeySpec {
   readonly onUpdate?: ReferentialAction;
 }
 
-export function step(description: string, sql: string) {
-  return { description, sql };
+export function step(description: string, sql: string, params?: readonly unknown[]) {
+  return { description, sql, ...ifDefined('params', params) };
 }
 
 export function targetDetails(

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

@@ -1,25 +1,24 @@
-import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { tableExistsAst } from '../../../contract-free/checks';
+import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 
-export function dropTable(schemaName: string, tableName: string): Op {
+export async function dropTable(
+  schemaName: string,
+  tableName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
+  const checks = tableExistsAst(schemaName, tableName);
+  const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
   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`,
-      ),
-    ],
+    precheck: [step(`ensure table "${tableName}" exists`, present.sql, present.params)],
     execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
-    postcheck: [
-      step(
-        `verify table "${tableName}" does not exist`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
-      ),
-    ],
+    postcheck: [step(`verify table "${tableName}" does not exist`, absent.sql, absent.params)],
   };
 }

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

@@ -1,13 +1,15 @@
 import type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import {
+  columnDefaultAst,
+  columnExistsAst,
+  columnNullabilityAst,
+} from '../../contract-free/checks';
 import { quoteIdentifier } from '../sql-utils';
+import { step } from './operations/shared';
 import { buildAddColumnSql } from './planner-ddl-builders';
-import {
-  columnExistsCheck,
-  columnHasNoDefaultCheck,
-  columnNullabilityCheck,
-  qualifyTableName,
-} from './planner-sql-checks';
+import { qualifyTableName } from './planner-sql-checks';
 import { buildTargetDetails, type PostgresPlanTargetDetails } from './planner-target-details';
 
 export function buildAddColumnOperationIdentity(
@@ -29,7 +31,7 @@ export function buildAddColumnOperationIdentity(
   };
 }
 
-export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
+export async function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
   readonly schema: string;
   readonly tableName: string;
   readonly columnName: string;
@@ -37,20 +39,37 @@ export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
   readonly codecHooks: Map<string, CodecControlHooks>;
   readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly temporaryDefault: string;
-}): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
-  const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } =
-    options;
+  readonly lowerer: ExecuteRequestLowerer;
+}): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+  const {
+    schema,
+    tableName,
+    columnName,
+    column,
+    codecHooks,
+    storageTypes,
+    temporaryDefault,
+    lowerer,
+  } = options;
   const qualified = qualifyTableName(schema, tableName);
 
+  const absent = await lowerer.lowerToExecuteRequest(
+    columnExistsAst({ schema, table: tableName, column: columnName }).columnAbsent(),
+  );
+  const present = await lowerer.lowerToExecuteRequest(
+    columnExistsAst({ schema, table: tableName, column: columnName }).columnPresent(),
+  );
+  const notNullable = await lowerer.lowerToExecuteRequest(
+    columnNullabilityAst({ schema, table: tableName, column: columnName, nullable: false }),
+  );
+  const noDefault = await lowerer.lowerToExecuteRequest(
+    columnDefaultAst({ schema, table: tableName, column: columnName }).noDefault(),
+  );
+
   return {
     ...buildAddColumnOperationIdentity(schema, tableName, columnName),
     operationClass: 'additive',
-    precheck: [
-      {
-        description: `ensure column "${columnName}" is missing`,
-        sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),
-      },
-    ],
+    precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params)],
     execute: [
       {
         description: `add column "${columnName}"`,
@@ -69,23 +88,13 @@ export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
       },
     ],
     postcheck: [
-      {
-        description: `verify column "${columnName}" exists`,
-        sql: columnExistsCheck({ schema, table: tableName, column: columnName }),
-      },
-      {
-        description: `verify column "${columnName}" is NOT NULL`,
-        sql: columnNullabilityCheck({
-          schema,
-          table: tableName,
-          column: columnName,
-          nullable: false,
-        }),
-      },
-      {
-        description: `verify column "${columnName}" has no default after temporary default removal`,
-        sql: columnHasNoDefaultCheck({ schema, table: tableName, column: columnName }),
-      },
+      step(`verify column "${columnName}" exists`, present.sql, present.params),
+      step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params),
+      step(
+        `verify column "${columnName}" has no default after temporary default removal`,
+        noDefault.sql,
+        noDefault.params,
+      ),
     ],
   };
 }