@prisma-next/target-sqlite 0.13.0 → 0.14.0-dev.2

package/src/core/migrations/op-factory-call.ts

@@ -2,13 +2,11 @@
  * SQLite migration IR: one concrete `*Call` class per pure factory under
  * `operations/`, plus a shared `SqliteOpFactoryCallNode` abstract base.
  *
- * Each call class carries fully-resolved literal arguments (flat
- * `SqliteColumnSpec` / `SqliteTableSpec` etc.) — codec / `typeRef` / default
- * expansion happens upstream in the issue-planner / strategies, mirroring
- * the Postgres `ColumnSpec` pattern. As a result, `toOp()` and
- * `renderTypeScript()` both pass the same flat data through; the rendered
- * TypeScript scaffold is fully self-contained and does not need access to a
- * `storageTypes` map at runtime.
+ * Each call class carries fully-resolved literal arguments. `CreateTableCall`
+ * holds structured `DdlColumn[]` + `DdlTableConstraint[]` and lowers via the
+ * adapter's DDL path; other call classes carry flat SQL fragments. Codec /
+ * `typeRef` / default expansion happens upstream in the issue-planner /
+ * strategies, mirroring the Postgres `ColumnSpec` pattern.
  */
 
 import { errorUnfilledPlaceholder } from '@prisma-next/errors/migration';
@@ -16,13 +14,25 @@ import type {
   MigrationOperationClass,
   SqlMigrationPlanOperation,
 } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer, Lowerer } from '@prisma-next/family-sql/control-adapter';
 import type { OpFactoryCall as FrameworkOpFactoryCall } from '@prisma-next/framework-components/control';
+import type {
+  AnyDdlColumnDefault,
+  DdlColumn,
+  DdlTableConstraint,
+} from '@prisma-next/sql-relational-core/ast';
 import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';
-import { addColumn, dropColumn } from './operations/columns';
-import { createIndex, dropIndex } from './operations/indexes';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { columnExistsAst, indexExistsAst, tableExistsAst } from '../../contract-free/checks';
+import * as contractFreeDdl from '../../contract-free/ddl';
+import { quoteIdentifier } from '../sql-utils';
+import { addColumnExecuteSql, dropColumnExecuteSql } from './operations/columns';
 import type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';
