@prisma-next/target-sqlite 0.13.0-dev.35 → 0.13.0-dev.36

package/dist/sqlite-migration-DVfhQwN_.d.mts

@@ -0,0 +1,75 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz.mjs";
+import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-Dhc8mLK1.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
+import { MigrationOperationClass, SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { ControlStack } from "@prisma-next/framework-components/control";
+import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
+
+//#region src/core/migrations/sqlite-migration.d.ts
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+/**
+ * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
+ * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the
+ * SQLite literal, so both user-authored migrations and renderer-generated
+ * scaffolds can extend `SqliteMigration` directly without redeclaring
+ * target-local identity.
+ *
+ * The constructor materializes a single SQLite `SqlControlAdapter` from
+ * `stack.adapter.create(stack)` and stores it; the protected instance methods
+ * forward to the corresponding `*Call` with that stored adapter, so user
+ * migrations can write `this.createTable({...})` without threading the adapter
+ * through every call.
+ */
+declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails, 'sqlite'> {
+  readonly targetId: "sqlite";
+  /**
+   * Materialized SQLite control adapter, created once per migration
+   * instance from the injected stack. `undefined` only when the migration
+   * was instantiated without a stack (test fixtures); the operation methods
+   * throw in that case to surface the misuse.
+   */
+  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
+  constructor(stack?: ControlStack<'sql', 'sqlite'>);
+  protected createTable(options: {
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<Op>;
+  protected dropTable(options: {
+    readonly table: string;
+  }): Promise<Op>;
+  protected addColumn(options: {
+    readonly table: string;
+    readonly column: SqliteColumnSpec;
+  }): Promise<Op>;
+  protected dropColumn(options: {
+    readonly table: string;
+    readonly column: string;
+  }): Promise<Op>;
+  protected createIndex(options: {
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+  }): Promise<Op>;
+  protected dropIndex(options: {
+    readonly table: string;
+    readonly index: string;
+  }): Promise<Op>;
+  protected recreateTable(options: {
+    readonly tableName: string;
+    readonly contractTable: SqliteTableSpec;
+    readonly schemaColumnNames: readonly string[];
+    readonly indexes: readonly SqliteIndexSpec[];
+    readonly summary: string;
+    readonly postchecks: readonly {
+      readonly description: string;
+      readonly sql: string;
+    }[];
+    readonly operationClass: MigrationOperationClass;
+  }): Promise<Op>;
+}
+//#endregion
+export { SqliteMigration as t };
+//# sourceMappingURL=sqlite-migration-DVfhQwN_.d.mts.map

package/dist/sqlite-migration-DVfhQwN_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-DVfhQwN_.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;;;;KAsBK,EAAA,GAAK,yBAAyB,CAAC,uBAAA;;AAFoC;;;;AAEb;AAe3D;;;;;;;uBAAsB,eAAA,SAAwB,SAAA,CAAa,uBAAA;EAAA,SAChD,QAAA;EAyBL;;;;;;EAAA,mBAjBe,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAAA,UAUV,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA,IAC9B,OAAA,CAAQ,EAAA;EAAA,UASF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAOxD,SAAA,CAAU,OAAA;IAAA,SACT,KAAA;IAAA,SACA,MAAA,EAAQ,gBAAA;EAAA,IACf,OAAA,CAAQ,EAAA;EAAA,UAOF,UAAA,CAAW,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,MAAA;EAAA,IAAmB,OAAA,CAAQ,EAAA;EAAA,UAOlF,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA,IACP,OAAA,CAAQ,EAAA;EAAA,UASF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAOhF,aAAA,CAAc,OAAA;IAAA,SACb,SAAA;IAAA,SACA,aAAA,EAAe,eAAA;IAAA,SACf,iBAAA;IAAA,SACA,OAAA,WAAkB,eAAA;IAAA,SAClB,OAAA;IAAA,SACA,UAAA;MAAA,SAAgC,WAAA;MAAA,SAA8B,GAAA;IAAA;IAAA,SAC9D,cAAA,EAAgB,uBAAA;EAAA,IACvB,OAAA,CAAQ,EAAA;AAAA"}

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.13.0-dev.35",
+  "version": "0.13.0-dev.36",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.13.0-dev.35",
-    "@prisma-next/contract": "0.13.0-dev.35",
-    "@prisma-next/errors": "0.13.0-dev.35",
-    "@prisma-next/family-sql": "0.13.0-dev.35",
-    "@prisma-next/framework-components": "0.13.0-dev.35",
-    "@prisma-next/migration-tools": "0.13.0-dev.35",
-    "@prisma-next/sql-contract": "0.13.0-dev.35",
-    "@prisma-next/sql-errors": "0.13.0-dev.35",
-    "@prisma-next/sql-relational-core": "0.13.0-dev.35",
-    "@prisma-next/sql-runtime": "0.13.0-dev.35",
-    "@prisma-next/sql-schema-ir": "0.13.0-dev.35",
-    "@prisma-next/ts-render": "0.13.0-dev.35",
-    "@prisma-next/utils": "0.13.0-dev.35",
+    "@prisma-next/cli": "0.13.0-dev.36",
+    "@prisma-next/contract": "0.13.0-dev.36",
+    "@prisma-next/errors": "0.13.0-dev.36",
+    "@prisma-next/family-sql": "0.13.0-dev.36",
+    "@prisma-next/framework-components": "0.13.0-dev.36",
+    "@prisma-next/migration-tools": "0.13.0-dev.36",
+    "@prisma-next/sql-contract": "0.13.0-dev.36",
+    "@prisma-next/sql-errors": "0.13.0-dev.36",
+    "@prisma-next/sql-relational-core": "0.13.0-dev.36",
+    "@prisma-next/sql-runtime": "0.13.0-dev.36",
+    "@prisma-next/sql-schema-ir": "0.13.0-dev.36",
+    "@prisma-next/ts-render": "0.13.0-dev.36",
+    "@prisma-next/utils": "0.13.0-dev.36",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.13.0-dev.35",
-    "@prisma-next/test-utils": "0.13.0-dev.35",
-    "@prisma-next/tsconfig": "0.13.0-dev.35",
-    "@prisma-next/tsdown": "0.13.0-dev.35",
+    "@prisma-next/driver-sqlite": "0.13.0-dev.36",
+    "@prisma-next/test-utils": "0.13.0-dev.36",
+    "@prisma-next/tsconfig": "0.13.0-dev.36",
+    "@prisma-next/tsdown": "0.13.0-dev.36",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/contract-free/checks.ts

@@ -0,0 +1,75 @@
+import { FunctionSource, type SelectAst } from '@prisma-next/sql-relational-core/ast';
+import { cfExpr, cfTable, exprSelect } from '@prisma-next/sql-relational-core/contract-free';
+import { SQLITE_TEXT_CODEC_ID } from '../core/codec-ids';
+
+export interface ColumnExistsCheckBuilder {
+  columnAbsent(): SelectAst;
+  columnPresent(): SelectAst;
+}
+
+/**
+ * Typed builder for the migration planner's column-existence checks. Produces
+ * `SELECT COUNT(*) {=|>} 0 AS "result" FROM pragma_table_info(?) WHERE "name" = ?`
+ * ASTs with the table and column names bound as text parameters — never
+ * inlined into the SQL.
+ */
+export function columnExistsAst(table: string, column: string): ColumnExistsCheckBuilder {
+  const source = FunctionSource.of('pragma_table_info', [
+    cfExpr.param(table, SQLITE_TEXT_CODEC_ID).ast,
+  ]);
+  const where = cfExpr.identifierRef('name').eqParam(column, SQLITE_TEXT_CODEC_ID);
+  return {
+    columnAbsent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().eqLit(0)).where(where).build(),
+    columnPresent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().gtLit(0)).where(where).build(),
+  };
+}
+
+export interface TableExistsCheckBuilder {
+  tableAbsent(): SelectAst;
+  tablePresent(): SelectAst;
+}
+
+/**
+ * Typed builder for table-existence checks over `sqlite_master`.
+ * Produces `SELECT COUNT(*) {=|>} 0 AS "result" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?`
+ * with the table name and the literal `'table'` bound as text parameters.
+ */
+export function tableExistsAst(tableName: string): TableExistsCheckBuilder {
+  const source = cfTable('sqlite_master');
+  const where = cfExpr.allOf([
+    cfExpr.identifierRef('type').eqParam('table', SQLITE_TEXT_CODEC_ID),
+    cfExpr.identifierRef('name').eqParam(tableName, SQLITE_TEXT_CODEC_ID),
+  ]);
+  return {
+    tableAbsent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().eqLit(0)).where(where).build(),
+    tablePresent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().gtLit(0)).where(where).build(),
+  };
+}
+
+export interface IndexExistsCheckBuilder {
+  indexAbsent(): SelectAst;
+  indexPresent(): SelectAst;
+}
+
+/**
+ * Typed builder for index-existence checks over `sqlite_master`.
+ * Produces `SELECT COUNT(*) {=|>} 0 AS "result" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?`
+ * with the index name and the literal `'index'` bound as text parameters.
+ */
+export function indexExistsAst(indexName: string): IndexExistsCheckBuilder {
+  const source = cfTable('sqlite_master');
+  const where = cfExpr.allOf([
+    cfExpr.identifierRef('type').eqParam('index', SQLITE_TEXT_CODEC_ID),
+    cfExpr.identifierRef('name').eqParam(indexName, SQLITE_TEXT_CODEC_ID),
+  ]);
+  return {
+    indexAbsent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().eqLit(0)).where(where).build(),
+    indexPresent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().gtLit(0)).where(where).build(),
+  };
+}

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

