@type32/tauri-sqlite-orm 0.1.18-20 → 0.1.18-21

package/dist/index.d.mts

@@ -207,7 +207,9 @@ declare class TauriORM {
     private tables;
     constructor(db: Database, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
     private buildColumnDefinition;
-    migrate(): Promise<void>;
+    migrate(options?: {
+        performDestructiveActions?: boolean;
+    }): Promise<void>;
     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>;
@@ -232,6 +234,12 @@ declare class TauriORM {
         stored: string | null;
     }>;
     migrateIfDirty(): Promise<boolean>;
+    doesTableExist(tableName: string): Promise<boolean>;
+    dropTable(tableName: string): Promise<void>;
+    doesColumnExist(tableName: string, columnName: string): Promise<boolean>;
+    renameTable(from: string, to: string): Promise<void>;
+    dropColumn(tableName: string, columnName: string): Promise<void>;
+    renameColumn(tableName: string, from: string, to: string): Promise<void>;
 }
 declare class Relation<T extends AnyTable = AnyTable> {
     foreignTable: T;

package/dist/index.d.ts

@@ -207,7 +207,9 @@ declare class TauriORM {
     private tables;
     constructor(db: Database, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
     private buildColumnDefinition;
-    migrate(): Promise<void>;
+    migrate(options?: {
+        performDestructiveActions?: boolean;
+    }): Promise<void>;
     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>;
@@ -232,6 +234,12 @@ declare class TauriORM {
         stored: string | null;
     }>;
     migrateIfDirty(): Promise<boolean>;
+    doesTableExist(tableName: string): Promise<boolean>;
+    dropTable(tableName: string): Promise<void>;
+    doesColumnExist(tableName: string, columnName: string): Promise<boolean>;
+    renameTable(from: string, to: string): Promise<void>;
+    dropColumn(tableName: string, columnName: string): Promise<void>;
+    renameColumn(tableName: string, from: string, to: string): Promise<void>;
 }
 declare class Relation<T extends AnyTable = AnyTable> {
     foreignTable: T;

package/dist/index.js

@@ -794,26 +794,48 @@ var TauriORM = class {
     }
     return sql2;
   }
-  async migrate() {
+  async migrate(options) {
+    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()));
     for (const table of this.tables.values()) {
-      const existingTableInfo = await this.db.select(`PRAGMA table_info('${table._.name}')`);
-      if (existingTableInfo.length === 0) {
+      const tableName = table._.name;
+      const tableExists = dbTableNames.has(tableName);
+      if (!tableExists) {
         const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
-        const createSql = `CREATE TABLE ${table._.name}
+        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 ${table._.name}
+            const alterSql = `ALTER TABLE ${tableName}
                             ADD COLUMN ${columnSql}`;
             await this.db.execute(alterSql);
           }
         }
+        if (options?.performDestructiveActions) {
+          for (const colName of existingColumnNames) {
+            if (!schemaColumnNames.has(colName)) {
+              await this.dropColumn(tableName, colName);
+            }
+          }
+        }
+      }
+    }
+    if (options?.performDestructiveActions) {
+      for (const tableName of dbTableNames) {
+        if (!schemaTableNames.has(tableName)) {
+          await this.dropTable(tableName);
+        }
       }
     }
   }
@@ -933,6 +955,29 @@ var TauriORM = class {
     }
     return false;
   }
+  async doesTableExist(tableName) {
+    const result = await this.db.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+      [tableName]
+    );
+    return result.length > 0;
+  }
+  async dropTable(tableName) {
+    await this.db.execute(`DROP TABLE IF EXISTS ${tableName}`);
+  }
+  async doesColumnExist(tableName, columnName) {
+    const result = await this.db.select(`PRAGMA table_info('${tableName}')`);
+    return result.some((col) => col.name === columnName);
+  }
+  async renameTable(from, to) {
+    await this.db.execute(`ALTER TABLE ${from} RENAME TO ${to}`);
+  }
+  async dropColumn(tableName, columnName) {
+    await this.db.execute(`ALTER TABLE ${tableName} DROP COLUMN ${columnName}`);
+  }
+  async renameColumn(tableName, from, to) {
+    await this.db.execute(`ALTER TABLE ${tableName} RENAME COLUMN ${from} TO ${to}`);
+  }
 };
 var Relation = class {
   constructor(foreignTable) {

package/dist/index.mjs

@@ -725,26 +725,48 @@ var TauriORM = class {
     }
     return sql2;
   }
-  async migrate() {
+  async migrate(options) {
+    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()));
     for (const table of this.tables.values()) {
-      const existingTableInfo = await this.db.select(`PRAGMA table_info('${table._.name}')`);
-      if (existingTableInfo.length === 0) {
+      const tableName = table._.name;
+      const tableExists = dbTableNames.has(tableName);
+      if (!tableExists) {
         const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
-        const createSql = `CREATE TABLE ${table._.name}
+        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 ${table._.name}
+            const alterSql = `ALTER TABLE ${tableName}
                             ADD COLUMN ${columnSql}`;
             await this.db.execute(alterSql);
           }
         }
+        if (options?.performDestructiveActions) {
+          for (const colName of existingColumnNames) {
+            if (!schemaColumnNames.has(colName)) {
+              await this.dropColumn(tableName, colName);
+            }
+          }
+        }
+      }
+    }
+    if (options?.performDestructiveActions) {
+      for (const tableName of dbTableNames) {
+        if (!schemaTableNames.has(tableName)) {
+          await this.dropTable(tableName);
+        }
       }
     }
   }
@@ -864,6 +886,29 @@ var TauriORM = class {
     }
     return false;
   }
+  async doesTableExist(tableName) {
+    const result = await this.db.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+      [tableName]
+    );
+    return result.length > 0;
+  }
+  async dropTable(tableName) {
+    await this.db.execute(`DROP TABLE IF EXISTS ${tableName}`);
+  }
+  async doesColumnExist(tableName, columnName) {
+    const result = await this.db.select(`PRAGMA table_info('${tableName}')`);
+    return result.some((col) => col.name === columnName);
+  }
+  async renameTable(from, to) {
+    await this.db.execute(`ALTER TABLE ${from} RENAME TO ${to}`);
+  }
+  async dropColumn(tableName, columnName) {
+    await this.db.execute(`ALTER TABLE ${tableName} DROP COLUMN ${columnName}`);
+  }
+  async renameColumn(tableName, from, to) {
+    await this.db.execute(`ALTER TABLE ${tableName} RENAME COLUMN ${from} TO ${to}`);
+  }
 };
 var Relation = class {
   constructor(foreignTable) {

package/package.json

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