-import { createTable, dropTable, recreateTable } from './operations/tables';
+import { step } from './operations/shared';
+import { recreateTable } from './operations/tables';
+import { buildCreateIndexSql, buildDropIndexSql } from './planner-ddl-builders';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
+import { buildTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 
@@ -32,7 +42,7 @@ abstract class SqliteOpFactoryCallNode extends TsExpression implements Framework
   abstract readonly factoryName: string;
   abstract readonly operationClass: MigrationOperationClass;
   abstract readonly label: string;
-  abstract toOp(): Op;
+  abstract toOp(lowerer?: Lowerer): Op | Promise<Op>;
 
   importRequirements(): readonly ImportRequirement[] {
     return [{ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: this.factoryName }];
@@ -47,27 +57,149 @@ abstract class SqliteOpFactoryCallNode extends TsExpression implements Framework
 // Table
 // ============================================================================
 
+// ---------------------------------------------------------------------------
+// TypeScript rendering helpers for DdlColumn / DdlTableConstraint
+// ---------------------------------------------------------------------------
+
+function renderDdlColumnDefault(def: AnyDdlColumnDefault | undefined): string {
+  if (!def) return '';
+  if (def.kind === 'literal') {
+    return `lit(${jsonToTsSource(def.value)})`;
+  }
+  return `fn(${jsonToTsSource(def.expression)})`;
+}
+
+function renderDdlColumnAsTsCall(column: DdlColumn): string {
+  const opts: string[] = [];
+  if (column.notNull) opts.push('notNull: true');
+  if (column.primaryKey) opts.push('primaryKey: true');
+  if (column.default) opts.push(`default: ${renderDdlColumnDefault(column.default)}`);
+  const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+  return `col(${jsonToTsSource(column.name)}, ${jsonToTsSource(column.type)}${optsStr})`;
+}
+
+function renderDdlConstraintAsTsCall(constraint: DdlTableConstraint): string {
+  switch (constraint.kind) {
+    case 'primary-key': {
+      const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
+      return `primaryKey(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+    }
+    case 'foreign-key': {
+      const opts: string[] = [];
+      if (constraint.name) opts.push(`name: ${jsonToTsSource(constraint.name)}`);
+      if (constraint.onDelete) opts.push(`onDelete: ${jsonToTsSource(constraint.onDelete)}`);
+      if (constraint.onUpdate) opts.push(`onUpdate: ${jsonToTsSource(constraint.onUpdate)}`);
+      const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+      return `foreignKey(${jsonToTsSource(constraint.columns)}, ${jsonToTsSource(constraint.refTable)}, ${jsonToTsSource(constraint.refColumns)}${optsStr})`;
+    }
+    case 'unique': {
+      const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
+      return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+    }
+  }
+}
+
+function constraintImportSymbols(constraints: readonly DdlTableConstraint[] | undefined): string[] {
+  if (!constraints || constraints.length === 0) return [];
+  const symbols = new Set<string>();
+  for (const c of constraints) {
+    if (c.kind === 'primary-key') symbols.add('primaryKey');
+    else if (c.kind === 'foreign-key') symbols.add('foreignKey');
+    else if (c.kind === 'unique') symbols.add('unique');
+  }
+  return [...symbols];
+}
+
+function defaultImportSymbols(columns: readonly DdlColumn[]): string[] {
+  const symbols = new Set<string>();
+  for (const col of columns) {
+    if (col.default?.kind === 'literal') symbols.add('lit');
+    else if (col.default?.kind === 'function') symbols.add('fn');
+  }
+  return [...symbols];
+}
+
 export class CreateTableCall extends SqliteOpFactoryCallNode {
   readonly factoryName = 'createTable' as const;
   readonly operationClass = 'additive' as const;
   readonly tableName: string;
-  readonly spec: SqliteTableSpec;
+  readonly columns: readonly DdlColumn[];
+  readonly constraints: readonly DdlTableConstraint[] | undefined;
   readonly label: string;
 
-  constructor(tableName: string, spec: SqliteTableSpec) {
+  constructor(
+    tableName: string,
+    columns: readonly DdlColumn[],
+    constraints?: readonly DdlTableConstraint[],
+  ) {
     super();
     this.tableName = tableName;
-    this.spec = spec;
+    this.columns = Object.freeze([...columns]);
+    this.constraints = constraints ? Object.freeze([...constraints]) : undefined;
     this.label = `Create table ${tableName}`;
     this.freeze();
   }
 
-  toOp(): Op {
-    return createTable(this.tableName, this.spec);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `CreateTableCall.toOp: a DDL lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const ddlNode = contractFreeDdl.createTable({
+      table: this.tableName,
+      columns: this.columns,
+      ...ifDefined('constraints', this.constraints),
+    });
+    const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+    const tableName = this.tableName;
+    const tableChecks = tableExistsAst(tableName);
+    const absent = await lowerer.lowerToExecuteRequest(tableChecks.tableAbsent());
+    const present = await lowerer.lowerToExecuteRequest(tableChecks.tablePresent());
+    return {
+      id: `table.${tableName}`,
+      label: `Create table ${tableName}`,
+      summary: `Creates table ${tableName} with required columns`,
+      operationClass: 'additive',
+      target: { id: 'sqlite', details: buildTargetDetails('table', tableName) },
+      precheck: [step(`ensure table "${tableName}" does not exist`, absent.sql, absent.params)],
+      execute: [
+        {
+          description: `create table "${tableName}"`,
+          sql: statement.sql,
+          params: statement.params ?? [],
+        },
+      ],
+      postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params)],
+    };
   }
 
   renderTypeScript(): string {
-    return `createTable(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.spec)})`;
+    const columnsList = this.columns.map(renderDdlColumnAsTsCall).join(', ');
+    const constraintsList = this.constraints
+      ? this.constraints.map(renderDdlConstraintAsTsCall).join(', ')
+      : undefined;
+
+    const opts: string[] = [];
+    opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+    opts.push(`columns: [${columnsList}]`);
+    if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+
+    return `this.createTable({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    const req: ImportRequirement[] = [];
+    if (this.columns.length > 0) {
+      req.push({ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: 'col' });
+      for (const sym of defaultImportSymbols(this.columns)) {
+        req.push({ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: sym });
+      }
+    }
+    for (const sym of constraintImportSymbols(this.constraints)) {
+      req.push({ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: sym });
+    }
+    return req;
   }
 }
 
@@ -84,12 +216,35 @@ export class DropTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return dropTable(this.tableName);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DropTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const checks = tableExistsAst(this.tableName);
+    const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+    const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
+    return {
+      id: `dropTable.${this.tableName}`,
+      label: `Drop table ${this.tableName}`,
+      summary: `Drops table ${this.tableName} which is not in the contract`,
+      operationClass: 'destructive',
+      target: { id: 'sqlite', details: buildTargetDetails('table', this.tableName) },
+      precheck: [step(`ensure table "${this.tableName}" exists`, present.sql, present.params)],
+      execute: [
+        step(`drop table "${this.tableName}"`, `DROP TABLE ${quoteIdentifier(this.tableName)}`),
+      ],
+      postcheck: [step(`verify table "${this.tableName}" is gone`, absent.sql, absent.params)],
+    };
   }
 
   renderTypeScript(): string {
-    return `dropTable(${jsonToTsSource(this.tableName)})`;
+    return `this.dropTable({ table: ${jsonToTsSource(this.tableName)} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -125,16 +280,24 @@ export class RecreateTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return recreateTable({
-      tableName: this.tableName,
-      contractTable: this.contractTable,
-      schemaColumnNames: this.schemaColumnNames,
-      indexes: this.indexes,
-      summary: this.summary,
-      postchecks: this.postchecks,
-      operationClass: this.operationClass,
-    });
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `RecreateTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    return recreateTable(
+      {
+        tableName: this.tableName,
+        contractTable: this.contractTable,
+        schemaColumnNames: this.schemaColumnNames,
+        indexes: this.indexes,
+        summary: this.summary,
+        postchecks: this.postchecks,
+        operationClass: this.operationClass,
+      },
+      lowerer,
+    );
   }
 
   renderTypeScript(): string {
@@ -147,7 +310,11 @@ export class RecreateTableCall extends SqliteOpFactoryCallNode {
       postchecks: this.postchecks,
       operationClass: this.operationClass,
     };
-    return `recreateTable(${jsonToTsSource(args)})`;
+    return `this.recreateTable(${jsonToTsSource(args)})`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -172,12 +339,38 @@ export class AddColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return addColumn(this.tableName, this.column);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `AddColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const checks = columnExistsAst(this.tableName, this.column.name);
+    const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+    const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+    return {
+      id: `column.${this.tableName}.${this.column.name}`,
+      label: `Add column ${this.column.name} on ${this.tableName}`,
+      summary: `Adds column ${this.column.name} on ${this.tableName}`,
+      operationClass: 'additive',
+      target: {
+        id: 'sqlite',
+        details: buildTargetDetails('column', this.column.name, this.tableName),
+      },
+      precheck: [step(`ensure column "${this.column.name}" is missing`, absent.sql, absent.params)],
+      execute: [
+        step(`add column "${this.column.name}"`, addColumnExecuteSql(this.tableName, this.column)),
+      ],
+      postcheck: [step(`verify column "${this.column.name}" exists`, present.sql, present.params)],
+    };
   }
 
   renderTypeScript(): string {
-    return `addColumn(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;
+    return `this.addColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.column)} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -196,12 +389,53 @@ export class DropColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return dropColumn(this.tableName, this.columnName);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DropColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const checks = columnExistsAst(this.tableName, this.columnName);
+    const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+    const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+    return {
+      id: `dropColumn.${this.tableName}.${this.columnName}`,
+      label: `Drop column ${this.columnName} on ${this.tableName}`,
+      summary: `Drops column ${this.columnName} on ${this.tableName} which is not in the contract`,
+      operationClass: 'destructive',
+      target: {
+        id: 'sqlite',
+        details: buildTargetDetails('column', this.columnName, this.tableName),
+      },
+      precheck: [
+        step(
+          `ensure column "${this.columnName}" exists on "${this.tableName}"`,
+          present.sql,
+          present.params,
+        ),
+      ],
+      execute: [
+        step(
+          `drop column "${this.columnName}" from "${this.tableName}"`,
+          dropColumnExecuteSql(this.tableName, this.columnName),
+        ),
+      ],
+      postcheck: [
+        step(
+          `verify column "${this.columnName}" is gone from "${this.tableName}"`,
+          absent.sql,
+          absent.params,
+        ),
+      ],
+    };
   }
 
   renderTypeScript(): string {
-    return `dropColumn(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+    return `this.dropColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.columnName)} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -226,12 +460,41 @@ export class CreateIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return createIndex(this.tableName, this.indexName, this.columns);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `CreateIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const checks = indexExistsAst(this.indexName);
+    const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+    const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+    return {
+      id: `index.${this.tableName}.${this.indexName}`,
+      label: `Create index ${this.indexName} on ${this.tableName}`,
+      summary: `Creates index ${this.indexName} on ${this.tableName}`,
+      operationClass: 'additive',
+      target: {
+        id: 'sqlite',
+        details: buildTargetDetails('index', this.indexName, this.tableName),
+      },
+      precheck: [step(`ensure index "${this.indexName}" is missing`, absent.sql, absent.params)],
+      execute: [
+        step(
+          `create index "${this.indexName}"`,
+          buildCreateIndexSql(this.tableName, this.indexName, this.columns),
+        ),
+      ],
+      postcheck: [step(`verify index "${this.indexName}" exists`, present.sql, present.params)],
+    };
   }
 
   renderTypeScript(): string {
-    return `createIndex(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)}, ${jsonToTsSource(this.columns)})`;
+    return `this.createIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)}, columns: ${jsonToTsSource(this.columns)} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -250,12 +513,36 @@ export class DropIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return dropIndex(this.tableName, this.indexName);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DropIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const checks = indexExistsAst(this.indexName);
+    const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+    const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+    return {
+      id: `dropIndex.${this.tableName}.${this.indexName}`,
+      label: `Drop index ${this.indexName} on ${this.tableName}`,
+      summary: `Drops index ${this.indexName} on ${this.tableName} which is not in the contract`,
+      operationClass: 'destructive',
+      target: {
+        id: 'sqlite',
+        details: buildTargetDetails('index', this.indexName, this.tableName),
+      },
+      precheck: [step(`ensure index "${this.indexName}" exists`, present.sql, present.params)],
+      execute: [step(`drop index "${this.indexName}"`, buildDropIndexSql(this.indexName))],
+      postcheck: [step(`verify index "${this.indexName}" is gone`, absent.sql, absent.params)],
+    };
   }
 
   renderTypeScript(): string {
-    return `dropIndex(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)})`;
+    return `this.dropIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -292,7 +579,7 @@ export class DataTransformCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     throw errorUnfilledPlaceholder(this.label);
   }
 
@@ -344,7 +631,7 @@ export class RawSqlCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return this.op;
   }
 

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

@@ -1,39 +1,51 @@
-import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { columnExistsAst } from '../../../contract-free/checks';
+import { quoteIdentifier } from '../../sql-utils';
 import { buildTargetDetails } from '../planner-target-details';
 import { type Op, type SqliteColumnSpec, step } from './shared';
 
-export function addColumn(tableName: string, column: SqliteColumnSpec): Op {
+export function addColumnExecuteSql(tableName: string, column: SqliteColumnSpec): string {
   const parts = [
     `ALTER TABLE ${quoteIdentifier(tableName)}`,
     `ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
     column.defaultSql,
     column.nullable ? '' : 'NOT NULL',
   ].filter(Boolean);
