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

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

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

@@ -1,13 +1,21 @@
-import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type {
+  SqlMigrationPlanOperation,
+  SqlMigrationPlanOperationStep,
+} from '@prisma-next/family-sql/control';
 import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { quoteIdentifier } from '../../sql-utils';
 import type { SqlitePlanTargetDetails } from '../planner-target-details';
 
 export type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 
-export function step(description: string, sql: string): { description: string; sql: string } {
-  return { description, sql };
+export function step(
+  description: string,
+  sql: string,
+  params?: readonly unknown[],
+): SqlMigrationPlanOperationStep {
+  return { description, sql, ...ifDefined('params', params) };
 }
 
 /**

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

@@ -1,5 +1,7 @@
 import type { MigrationOperationClass } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import { tableExistsAst } from '../../../contract-free/checks';
 import { stripOuterParens } from '../../default-normalizer';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { buildCreateIndexSql } from '../planner-ddl-builders';
@@ -13,6 +15,18 @@ import {
   step,
 } from './shared';
 
+type CheckStep = { sql: string; params?: readonly unknown[] };
+
+async function tableExistsSteps(
+  lowerer: ExecuteRequestLowerer,
+  tableName: string,
+): Promise<{ present: CheckStep; absent: CheckStep }> {
+  const checks = tableExistsAst(tableName);
+  const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
+  return { present, absent };
+}
+
 /**
  * Renders the body of a `CREATE TABLE <name> ( … )` statement from a flat
  * `SqliteTableSpec`. SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT` form is
@@ -42,49 +56,35 @@ function renderCreateTableSql(tableName: string, spec: SqliteTableSpec): string
   return `CREATE TABLE ${quoteIdentifier(tableName)} (\n  ${allDefs.join(',\n  ')}\n)`;
 }
 
-export function createTable(tableName: string, spec: SqliteTableSpec): Op {
+export async function createTable(
+  tableName: string,
+  spec: SqliteTableSpec,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { present, absent } = await tableExistsSteps(lowerer, tableName);
   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 = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    precheck: [step(`ensure table "${tableName}" does not exist`, absent.sql, absent.params)],
     execute: [step(`create table "${tableName}"`, renderCreateTableSql(tableName, spec))],
-    postcheck: [
-      step(
-        `verify table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropTable(tableName: string): Op {
+export async function dropTable(tableName: string, lowerer: ExecuteRequestLowerer): Promise<Op> {
+  const { present, absent } = await tableExistsSteps(lowerer, tableName);
   return {
     id: `dropTable.${tableName}`,
     label: `Drop table ${tableName}`,
     summary: `Drops table ${tableName} which is not in the contract`,
     operationClass: 'destructive',
     target: { id: 'sqlite', details: buildTargetDetails('table', tableName) },
-    precheck: [
-      step(
-        `ensure table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    precheck: [step(`ensure table "${tableName}" exists`, present.sql, present.params)],
     execute: [step(`drop table "${tableName}"`, `DROP TABLE ${quoteIdentifier(tableName)}`)],
-    postcheck: [
-      step(
-        `verify table "${tableName}" is gone`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    postcheck: [step(`verify table "${tableName}" is gone`, absent.sql, absent.params)],
   };
 }
 
@@ -115,7 +115,10 @@ export interface RecreateTableArgs {
   readonly operationClass: MigrationOperationClass;
 }
 
-export function recreateTable(args: RecreateTableArgs): Op {
+export async function recreateTable(
+  args: RecreateTableArgs,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const {
     tableName,
     contractTable,
@@ -149,6 +152,9 @@ export function recreateTable(args: RecreateTableArgs): Op {
         ]
       : [];
 
+  const tableSteps = await tableExistsSteps(lowerer, tableName);
+  const tempSteps = await tableExistsSteps(lowerer, tempName);
+
   return {
     id: `recreateTable.${tableName}`,
     label: `Recreate table ${tableName}`,
@@ -156,13 +162,11 @@ export function recreateTable(args: RecreateTableArgs): Op {
     operationClass,
     target: { id: 'sqlite', details: buildTargetDetails('table', tableName) },
     precheck: [
-      step(
-        `ensure table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
+      step(`ensure table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params),
       step(
         `ensure temp table "${tempName}" does not exist`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tempName)}'`,
+        tempSteps.absent.sql,
+        tempSteps.absent.params,
       ),
     ],
     execute: [
@@ -179,13 +183,11 @@ export function recreateTable(args: RecreateTableArgs): Op {
       ...indexStatements,
     ],
     postcheck: [
-      step(
-        `verify table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
+      step(`verify table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params),
       step(
         `verify temp table "${tempName}" is gone`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tempName)}'`,
+        tempSteps.absent.sql,
+        tempSteps.absent.params,
       ),
       ...postchecks,
     ],

package/src/core/migrations/sqlite-migration.ts

@@ -1,13 +1,27 @@
-import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type {
+  MigrationOperationClass,
+  SqlMigrationPlanOperation,
+} from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
 import type { ControlStack } from '@prisma-next/framework-components/control';
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import { blindCast } from '@prisma-next/utils/casts';
 import { errorSqliteMigrationStackMissing } from '../errors';
-import { CreateTableCall } from './op-factory-call';
+import {
+  AddColumnCall,
+  CreateIndexCall,
+  CreateTableCall,
+  DropColumnCall,
+  DropIndexCall,
+  DropTableCall,
+  RecreateTableCall,
+} from './op-factory-call';
+import type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+
 /**
  * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
  * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the
@@ -16,10 +30,10 @@ import type { SqlitePlanTargetDetails } from './planner-target-details';
  * target-local identity.
  *
  * The constructor materializes a single SQLite `SqlControlAdapter` from
- * `stack.adapter.create(stack)` and stores it; the protected `createTable`
- * instance method forwards to `CreateTableCall` with that stored adapter,
- * so user migrations can write `this.createTable({...})` without threading
- * the adapter through every call.
+ * `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.
  */
 export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails, 'sqlite'> {
   readonly targetId = 'sqlite' as const;
@@ -27,8 +41,8 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
   /**
    * 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); `createTable`
-   * throws in that case to surface the misuse.
+   * was instantiated without a stack (test fixtures); the operation methods
+   * throw in that case to surface the misuse.
    */
   protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
 
@@ -42,17 +56,12 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
       : undefined;
   }
 
-  /**
-   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
-   * the supplied options and lowers it through the stored control adapter.
-   * Throws if no adapter is present (i.e. migration instantiated without a stack).
-   */
   protected createTable(options: {
     readonly table: string;
     readonly ifNotExists?: boolean;
     readonly columns: readonly DdlColumn[];
     readonly constraints?: readonly DdlTableConstraint[];
-  }): Promise<SqlMigrationPlanOperation<SqlitePlanTargetDetails>> {
+  }): Promise<Op> {
     if (!this.controlAdapter) {
       throw errorSqliteMigrationStackMissing();
     }
@@ -60,4 +69,63 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
       this.controlAdapter,
     );
   }
