@type32/tauri-sqlite-orm 0.2.9 → 0.2.10

package/dist/index.d.mts

@@ -289,6 +289,9 @@ declare class TauriORM {
     migrate(options?: {
         performDestructiveActions?: 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

@@ -289,6 +289,9 @@ declare class TauriORM {
     migrate(options?: {
         performDestructiveActions?: 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

@@ -1269,30 +1269,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 +1335,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

@@ -1170,30 +1170,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 +1236,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.10",
     "description": "A Drizzle-like ORM for Tauri v2's SQL JS API plugin.",
     "main": "./dist/index.js",
     "module": "./dist/index.mjs",