-  const addSql = parts.join(' ');
+  return parts.join(' ');
+}
+
+export function dropColumnExecuteSql(tableName: string, columnName: string): string {
+  return `ALTER TABLE ${quoteIdentifier(tableName)} DROP COLUMN ${quoteIdentifier(columnName)}`;
+}
 
+export async function addColumn(
+  tableName: string,
+  column: SqliteColumnSpec,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const checks = columnExistsAst(tableName, column.name);
+  const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+  const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
   return {
     id: `column.${tableName}.${column.name}`,
     label: `Add column ${column.name} on ${tableName}`,
     summary: `Adds column ${column.name} on ${tableName}`,
     operationClass: 'additive',
     target: { id: 'sqlite', details: buildTargetDetails('column', column.name, tableName) },
-    precheck: [
-      step(
-        `ensure column "${column.name}" is missing`,
-        `SELECT COUNT(*) = 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(column.name)}'`,
-      ),
-    ],
-    execute: [step(`add column "${column.name}"`, addSql)],
-    postcheck: [
-      step(
-        `verify column "${column.name}" exists`,
-        `SELECT COUNT(*) > 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(column.name)}'`,
-      ),
-    ],
+    precheck: [step(`ensure column "${column.name}" is missing`, absent.sql, absent.params)],
+    execute: [step(`add column "${column.name}"`, addColumnExecuteSql(tableName, column))],
+    postcheck: [step(`verify column "${column.name}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropColumn(tableName: string, columnName: string): Op {
+export async function dropColumn(
+  tableName: string,
+  columnName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const checks = columnExistsAst(tableName, columnName);
+  const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
   return {
     id: `dropColumn.${tableName}.${columnName}`,
     label: `Drop column ${columnName} on ${tableName}`,
@@ -41,22 +53,16 @@ export function dropColumn(tableName: string, columnName: string): Op {
     operationClass: 'destructive',
     target: { id: 'sqlite', details: buildTargetDetails('column', columnName, tableName) },
     precheck: [
-      step(
-        `ensure column "${columnName}" exists on "${tableName}"`,
-        `SELECT COUNT(*) > 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(columnName)}'`,
-      ),
+      step(`ensure column "${columnName}" exists on "${tableName}"`, present.sql, present.params),
     ],
     execute: [
       step(
         `drop column "${columnName}" from "${tableName}"`,
-        `ALTER TABLE ${quoteIdentifier(tableName)} DROP COLUMN ${quoteIdentifier(columnName)}`,
+        dropColumnExecuteSql(tableName, columnName),
       ),
     ],
     postcheck: [
-      step(
-        `verify column "${columnName}" is gone from "${tableName}"`,
-        `SELECT COUNT(*) = 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(columnName)}'`,
-      ),
+      step(`verify column "${columnName}" is gone from "${tableName}"`, absent.sql, absent.params),
     ],
   };
 }

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