+
+  protected dropTable(options: { readonly table: string }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new DropTableCall(options.table).toOp(this.controlAdapter);
+  }
+
+  protected addColumn(options: {
+    readonly table: string;
+    readonly column: SqliteColumnSpec;
+  }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new AddColumnCall(options.table, options.column).toOp(this.controlAdapter);
+  }
+
+  protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new DropColumnCall(options.table, options.column).toOp(this.controlAdapter);
+  }
+
+  protected createIndex(options: {
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+  }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new CreateIndexCall(options.table, options.index, options.columns).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new DropIndexCall(options.table, options.index).toOp(this.controlAdapter);
+  }
+
+  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> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new RecreateTableCall(options).toOp(this.controlAdapter);
+  }
 }

package/src/core/sqlite-unbound-database.ts

@@ -1,13 +1,14 @@
 import {
   freezeNode,
+  hydrateNamespaceEntities,
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import {
-  type SqlNamespaceEntries,
-  type SqlNamespaceTablesInput,
+import { tableEntityKind } from '@prisma-next/sql-contract/entity-kinds';
+import type {
+  SqlNamespaceEntries,
+  SqlNamespaceTablesInput,
   StorageTable,
-  type StorageTableInput,
 } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 
@@ -33,26 +34,18 @@ export class SqliteDatabase extends NamespaceBase {
     super();
     this.id = input.id;
 
-    const carried: Record<string, Readonly<Record<string, unknown>>> = {};
-    let table: Readonly<Record<string, StorageTable>> = Object.freeze({});
-    for (const [kind, rawMap] of Object.entries(input.entries)) {
-      if (kind === 'table') {
-        const tableMap: Record<string, StorageTable> = {};
-        for (const [name, v] of Object.entries(
-          blindCast<
-            Record<string, StorageTableInput>,
-            'entries[table] holds StorageTableInput by construction'
-          >(rawMap),
-        )) {
-          tableMap[name] = new StorageTable(v);
-        }
-        table = Object.freeze(tableMap);
-      } else {
-        carried[kind] = Object.freeze(rawMap);
-      }
-    }
+    const dispatched = hydrateNamespaceEntities(
+      input.entries,
+      new Map([['table', tableEntityKind]]),
+      'carry',
+    );
 
-    this.entries = Object.freeze({ ...carried, table });
+    this.entries = Object.freeze(
+      blindCast<
+        SqlNamespaceEntries,
+        "SQLite's table-only descriptor map hydrates table→StorageTable and carries every other kind raw, so this open-dict result satisfies SqlNamespaceEntries; the descriptor Map erases the per-kind Node type from the return."
+      >(dispatched),
+    );
     Object.defineProperty(this, 'kind', {
       value: SQLITE_NAMESPACE_KIND,
       writable: false,

package/src/exports/contract-free.ts

@@ -1,3 +1,11 @@
+export {
+  type ColumnExistsCheckBuilder,
+  columnExistsAst,
+  type IndexExistsCheckBuilder,
+  indexExistsAst,
+  type TableExistsCheckBuilder,
+  tableExistsAst,
+} from '../contract-free/checks';
 export { datetime, integer, jsonText, sqliteTable, text } from '../contract-free/columns';
 export {
   buildControlTableBootstrapQueries,

package/src/exports/migration.ts

@@ -17,14 +17,11 @@ export {
   primaryKey,
   unique,
 } from '@prisma-next/sql-relational-core/contract-free';
-export { addColumn, dropColumn } from '../core/migrations/operations/columns';
 export {
   type DataTransformOptions,
   dataTransform,
 } from '../core/migrations/operations/data-transform';
-export { createIndex, dropIndex } from '../core/migrations/operations/indexes';
 export { rawSql } from '../core/migrations/operations/raw';
-export { dropTable, recreateTable } from '../core/migrations/operations/tables';
 // Target-owned base class for migrations. Aliased to `Migration` so
 // user-edited migration.ts files (and the renderer's scaffold) read as
 // `class M extends Migration { … }` without having to thread the

package/dist/ddl-CH8V_qcd.mjs

@@ -1,23 +0,0 @@
-import { t as SqliteCreateTable } from "./nodes-D0k4z7NL.mjs";
-//#region src/contract-free/ddl.ts
-/**
-* Build a SQLite `CREATE TABLE` query node.
-*
-* Pass `constraints` for table-level composite primary keys, foreign keys, and
-* unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},
-* and {@link UniqueConstraint} classes from `@prisma-next/sql-relational-core/ast`.
-*
-* Precondition: identifiers (`table`, column names/types) are emitted to SQL
-* verbatim — they are not quoted or escaped, so callers must pass pre-trusted
-* values (e.g. fixed control-plane identifiers). String-literal default values,
-* by contrast, are single-quote-escaped (embedded `'` doubled) by the renderer.
-* Identifier quoting for untrusted identifiers is added when the migration
-* planner adopts this lowering path.
-*/
-function createTable(options) {
-	return new SqliteCreateTable(options);
-}
-//#endregion
-export { createTable as t };
-
-//# sourceMappingURL=ddl-CH8V_qcd.mjs.map

package/dist/ddl-CH8V_qcd.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-CH8V_qcd.mjs","names":[],"sources":["../src/contract-free/ddl.ts"],"sourcesContent":["import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { SqliteCreateTable } from '../core/ddl/nodes';\n\n/**\n * Build a SQLite `CREATE TABLE` query node.\n *\n * Pass `constraints` for table-level composite primary keys, foreign keys, and\n * unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},\n * and {@link UniqueConstraint} classes from `@prisma-next/sql-relational-core/ast`.\n *\n * Precondition: identifiers (`table`, column names/types) are emitted to SQL\n * verbatim — they are not quoted or escaped, so callers must pass pre-trusted\n * values (e.g. fixed control-plane identifiers). String-literal default values,\n * by contrast, are single-quote-escaped (embedded `'` doubled) by the renderer.\n * Identifier quoting for untrusted identifiers is added when the migration\n * planner adopts this lowering path.\n */\nexport function createTable(options: {\n  readonly table: string;\n  readonly schema?: string;\n  readonly ifNotExists?: boolean;\n  readonly columns: readonly DdlColumn[];\n  readonly constraints?: readonly DdlTableConstraint[];\n}): SqliteCreateTable {\n  return new SqliteCreateTable(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAY,SAMN;CACpB,OAAO,IAAI,kBAAkB,OAAO;AACtC"}