@holo-js/db 0.3.1 → 0.3.2

package/dist/index.d.ts

@@ -19,6 +19,7 @@ interface DatabaseCapabilities {
     jsonLength: boolean;
     schemaQualifiedIdentifiers: boolean;
     nativeUpsert: boolean;
+    ddlAddColumnSupport?: boolean;
     ddlAlterSupport: boolean;
     introspection: boolean;
 }
@@ -355,6 +356,9 @@ interface DriverAdapter {
     isDatabaseMissingError?(error: unknown): boolean;
     ensureDatabaseExists?(): Promise<void>;
     runWithTransactionScope?<T>(callback: () => Promise<T>): Promise<T>;
+    beforeMigrationTransaction?(): Promise<unknown>;
+    validateMigrationTransaction?(): Promise<void>;
+    afterMigrationTransaction?(state: unknown): Promise<void>;
     introspect?<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     execute(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
@@ -3053,11 +3057,13 @@ declare class SchemaService {
     private parsePostgresIndex;
     private unsupportedIntrospectionError;
     private assertAlterCapability;
+    private assertAddColumnCapability;
     private assertForeignKeyCapability;
     private resolveColumnDefinition;
     private createDefinedTable;
     private assertTableMutationIndexNames;
     private executeTableMutation;
+    private rebuildSqliteTableForAlteredColumn;
     private buildTableDefinition;
     private updateRegisteredTable;
     private renameRegisteredTable;
@@ -3142,6 +3148,7 @@ declare class MigrationService {
     private ensureTrackingTableForMigration;
     rollback(options?: RollbackOptions): Promise<RegisteredMigrationDefinition[]>;
     getExecutionPolicy(): MigrationExecutionPolicy;
+    private runMigrationTransaction;
     private ensureTrackingTable;
     private getRanRecords;
     private createContext;
@@ -3297,6 +3304,9 @@ declare class DeferredDatabaseDriverAdapter implements DriverAdapter {
     ensureDatabaseExists(): Promise<void>;
     isDatabaseMissingError(error: unknown): boolean;
     runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
+    beforeMigrationTransaction(): Promise<unknown>;
+    validateMigrationTransaction(): Promise<void>;
+    afterMigrationTransaction(state: unknown): Promise<void>;
     introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     execute(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;

package/dist/index.mjs

@@ -7344,6 +7344,14 @@ var SchemaService = class {
       );
     }
   }
+  assertAddColumnCapability() {
+    const capabilities = this.connection.getCapabilities();
+    if (!(capabilities.ddlAddColumnSupport ?? capabilities.ddlAlterSupport)) {
+      throw new CapabilityError(
+        `SchemaService does not support adding columns for dialect "${this.connection.getDialect().name}".`
+      );
+    }
+  }
   assertForeignKeyCapability(action) {
     if (this.isSqlite() || !this.connection.getCapabilities().ddlAlterSupport) {
       throw new CapabilityError(
@@ -7384,16 +7392,20 @@ var SchemaService = class {
   async executeTableMutation(tableName, operation) {
     switch (operation.kind) {
       case "addColumn": {
-        this.assertAlterCapability("adding columns");
+        this.assertAddColumnCapability();
         const definition = this.resolveColumnDefinition(operation.columnName, operation.column);
         await this.execute(this.createCompiler().compile(addColumnOperation(tableName, definition)));
         this.updateRegisteredTable(tableName, (table) => this.withColumn(table, definition));
         return;
       }
       case "alterColumn": {
-        this.assertAlterCapability("altering columns");
         const definition = this.resolveColumnDefinition(operation.columnName, operation.column);
-        await this.execute(this.createCompiler().compile(alterColumnOperation(tableName, definition)));
+        if (this.isSqlite()) {
+          await this.rebuildSqliteTableForAlteredColumn(tableName, definition);
+        } else {
+          this.assertAlterCapability("altering columns");
+          await this.execute(this.createCompiler().compile(alterColumnOperation(tableName, definition)));
+        }
         this.updateRegisteredTable(tableName, (table) => this.withAlteredColumn(table, definition));
         return;
       }
@@ -7457,6 +7469,48 @@ var SchemaService = class {
         return;
     }
   }
+  async rebuildSqliteTableForAlteredColumn(tableName, column2) {
+    const registered = this.connection.getSchemaRegistry().get(tableName);
+    if (!registered) {
+      throw new SchemaError(
+        `SQLite column changes require table "${tableName}" to be registered before calling change().`
+      );
+    }
+    if (!registered.columns[column2.name]) {
+      throw new SchemaError(
+        `SQLite cannot change missing column "${column2.name}" on table "${tableName}". Add the column without change() first.`
+      );
+    }
+    const temporaryTableName = `__holo_rebuild_${tableName.replaceAll(".", "_")}`;
+    if (await this.hasTable(temporaryTableName)) {
+      throw new SchemaError(
+        `SQLite cannot rebuild table "${tableName}" because temporary table "${temporaryTableName}" already exists.`
+      );
+    }
+    const rebuilt = this.withAlteredColumn(registered, column2);
+    const schemaObjects = await this.connection.introspectCompiled({
+      sql: "SELECT type, name, sql FROM sqlite_master WHERE tbl_name = ? AND type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name",
+      bindings: [tableName],
+      source: `schema:sqliteRebuild:objects:${tableName}`
+    });
+    const temporaryDefinition = defineTable(temporaryTableName, rebuilt.columns);
+    const compiler = this.createCompiler();
+    const quote = (identifier) => this.connection.getDialect().quoteIdentifier(identifier);
+    const columns = Object.keys(rebuilt.columns).map(quote).join(", ");
+    await this.execute(compiler.compile(createTableOperation(temporaryDefinition)));
+    await this.connection.executeCompiled({
+      sql: `INSERT INTO ${quote(temporaryTableName)} (${columns}) SELECT ${columns} FROM ${quote(tableName)}`,
+      source: `schema:sqliteRebuild:copy:${tableName}`
+    });
+    await this.execute(compiler.compile(dropTableOperation(tableName)));
+    await this.execute(compiler.compile(renameTableOperation(temporaryTableName, tableName)));
+    for (const object of schemaObjects.rows) {
+      await this.connection.executeCompiled({
+        sql: object.sql,
+        source: `schema:sqliteRebuild:restore:${object.type}:${object.name}`
+      });
+    }
+  }
   async buildTableDefinition(tableName, callback) {
     assertValidIdentifierPath(tableName, "Table name");
     if (!callback) {
@@ -7915,7 +7969,7 @@ var MigrationService = class {
       for (const migration of pending) {
         const log = this.createMigrationLog(migration.name, "up", nextBatch);
         await this.runMigrationLifecycle(log, async () => {
-          await this.connection.transaction(async (tx) => {
+          await this.runMigrationTransaction(async (tx) => {
             const context = this.createContext(tx);
             await migration.up(context);
             await new TableQueryBuilder(migrationsTable, tx).insert({
@@ -7964,7 +8018,7 @@ var MigrationService = class {
         }
         const log = this.createMigrationLog(record.name, "down", record.batch);
         await this.runMigrationLifecycle(log, async () => {
-          await this.connection.transaction(async (tx) => {
+          await this.runMigrationTransaction(async (tx) => {
             const context = this.createContext(tx);
             if (migration.down) {
               await migration.down(context);
@@ -7984,6 +8038,22 @@ var MigrationService = class {
       allowsConcurrentMigrations: false
     };
   }
+  async runMigrationTransaction(callback) {
+    const adapter = this.connection.getAdapter();
+    const runWithinScope = adapter.runWithTransactionScope?.bind(adapter) ?? (async (runner) => runner());
+    return await runWithinScope(async () => {
+      const driverState = await adapter.beforeMigrationTransaction?.();
+      try {
+        return await this.connection.transaction(async (tx) => {
+          const result = await callback(tx);
+          await adapter.validateMigrationTransaction?.();
+          return result;
+        });
+      } finally {
+        await adapter.afterMigrationTransaction?.(driverState);
+      }
+    });
+  }
   async ensureTrackingTable() {
     const schema = createSchemaService(this.connection);
     if (await schema.hasTable(migrationsTable.tableName)) {
@@ -14284,6 +14354,7 @@ var DEFAULT_CAPABILITIES = {
   jsonLength: false,
   schemaQualifiedIdentifiers: false,
   nativeUpsert: false,
+  ddlAddColumnSupport: false,
   ddlAlterSupport: false,
   introspection: false
 };
@@ -14940,6 +15011,15 @@ var DeferredDatabaseDriverAdapter = class {
   async runWithTransactionScope(callback) {
     return (await this.resolve()).runWithTransactionScope?.(callback) ?? callback();
   }
+  async beforeMigrationTransaction() {
+    return await (await this.resolve()).beforeMigrationTransaction?.();
+  }
+  async validateMigrationTransaction() {
+    await (await this.resolve()).validateMigrationTransaction?.();
+  }
+  async afterMigrationTransaction(state) {
+    await (await this.resolve()).afterMigrationTransaction?.(state);
+  }
   async introspect(sql, bindings, options) {
     const adapter = await this.resolve();
     return adapter.introspect ? adapter.introspect(sql, bindings, options) : adapter.query(sql, bindings, options);
@@ -15150,6 +15230,7 @@ function createDialect(driver) {
     jsonLength: true,
     schemaQualifiedIdentifiers: false,
     nativeUpsert: true,
+    ddlAddColumnSupport: true,
     ddlAlterSupport: false,
     introspection: true
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/db",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Holo-JS Framework - portable database, ORM, migrations, factories, and seeders",
   "type": "module",
   "license": "MIT",
@@ -28,16 +28,16 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/config": "^0.3.1",
-    "@holo-js/kernel": "^0.3.1",
+    "@holo-js/config": "^0.3.2",
+    "@holo-js/kernel": "^0.3.2",
     "inflection": "^3.0.2",
     "ulid": "^3.0.1",
     "uuid": "^12.0.0"
   },
   "devDependencies": {
-    "@holo-js/db-mysql": "^0.3.1",
-    "@holo-js/db-postgres": "^0.3.1",
-    "@holo-js/db-sqlite": "^0.3.1",
+    "@holo-js/db-mysql": "^0.3.2",
+    "@holo-js/db-postgres": "^0.3.2",
+    "@holo-js/db-sqlite": "^0.3.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
   }