@@ -1,52 +1,56 @@
-import { escapeLiteral } from '../../sql-utils';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { indexExistsAst } from '../../../contract-free/checks';
 import { buildCreateIndexSql, buildDropIndexSql } from '../planner-ddl-builders';
 import { buildTargetDetails } from '../planner-target-details';
 import { type Op, step } from './shared';
 
-export function createIndex(tableName: string, indexName: string, columns: readonly string[]): Op {
+type CheckStep = { sql: string; params?: readonly unknown[] };
+
+async function indexExistsSteps(
+  lowerer: ExecuteRequestLowerer,
+  indexName: string,
+): Promise<{ present: CheckStep; absent: CheckStep }> {
+  const checks = indexExistsAst(indexName);
+  const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+  return { present, absent };
+}
+
+export async function createIndex(
+  tableName: string,
+  indexName: string,
+  columns: readonly string[],
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { present, absent } = await indexExistsSteps(lowerer, indexName);
   return {
     id: `index.${tableName}.${indexName}`,
     label: `Create index ${indexName} on ${tableName}`,
     summary: `Creates index ${indexName} on ${tableName}`,
     operationClass: 'additive',
     target: { id: 'sqlite', details: buildTargetDetails('index', indexName, tableName) },
-    precheck: [
-      step(
-        `ensure index "${indexName}" is missing`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`,
-      ),
-    ],
+    precheck: [step(`ensure index "${indexName}" is missing`, absent.sql, absent.params)],
     execute: [
       step(`create index "${indexName}"`, buildCreateIndexSql(tableName, indexName, columns)),
     ],
-    postcheck: [
-      step(
-        `verify index "${indexName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`,
-      ),
-    ],
+    postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropIndex(tableName: string, indexName: string): Op {
+export async function dropIndex(
+  tableName: string,
+  indexName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { present, absent } = await indexExistsSteps(lowerer, indexName);
   return {
     id: `dropIndex.${tableName}.${indexName}`,
     label: `Drop index ${indexName} on ${tableName}`,
     summary: `Drops index ${indexName} on ${tableName} which is not in the contract`,
     operationClass: 'destructive',
     target: { id: 'sqlite', details: buildTargetDetails('index', indexName, tableName) },
-    precheck: [
-      step(
-        `ensure index "${indexName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`,
-      ),
-    ],
+    precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
     execute: [step(`drop index "${indexName}"`, buildDropIndexSql(indexName))],
-    postcheck: [
-      step(
-        `verify index "${indexName}" is gone`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`,
-      ),
-    ],
+    postcheck: [step(`verify index "${indexName}" is gone`, absent.sql, absent.params)],
   };
 }