@@ -23,13 +23,14 @@ import type {
 } from '@prisma-next/sql-relational-core/ast';
 import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { columnExistsAst, indexExistsAst, tableExistsAst } from '../../contract-free/checks';
 import * as contractFreeDdl from '../../contract-free/ddl';
-import { escapeLiteral } from '../sql-utils';
-import { addColumn, dropColumn } from './operations/columns';
-import { createIndex, dropIndex } from './operations/indexes';
+import { quoteIdentifier } from '../sql-utils';
+import { addColumnExecuteSql, dropColumnExecuteSql } from './operations/columns';
 import type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';
 import { step } from './operations/shared';
-import { dropTable, recreateTable } from './operations/tables';
+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';
 
@@ -152,19 +153,16 @@ export class CreateTableCall extends SqliteOpFactoryCallNode {
     });
     const statement = await lowerer.lowerToExecuteRequest(ddlNode);
     const tableName = this.tableName;
-    const escapedName = escapeLiteral(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`,
-          `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapedName}'`,
-        ),
-      ],
+      precheck: [step(`ensure table "${tableName}" does not exist`, absent.sql, absent.params)],
       execute: [
         {
           description: `create table "${tableName}"`,
@@ -172,12 +170,7 @@ export class CreateTableCall extends SqliteOpFactoryCallNode {
           params: statement.params ?? [],
         },
       ],
-      postcheck: [
-        step(
-          `verify table "${tableName}" exists`,
-          `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapedName}'`,
-        ),
-      ],
+      postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params)],
     };
   }
 
@@ -223,12 +216,35 @@ export class DropTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(_lowerer?: Lowerer): 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 [];
   }
 }
 
@@ -264,16 +280,24 @@ export class RecreateTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(_lowerer?: Lowerer): 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 {
@@ -286,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 [];
   }
 }
 
@@ -311,12 +339,38 @@ export class AddColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(_lowerer?: Lowerer): 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 [];
   }
 }
 
@@ -335,12 +389,53 @@ export class DropColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(_lowerer?: Lowerer): 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 [];
   }
 }
 
@@ -365,12 +460,41 @@ export class CreateIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(_lowerer?: Lowerer): 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 [];
   }
 }
 
@@ -389,12 +513,36 @@ export class DropIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(_lowerer?: Lowerer): 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 [];
   }
 }
 

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),
     ],
   };
 }