@type32/tauri-sqlite-orm 0.2.9 → 0.2.11

package/dist/index.d.mts

@@ -286,9 +286,25 @@ declare class TauriORM {
     private tables;
     constructor(db: Database, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
     private buildColumnDefinition;
+    checkMigration(): Promise<{
+        safe: boolean;
+        changes: {
+            tablesToCreate: string[];
+            tablesToRecreate: string[];
+            tablesToDrop: string[];
+            columnsToAdd: Array<{
+                table: string;
+                column: string;
+            }>;
+        };
+    }>;
     migrate(options?: {
         performDestructiveActions?: boolean;
+        dryRun?: boolean;
     }): Promise<void>;
+    private canAddColumnWithAlter;
+    private hasColumnDefinitionChanged;
+    private recreateTable;
     select<T extends AnyTable, C extends (keyof T['_']['columns'])[] | undefined = undefined>(table: T, columns?: C): SelectQueryBuilder<T, C>;
     insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
     update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;

package/dist/index.d.ts

@@ -286,9 +286,25 @@ declare class TauriORM {
     private tables;
     constructor(db: Database, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
     private buildColumnDefinition;
+    checkMigration(): Promise<{
+        safe: boolean;
+        changes: {
+            tablesToCreate: string[];
+            tablesToRecreate: string[];
+            tablesToDrop: string[];
+            columnsToAdd: Array<{
+                table: string;
+                column: string;
+            }>;
+        };
+    }>;
     migrate(options?: {
         performDestructiveActions?: boolean;
+        dryRun?: boolean;
     }): Promise<void>;
+    private canAddColumnWithAlter;
+    private hasColumnDefinitionChanged;
+    private recreateTable;
     select<T extends AnyTable, C extends (keyof T['_']['columns'])[] | undefined = undefined>(table: T, columns?: C): SelectQueryBuilder<T, C>;
     insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
     update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;

package/dist/index.js

@@ -1258,7 +1258,86 @@ var TauriORM = class {
     }
     return sql2;
   }
+  async checkMigration() {
+    const dbTables = await this.db.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
+    );
+    const dbTableNames = new Set(dbTables.map((t) => t.name));
+    const schemaTableNames = new Set(Array.from(this.tables.keys()));
+    const changes = {
+      tablesToCreate: [],
+      tablesToRecreate: [],
+      tablesToDrop: [],
+      columnsToAdd: []
+    };
+    for (const tableName of schemaTableNames) {
+      if (!dbTableNames.has(tableName)) {
+        changes.tablesToCreate.push(tableName);
+      }
+    }
+    for (const tableName of dbTableNames) {
+      if (!schemaTableNames.has(tableName)) {
+        changes.tablesToDrop.push(tableName);
+      }
+    }
+    for (const table of this.tables.values()) {
+      const tableName = table._.name;
+      if (!dbTableNames.has(tableName)) continue;
+      const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
+      const existingIndexes = await this.db.select(`PRAGMA index_list('${tableName}')`);
+      const uniqueColumns = /* @__PURE__ */ new Set();
+      for (const index of existingIndexes) {
+        if (index.unique === 1 && index.origin === "u") {
+          const indexInfo = await this.db.select(`PRAGMA index_info('${index.name}')`);
+          if (indexInfo.length === 1) {
+            uniqueColumns.add(indexInfo[0].name);
+          }
+        }
+      }
+      const existingColumns = new Map(existingTableInfo.map((c) => [c.name, c]));
+      const schemaColumns = table._.columns;
+      let needsRecreate = false;
+      for (const [colName, column] of Object.entries(schemaColumns)) {
+        const existing = existingColumns.get(colName);
+        if (!existing) {
+          if (!this.canAddColumnWithAlter(column)) {
+            needsRecreate = true;
+            break;
+          }
+          changes.columnsToAdd.push({ table: tableName, column: colName });
+        } else {
+          const hasUniqueInDB = uniqueColumns.has(colName);
+          const wantsUnique = !!column.options.unique;
+          if (hasUniqueInDB !== wantsUnique || this.hasColumnDefinitionChanged(column, existing)) {
+            needsRecreate = true;
+            break;
+          }
+        }
+      }
+      for (const existingCol of existingColumns.keys()) {
+        if (!schemaColumns[existingCol]) {
+          needsRecreate = true;
+          break;
+        }
+      }
+      if (needsRecreate) {
+        changes.tablesToRecreate.push(tableName);
+      }
+    }
+    const safe = changes.tablesToRecreate.length === 0 && changes.tablesToDrop.length === 0;
+    return { safe, changes };
+  }
   async migrate(options) {
+    if (options?.dryRun) {
+      const check = await this.checkMigration();
+      console.log("[Tauri-ORM] Migration Preview (Dry Run):");
+      console.log("  Tables to create:", check.changes.tablesToCreate);
+      console.log("  Tables to recreate (DESTRUCTIVE):", check.changes.tablesToRecreate);
+      console.log("  Tables to drop:", check.changes.tablesToDrop);
+      console.log("  Columns to add:", check.changes.columnsToAdd);
+      console.log("  Safe migration:", check.safe);
+      return;
+    }
     const dbTables = await this.db.select(
       `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
     );
@@ -1269,30 +1348,62 @@ var TauriORM = class {
       const tableExists = dbTableNames.has(tableName);
       if (!tableExists) {
         const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
-        const createSql = `CREATE TABLE ${tableName}
-                                   (
-                                       ${columnsSql}
-                                   )`;
+        const createSql = `CREATE TABLE ${tableName} (${columnsSql})`;
         await this.db.execute(createSql);
       } else {
         const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
-        const existingColumnNames = new Set(existingTableInfo.map((c) => c.name));
-        const schemaColumnNames = new Set(Object.keys(table._.columns));
-        for (const column of Object.values(table._.columns)) {
-          if (!existingColumnNames.has(column._.name)) {
-            const columnSql = this.buildColumnDefinition(column, true);
-            const alterSql = `ALTER TABLE ${tableName}
-                            ADD COLUMN ${columnSql}`;
-            await this.db.execute(alterSql);
+        const existingIndexes = await this.db.select(`PRAGMA index_list('${tableName}')`);
+        const uniqueColumns = /* @__PURE__ */ new Set();
+        for (const index of existingIndexes) {
+          if (index.unique === 1 && index.origin === "u") {
+            const indexInfo = await this.db.select(`PRAGMA index_info('${index.name}')`);
+            if (indexInfo.length === 1) {
+              uniqueColumns.add(indexInfo[0].name);
+            }
+          }
+        }
+        const existingColumns = new Map(existingTableInfo.map((c) => [c.name, c]));
+        const schemaColumns = table._.columns;
+        let needsRecreate = false;
+        const columnsToAdd = [];
+        for (const [colName, column] of Object.entries(schemaColumns)) {
+          const existing = existingColumns.get(colName);
+          if (!existing) {
+            if (this.canAddColumnWithAlter(column)) {
+              columnsToAdd.push(column);
+            } else {
+              needsRecreate = true;
+              break;
+            }
+          } else {
+            const hasUniqueInDB = uniqueColumns.has(colName);
+            const wantsUnique = !!column.options.unique;
+            if (hasUniqueInDB !== wantsUnique) {
+              needsRecreate = true;
+              break;
+            }
+            if (this.hasColumnDefinitionChanged(column, existing)) {
+              needsRecreate = true;
+              break;
+            }
           }
         }
         if (options?.performDestructiveActions) {
-          for (const colName of existingColumnNames) {
-            if (!schemaColumnNames.has(colName)) {
-              await this.dropColumn(tableName, colName);
+          for (const existingCol of existingColumns.keys()) {
+            if (!schemaColumns[existingCol]) {
+              needsRecreate = true;
+              break;
             }
           }
         }
+        if (needsRecreate) {
+          await this.recreateTable(tableName, table);
+        } else if (columnsToAdd.length > 0) {
+          for (const column of columnsToAdd) {
+            const columnSql = this.buildColumnDefinition(column, true);
+            await this.db.execute(`ALTER TABLE ${tableName} ADD COLUMN ${columnSql}`);
+          }
+        }
       }
     }
     if (options?.performDestructiveActions) {
@@ -1303,6 +1414,38 @@ var TauriORM = class {
       }
     }
   }
+  canAddColumnWithAlter(column) {
+    if (column.options.primaryKey) return false;
+    if (column.options.unique) return false;
+    if (column._.notNull && column.options.default === void 0 && !column.options.$defaultFn) return false;
+    return true;
+  }
+  hasColumnDefinitionChanged(column, existing) {
+    if (column.type.toUpperCase() !== existing.type.toUpperCase()) return true;
+    if (column._.notNull !== (existing.notnull === 1)) return true;
+    if (!!column.options.primaryKey !== (existing.pk === 1)) return true;
+    const hasDefault = column.options.default !== void 0;
+    const existingHasDefault = existing.dflt_value !== null;
+    if (hasDefault !== existingHasDefault) return true;
+    return false;
+  }
+  async recreateTable(tableName, table) {
+    const tempTableName = `${tableName}_new_${Date.now()}`;
+    const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
+    await this.db.execute(`CREATE TABLE ${tempTableName} (${columnsSql})`);
+    const oldColumns = await this.db.select(`PRAGMA table_info('${tableName}')`);
+    const oldColumnNames = oldColumns.map((c) => c.name);
+    const newColumnNames = Object.keys(table._.columns);
+    const commonColumns = oldColumnNames.filter((name) => newColumnNames.includes(name));
+    if (commonColumns.length > 0) {
+      const columnsList = commonColumns.join(", ");
+      await this.db.execute(
+        `INSERT INTO ${tempTableName} (${columnsList}) SELECT ${columnsList} FROM ${tableName}`
+      );
+    }
+    await this.db.execute(`DROP TABLE ${tableName}`);
+    await this.db.execute(`ALTER TABLE ${tempTableName} RENAME TO ${tableName}`);
+  }
   select(table, columns) {
     const internalTable = this.tables.get(table._.name);
     if (!internalTable) {

package/dist/index.mjs

@@ -1159,7 +1159,86 @@ var TauriORM = class {
     }
     return sql2;
   }
+  async checkMigration() {
+    const dbTables = await this.db.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
+    );
+    const dbTableNames = new Set(dbTables.map((t) => t.name));
+    const schemaTableNames = new Set(Array.from(this.tables.keys()));
+    const changes = {
+      tablesToCreate: [],
+      tablesToRecreate: [],
+      tablesToDrop: [],
+      columnsToAdd: []
+    };
+    for (const tableName of schemaTableNames) {
+      if (!dbTableNames.has(tableName)) {
+        changes.tablesToCreate.push(tableName);
+      }
+    }
+    for (const tableName of dbTableNames) {
+      if (!schemaTableNames.has(tableName)) {
+        changes.tablesToDrop.push(tableName);
+      }
+    }
+    for (const table of this.tables.values()) {
+      const tableName = table._.name;
+      if (!dbTableNames.has(tableName)) continue;
+      const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
+      const existingIndexes = await this.db.select(`PRAGMA index_list('${tableName}')`);
+      const uniqueColumns = /* @__PURE__ */ new Set();
+      for (const index of existingIndexes) {
+        if (index.unique === 1 && index.origin === "u") {
+          const indexInfo = await this.db.select(`PRAGMA index_info('${index.name}')`);
+          if (indexInfo.length === 1) {
+            uniqueColumns.add(indexInfo[0].name);
+          }
+        }
+      }
+      const existingColumns = new Map(existingTableInfo.map((c) => [c.name, c]));
+      const schemaColumns = table._.columns;
+      let needsRecreate = false;
+      for (const [colName, column] of Object.entries(schemaColumns)) {
+        const existing = existingColumns.get(colName);
+        if (!existing) {
+          if (!this.canAddColumnWithAlter(column)) {
+            needsRecreate = true;
+            break;
+          }
+          changes.columnsToAdd.push({ table: tableName, column: colName });
+        } else {
+          const hasUniqueInDB = uniqueColumns.has(colName);
+          const wantsUnique = !!column.options.unique;
+          if (hasUniqueInDB !== wantsUnique || this.hasColumnDefinitionChanged(column, existing)) {
+            needsRecreate = true;
+            break;
+          }
+        }
+      }
+      for (const existingCol of existingColumns.keys()) {
+        if (!schemaColumns[existingCol]) {
+          needsRecreate = true;
+          break;
+        }
+      }
+      if (needsRecreate) {
+        changes.tablesToRecreate.push(tableName);
+      }
+    }
+    const safe = changes.tablesToRecreate.length === 0 && changes.tablesToDrop.length === 0;
+    return { safe, changes };
+  }
   async migrate(options) {
+    if (options?.dryRun) {
+      const check = await this.checkMigration();
+      console.log("[Tauri-ORM] Migration Preview (Dry Run):");
+      console.log("  Tables to create:", check.changes.tablesToCreate);
+      console.log("  Tables to recreate (DESTRUCTIVE):", check.changes.tablesToRecreate);
+      console.log("  Tables to drop:", check.changes.tablesToDrop);
+      console.log("  Columns to add:", check.changes.columnsToAdd);
+      console.log("  Safe migration:", check.safe);
+      return;
+    }
     const dbTables = await this.db.select(
       `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
     );
@@ -1170,30 +1249,62 @@ var TauriORM = class {
       const tableExists = dbTableNames.has(tableName);
       if (!tableExists) {
         const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
-        const createSql = `CREATE TABLE ${tableName}
-                                   (
-                                       ${columnsSql}
-                                   )`;
+        const createSql = `CREATE TABLE ${tableName} (${columnsSql})`;
         await this.db.execute(createSql);
       } else {
         const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
-        const existingColumnNames = new Set(existingTableInfo.map((c) => c.name));
-        const schemaColumnNames = new Set(Object.keys(table._.columns));
-        for (const column of Object.values(table._.columns)) {
-          if (!existingColumnNames.has(column._.name)) {
-            const columnSql = this.buildColumnDefinition(column, true);
-            const alterSql = `ALTER TABLE ${tableName}
-                            ADD COLUMN ${columnSql}`;
-            await this.db.execute(alterSql);
+        const existingIndexes = await this.db.select(`PRAGMA index_list('${tableName}')`);
+        const uniqueColumns = /* @__PURE__ */ new Set();
+        for (const index of existingIndexes) {
+          if (index.unique === 1 && index.origin === "u") {
+            const indexInfo = await this.db.select(`PRAGMA index_info('${index.name}')`);
+            if (indexInfo.length === 1) {
+              uniqueColumns.add(indexInfo[0].name);
+            }
+          }
+        }
+        const existingColumns = new Map(existingTableInfo.map((c) => [c.name, c]));
+        const schemaColumns = table._.columns;
+        let needsRecreate = false;
+        const columnsToAdd = [];
+        for (const [colName, column] of Object.entries(schemaColumns)) {
+          const existing = existingColumns.get(colName);
+          if (!existing) {
+            if (this.canAddColumnWithAlter(column)) {
+              columnsToAdd.push(column);
+            } else {
+              needsRecreate = true;
+              break;
+            }
+          } else {
+            const hasUniqueInDB = uniqueColumns.has(colName);
+            const wantsUnique = !!column.options.unique;
+            if (hasUniqueInDB !== wantsUnique) {
+              needsRecreate = true;
+              break;
+            }
+            if (this.hasColumnDefinitionChanged(column, existing)) {
+              needsRecreate = true;
+              break;
+            }
           }
         }
         if (options?.performDestructiveActions) {
-          for (const colName of existingColumnNames) {
-            if (!schemaColumnNames.has(colName)) {
-              await this.dropColumn(tableName, colName);
+          for (const existingCol of existingColumns.keys()) {
+            if (!schemaColumns[existingCol]) {
+              needsRecreate = true;
+              break;
             }
           }
         }
+        if (needsRecreate) {
+          await this.recreateTable(tableName, table);
+        } else if (columnsToAdd.length > 0) {
+          for (const column of columnsToAdd) {
+            const columnSql = this.buildColumnDefinition(column, true);
+            await this.db.execute(`ALTER TABLE ${tableName} ADD COLUMN ${columnSql}`);
+          }
+        }
       }
     }
     if (options?.performDestructiveActions) {
@@ -1204,6 +1315,38 @@ var TauriORM = class {
       }
     }
   }
+  canAddColumnWithAlter(column) {
+    if (column.options.primaryKey) return false;
+    if (column.options.unique) return false;
+    if (column._.notNull && column.options.default === void 0 && !column.options.$defaultFn) return false;
+    return true;
+  }
+  hasColumnDefinitionChanged(column, existing) {
+    if (column.type.toUpperCase() !== existing.type.toUpperCase()) return true;
+    if (column._.notNull !== (existing.notnull === 1)) return true;
+    if (!!column.options.primaryKey !== (existing.pk === 1)) return true;
+    const hasDefault = column.options.default !== void 0;
+    const existingHasDefault = existing.dflt_value !== null;
+    if (hasDefault !== existingHasDefault) return true;
+    return false;
+  }
+  async recreateTable(tableName, table) {
+    const tempTableName = `${tableName}_new_${Date.now()}`;
+    const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
+    await this.db.execute(`CREATE TABLE ${tempTableName} (${columnsSql})`);
+    const oldColumns = await this.db.select(`PRAGMA table_info('${tableName}')`);
+    const oldColumnNames = oldColumns.map((c) => c.name);
+    const newColumnNames = Object.keys(table._.columns);
+    const commonColumns = oldColumnNames.filter((name) => newColumnNames.includes(name));
+    if (commonColumns.length > 0) {
+      const columnsList = commonColumns.join(", ");
+      await this.db.execute(
+        `INSERT INTO ${tempTableName} (${columnsList}) SELECT ${columnsList} FROM ${tableName}`
+      );
+    }
+    await this.db.execute(`DROP TABLE ${tableName}`);
+    await this.db.execute(`ALTER TABLE ${tempTableName} RENAME TO ${tableName}`);
+  }
   select(table, columns) {
     const internalTable = this.tables.get(table._.name);
     if (!internalTable) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@type32/tauri-sqlite-orm",
-    "version": "0.2.9",
+    "version": "0.2.11",
     "description": "A Drizzle-like ORM for Tauri v2's SQL JS API plugin.",
     "main": "./dist/index.js",
     "module": "./dist/index.mjs",