@type32/tauri-sqlite-orm 0.1.1 → 0.1.3

package/README.md

@@ -35,6 +35,7 @@ export const users = defineTable("users", {
 export const posts = defineTable("posts", {
   id: integer("id", { isPrimaryKey: true }).primaryKey(),
   content: text("content"),
+  randomId: text("random_id").$defaultFn(() => crypto.randomUUID()),
   authorId: integer("author_id"),
 });
 

package/dist/index.d.mts

@@ -25,6 +25,7 @@ interface Column<T = any> {
     autoIncrement?: boolean;
     isNotNull?: boolean;
     defaultValue?: T | SQLExpression;
+    defaultFn?: () => any;
     references?: {
         table: string;
         column: string;
@@ -46,6 +47,7 @@ type ColumnBuilder<T> = Column<T> & {
     notNull: () => ColumnBuilder<T>;
     default: (value: T | SQLExpression) => ColumnBuilder<T>;
     $type: <U>() => ColumnBuilder<U>;
+    $defaultFn: (fn: () => any) => ColumnBuilder<T>;
     references: (target: () => Column<any>, actions?: {
         onDelete?: UpdateDeleteAction;
         onUpdate?: UpdateDeleteAction;
@@ -152,6 +154,60 @@ declare class TauriORM {
         name?: string;
         track?: boolean;
     }): Promise<void>;
+    diffSchema(): Promise<{
+        extraTables: string[];
+        missingTables: string[];
+        tables: Record<string, {
+            missingColumns: string[];
+            extraColumns: string[];
+            changedColumns: Array<{
+                name: string;
+                diffs: {
+                    type?: boolean;
+                    pk?: boolean;
+                    notNull?: boolean;
+                    default?: boolean;
+                };
+            }>;
+        }>;
+    }>;
+    generate(): Promise<{
+        statements: string[];
+    }>;
+    migrateCli(opts?: {
+        name?: string;
+        track?: boolean;
+    }): Promise<void>;
+    push(opts?: {
+        dropExtraColumns?: boolean;
+        preserveData?: boolean;
+    }): Promise<void>;
+    pull(): Promise<Record<string, any>>;
+    studio(): Promise<{
+        driver: string;
+        path: any;
+    }>;
+    private ensureSchemaMeta;
+    private getSchemaMeta;
+    private setSchemaMeta;
+    private normalizeColumn;
+    private computeModelSignature;
+    isSchemaDirty(): Promise<{
+        dirty: boolean;
+        current: string;
+        stored: string | null;
+    }>;
+    migrateIfDirty(options?: {
+        name?: string;
+        track?: boolean;
+    }): Promise<boolean>;
+    pullSchema(): Promise<Record<string, any>>;
+    private buildCreateTableSQL;
+    private tableExists;
+    forcePush(options?: {
+        dropExtraColumns?: boolean;
+        preserveData?: boolean;
+    }): Promise<void>;
 }
 declare const db: TauriORM;
 type OneConfig = {

package/dist/index.d.ts

@@ -25,6 +25,7 @@ interface Column<T = any> {
     autoIncrement?: boolean;
     isNotNull?: boolean;
     defaultValue?: T | SQLExpression;
+    defaultFn?: () => any;
     references?: {
         table: string;
         column: string;
@@ -46,6 +47,7 @@ type ColumnBuilder<T> = Column<T> & {
     notNull: () => ColumnBuilder<T>;
     default: (value: T | SQLExpression) => ColumnBuilder<T>;
     $type: <U>() => ColumnBuilder<U>;
+    $defaultFn: (fn: () => any) => ColumnBuilder<T>;
     references: (target: () => Column<any>, actions?: {
         onDelete?: UpdateDeleteAction;
         onUpdate?: UpdateDeleteAction;
@@ -152,6 +154,60 @@ declare class TauriORM {
         name?: string;
         track?: boolean;
     }): Promise<void>;
+    diffSchema(): Promise<{
+        extraTables: string[];
+        missingTables: string[];
+        tables: Record<string, {
+            missingColumns: string[];
+            extraColumns: string[];
+            changedColumns: Array<{
+                name: string;
+                diffs: {
+                    type?: boolean;
+                    pk?: boolean;
+                    notNull?: boolean;
+                    default?: boolean;
+                };
+            }>;
+        }>;
+    }>;
+    generate(): Promise<{
+        statements: string[];
+    }>;
+    migrateCli(opts?: {
+        name?: string;
+        track?: boolean;
+    }): Promise<void>;
+    push(opts?: {
+        dropExtraColumns?: boolean;
+        preserveData?: boolean;
+    }): Promise<void>;
+    pull(): Promise<Record<string, any>>;
+    studio(): Promise<{
+        driver: string;
+        path: any;
+    }>;
+    private ensureSchemaMeta;
+    private getSchemaMeta;
+    private setSchemaMeta;
+    private normalizeColumn;
+    private computeModelSignature;
+    isSchemaDirty(): Promise<{
+        dirty: boolean;
+        current: string;
+        stored: string | null;
+    }>;
+    migrateIfDirty(options?: {
+        name?: string;
+        track?: boolean;
+    }): Promise<boolean>;
+    pullSchema(): Promise<Record<string, any>>;
+    private buildCreateTableSQL;
+    private tableExists;
+    forcePush(options?: {
+        dropExtraColumns?: boolean;
+        preserveData?: boolean;
+    }): Promise<void>;
 }
 declare const db: TauriORM;
 type OneConfig = {

package/dist/index.js

@@ -95,6 +95,10 @@ function createColumn(params) {
     return col;
   };
   col.$type = () => col;
+  col.$defaultFn = (fn) => {
+    col.defaultFn = fn;
+    return col;
+  };
   col.references = (target, actions) => {
     const t = target();
     col.references = {
@@ -289,8 +293,15 @@ var TauriORM = class {
       async execute() {
         const db3 = getDb();
         for (const data of this._rows) {
-          const keys = Object.keys(data);
-          const values = Object.values(data);
+          const finalData = { ...data };
+          const schema = this._table._schema;
+          for (const [key, col] of Object.entries(schema)) {
+            if (finalData[key] === void 0 && col.defaultFn) {
+              finalData[key] = col.defaultFn();
+            }
+          }
+          const keys = Object.keys(finalData);
+          const values = Object.values(finalData);
           const placeholders = values.map(() => "?").join(", ");
           const query = `INSERT INTO ${this._table._tableName} (${keys.join(
             ", "
@@ -462,6 +473,250 @@ var TauriORM = class {
       throw new Error("No tables configured. Call db.configure({...}) first.");
     await this.migrate(Object.values(this._tables), options);
   }
+  // --- Schema diff and CLI-like helpers ---
+  async diffSchema() {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = getDb();
+    const configuredNames = Object.values(this._tables).map(
+      (t) => t._tableName
+    );
+    const existing = await dbi.select(
+      `SELECT name FROM sqlite_master WHERE type='table'`
+    );
+    const existingNames = existing.map((r) => r.name);
+    const extraTables = existingNames.filter(
+      (n) => !configuredNames.includes(n)
+    );
+    const missingTables = configuredNames.filter(
+      (n) => !existingNames.includes(n)
+    );
+    const tables = {};
+    for (const tbl of Object.values(this._tables)) {
+      const tableName = tbl._tableName;
+      if (!existingNames.includes(tableName)) {
+        tables[tableName] = {
+          missingColumns: Object.keys(tbl._schema),
+          extraColumns: [],
+          changedColumns: []
+        };
+        continue;
+      }
+      const cols = await dbi.select(`PRAGMA table_info('${tableName}')`);
+      const colMap = new Map(cols.map((c) => [c.name, c]));
+      const modelCols = Object.values(
+        tbl._schema
+      );
+      const missingColumns = [];
+      const extraColumns = [];
+      const changedColumns = [];
+      const modelNamesSet = new Set(modelCols.map((c) => c.name));
+      for (const m of modelCols) {
+        const info = colMap.get(m.name);
+        if (!info) {
+          missingColumns.push(m.name);
+          continue;
+        }
+        const diffs = {};
+        if ((info.type || "").toUpperCase() !== m.type.toUpperCase())
+          diffs.type = true;
+        if (!!info.pk !== !!m.isPrimaryKey) diffs.pk = true;
+        if (!!info.notnull !== !!m.isNotNull) diffs.notNull = true;
+        const modelDv = m.defaultValue && typeof m.defaultValue === "object" && m.defaultValue.raw ? m.defaultValue.raw : m.defaultValue ?? null;
+        if ((info.dflt_value ?? null) !== modelDv)
+          diffs.default = true;
+        if (Object.keys(diffs).length)
+          changedColumns.push({ name: m.name, diffs });
+      }
+      for (const c of cols)
+        if (!modelNamesSet.has(c.name)) extraColumns.push(c.name);
+      tables[tableName] = { missingColumns, extraColumns, changedColumns };
+    }
+    return { extraTables, missingTables, tables };
+  }
+  async generate() {
+    if (!this._tables) throw new Error("No tables configured.");
+    return {
+      statements: Object.values(this._tables).map(
+        (t) => this.buildCreateTableSQL(t)
+      )
+    };
+  }
+  async migrateCli(opts) {
+    return this.migrateConfigured(opts);
+  }
+  async push(opts) {
+    return this.forcePush(opts);
+  }
+  async pull() {
+    return this.pullSchema();
+  }
+  async studio() {
+    const dbi = getDb();
+    return { driver: "sqlite", path: dbi.path };
+  }
+  // --- Schema detection / signature ---
+  async ensureSchemaMeta() {
+    await this.run(
+      `CREATE TABLE IF NOT EXISTS _schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+    );
+  }
+  async getSchemaMeta(key) {
+    const dbi = getDb();
+    await this.ensureSchemaMeta();
+    const rows = await dbi.select(
+      `SELECT value FROM _schema_meta WHERE key = ?`,
+      [key]
+    );
+    return rows?.[0]?.value ?? null;
+  }
+  async setSchemaMeta(key, value) {
+    const dbi = getDb();
+    await this.ensureSchemaMeta();
+    await dbi.execute(
+      `INSERT INTO _schema_meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+      [key, value]
+    );
+  }
+  normalizeColumn(col) {
+    return {
+      name: col.name,
+      type: col.type,
+      pk: !!col.isPrimaryKey,
+      ai: !!col.autoIncrement,
+      nn: !!col.isNotNull,
+      dv: col.defaultValue && typeof col.defaultValue === "object" && col.defaultValue.raw ? { raw: col.defaultValue.raw } : col.defaultValue ?? null
+    };
+  }
+  computeModelSignature() {
+    if (!this._tables) return "";
+    const entries = Object.entries(this._tables).map(([k, tbl]) => {
+      const cols = Object.values(
+        tbl._schema
+      ).map((c) => this.normalizeColumn(c)).sort((a, b) => a.name.localeCompare(b.name));
+      return { table: tbl._tableName, columns: cols };
+    });
+    entries.sort((a, b) => a.table.localeCompare(b.table));
+    return JSON.stringify(entries);
+  }
+  async isSchemaDirty() {
+    const sig = this.computeModelSignature();
+    const stored = await this.getSchemaMeta("schema_signature");
+    return { dirty: sig !== stored, current: sig, stored };
+  }
+  async migrateIfDirty(options) {
+    const status = await this.isSchemaDirty();
+    if (!this._tables) throw new Error("No tables configured.");
+    if (status.dirty) {
+      await this.migrate(Object.values(this._tables), options);
+      await this.setSchemaMeta(
+        "schema_signature",
+        this.computeModelSignature()
+      );
+      return true;
+    }
+    return false;
+  }
+  // Pull current DB schema (minimal) for configured tables
+  async pullSchema() {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = getDb();
+    const result = {};
+    for (const tbl of Object.values(this._tables)) {
+      const name = tbl._tableName;
+      const cols = await dbi.select(`PRAGMA table_info('${name}')`);
+      result[name] = cols.map((c) => ({
+        name: c.name,
+        type: c.type,
+        notnull: !!c.notnull,
+        pk: !!c.pk,
+        dflt_value: c.dflt_value ?? null
+      }));
+    }
+    return result;
+  }
+  buildCreateTableSQL(table) {
+    return this.generateCreateTableSql(table);
+  }
+  async tableExists(name) {
+    const dbi = getDb();
+    const rows = await dbi.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`,
+      [name]
+    );
+    return rows.length > 0;
+  }
+  // Force push model to DB: add missing tables/columns, rebuild tables if incompatible
+  async forcePush(options) {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = getDb();
+    const preserve = options?.preserveData !== false;
+    for (const tbl of Object.values(this._tables)) {
+      const tableName = tbl._tableName;
+      const exists = await this.tableExists(tableName);
+      if (!exists) {
+        await this.run(this.buildCreateTableSQL(tbl));
+        continue;
+      }
+      const existingCols = await dbi.select(
+        `PRAGMA table_info('${tableName}')`
+      );
+      const existingMap = new Map(existingCols.map((c) => [c.name, c]));
+      const modelCols = Object.values(
+        tbl._schema
+      );
+      const missing = [];
+      let requiresRebuild = false;
+      for (const m of modelCols) {
+        const info = existingMap.get(m.name);
+        if (!info) {
+          missing.push(m);
+          continue;
+        }
+        const typeDiff = (info.type || "").toUpperCase() !== m.type.toUpperCase();
+        const pkDiff = !!info.pk !== !!m.isPrimaryKey;
+        const nnDiff = !!info.notnull !== !!m.isNotNull;
+        const modelDv = m.defaultValue && typeof m.defaultValue === "object" && m.defaultValue.raw ? m.defaultValue.raw : m.defaultValue ?? null;
+        const defDiff = (info.dflt_value ?? null) !== modelDv;
+        if (typeDiff || pkDiff || nnDiff && !modelDv || defDiff) {
+          requiresRebuild = true;
+        }
+      }
+      if (requiresRebuild) {
+        const tmp = `_new_${tableName}`;
+        await this.run(this.buildCreateTableSQL(tbl));
+        await this.run(
+          this.buildCreateTableSQL({ ...tbl, _tableName: tmp })
+        );
+        const existingNames = existingCols.map((c) => c.name);
+        const modelNames = modelCols.map((c) => c.name);
+        const shared = existingNames.filter((n) => modelNames.includes(n));
+        if (preserve && shared.length > 0) {
+          await this.run(
+            `INSERT INTO ${tmp} (${shared.join(", ")}) SELECT ${shared.join(
+              ", "
+            )} FROM ${tableName}`
+          );
+        }
+        await this.run(`DROP TABLE ${tableName}`);
+        await this.run(`ALTER TABLE ${tmp} RENAME TO ${tableName}`);
+      } else {
+        for (const m of missing) {
+          let clause = `${m.name} ${m.type}`;
+          if (m.isNotNull) clause += " NOT NULL";
+          if (m.defaultValue !== void 0) {
+            const dv = m.defaultValue;
+            if (dv && typeof dv === "object" && "raw" in dv)
+              clause += ` DEFAULT ${dv.raw}`;
+            else if (typeof dv === "string")
+              clause += ` DEFAULT '${dv.replace(/'/g, "''")}'`;
+            else clause += ` DEFAULT ${dv}`;
+          }
+          await this.run(`ALTER TABLE ${tableName} ADD COLUMN ${clause}`);
+        }
+      }
+    }
+    await this.setSchemaMeta("schema_signature", this.computeModelSignature());
+  }
 };
 var db2 = new TauriORM();
 function relations(baseTable, builder) {

package/dist/index.mjs

@@ -36,6 +36,10 @@ function createColumn(params) {
     return col;
   };
   col.$type = () => col;
+  col.$defaultFn = (fn) => {
+    col.defaultFn = fn;
+    return col;
+  };
   col.references = (target, actions) => {
     const t = target();
     col.references = {
@@ -230,8 +234,15 @@ var TauriORM = class {
       async execute() {
         const db3 = getDb();
         for (const data of this._rows) {
-          const keys = Object.keys(data);
-          const values = Object.values(data);
+          const finalData = { ...data };
+          const schema = this._table._schema;
+          for (const [key, col] of Object.entries(schema)) {
+            if (finalData[key] === void 0 && col.defaultFn) {
+              finalData[key] = col.defaultFn();
+            }
+          }
+          const keys = Object.keys(finalData);
+          const values = Object.values(finalData);
           const placeholders = values.map(() => "?").join(", ");
           const query = `INSERT INTO ${this._table._tableName} (${keys.join(
             ", "
@@ -403,6 +414,250 @@ var TauriORM = class {
       throw new Error("No tables configured. Call db.configure({...}) first.");
     await this.migrate(Object.values(this._tables), options);
   }
+  // --- Schema diff and CLI-like helpers ---
+  async diffSchema() {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = getDb();
+    const configuredNames = Object.values(this._tables).map(
+      (t) => t._tableName
+    );
+    const existing = await dbi.select(
+      `SELECT name FROM sqlite_master WHERE type='table'`
+    );
+    const existingNames = existing.map((r) => r.name);
+    const extraTables = existingNames.filter(
+      (n) => !configuredNames.includes(n)
+    );
+    const missingTables = configuredNames.filter(
+      (n) => !existingNames.includes(n)
+    );
+    const tables = {};
+    for (const tbl of Object.values(this._tables)) {
+      const tableName = tbl._tableName;
+      if (!existingNames.includes(tableName)) {
+        tables[tableName] = {
+          missingColumns: Object.keys(tbl._schema),
+          extraColumns: [],
+          changedColumns: []
+        };
+        continue;
+      }
+      const cols = await dbi.select(`PRAGMA table_info('${tableName}')`);
+      const colMap = new Map(cols.map((c) => [c.name, c]));
+      const modelCols = Object.values(
+        tbl._schema
+      );
+      const missingColumns = [];
+      const extraColumns = [];
+      const changedColumns = [];
+      const modelNamesSet = new Set(modelCols.map((c) => c.name));
+      for (const m of modelCols) {
+        const info = colMap.get(m.name);
+        if (!info) {
+          missingColumns.push(m.name);
+          continue;
+        }
+        const diffs = {};
+        if ((info.type || "").toUpperCase() !== m.type.toUpperCase())
+          diffs.type = true;
+        if (!!info.pk !== !!m.isPrimaryKey) diffs.pk = true;
+        if (!!info.notnull !== !!m.isNotNull) diffs.notNull = true;
+        const modelDv = m.defaultValue && typeof m.defaultValue === "object" && m.defaultValue.raw ? m.defaultValue.raw : m.defaultValue ?? null;
+        if ((info.dflt_value ?? null) !== modelDv)
+          diffs.default = true;
+        if (Object.keys(diffs).length)
+          changedColumns.push({ name: m.name, diffs });
+      }
+      for (const c of cols)
+        if (!modelNamesSet.has(c.name)) extraColumns.push(c.name);
+      tables[tableName] = { missingColumns, extraColumns, changedColumns };
+    }
+    return { extraTables, missingTables, tables };
+  }
+  async generate() {
+    if (!this._tables) throw new Error("No tables configured.");
+    return {
+      statements: Object.values(this._tables).map(
+        (t) => this.buildCreateTableSQL(t)
+      )
+    };
+  }
+  async migrateCli(opts) {
+    return this.migrateConfigured(opts);
+  }
+  async push(opts) {
+    return this.forcePush(opts);
+  }
+  async pull() {
+    return this.pullSchema();
+  }
+  async studio() {
+    const dbi = getDb();
+    return { driver: "sqlite", path: dbi.path };
+  }
+  // --- Schema detection / signature ---
+  async ensureSchemaMeta() {
+    await this.run(
+      `CREATE TABLE IF NOT EXISTS _schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+    );
+  }
+  async getSchemaMeta(key) {
+    const dbi = getDb();
+    await this.ensureSchemaMeta();
+    const rows = await dbi.select(
+      `SELECT value FROM _schema_meta WHERE key = ?`,
+      [key]
+    );
+    return rows?.[0]?.value ?? null;
+  }
+  async setSchemaMeta(key, value) {
+    const dbi = getDb();
+    await this.ensureSchemaMeta();
+    await dbi.execute(
+      `INSERT INTO _schema_meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+      [key, value]
+    );
+  }
+  normalizeColumn(col) {
+    return {
+      name: col.name,
+      type: col.type,
+      pk: !!col.isPrimaryKey,
+      ai: !!col.autoIncrement,
+      nn: !!col.isNotNull,
+      dv: col.defaultValue && typeof col.defaultValue === "object" && col.defaultValue.raw ? { raw: col.defaultValue.raw } : col.defaultValue ?? null
+    };
+  }
+  computeModelSignature() {
+    if (!this._tables) return "";
+    const entries = Object.entries(this._tables).map(([k, tbl]) => {
+      const cols = Object.values(
+        tbl._schema
+      ).map((c) => this.normalizeColumn(c)).sort((a, b) => a.name.localeCompare(b.name));
+      return { table: tbl._tableName, columns: cols };
+    });
+    entries.sort((a, b) => a.table.localeCompare(b.table));
+    return JSON.stringify(entries);
+  }
+  async isSchemaDirty() {
+    const sig = this.computeModelSignature();
+    const stored = await this.getSchemaMeta("schema_signature");
+    return { dirty: sig !== stored, current: sig, stored };
+  }
+  async migrateIfDirty(options) {
+    const status = await this.isSchemaDirty();
+    if (!this._tables) throw new Error("No tables configured.");
+    if (status.dirty) {
+      await this.migrate(Object.values(this._tables), options);
+      await this.setSchemaMeta(
+        "schema_signature",
+        this.computeModelSignature()
+      );
+      return true;
+    }
+    return false;
+  }
+  // Pull current DB schema (minimal) for configured tables
+  async pullSchema() {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = getDb();
+    const result = {};
+    for (const tbl of Object.values(this._tables)) {
+      const name = tbl._tableName;
+      const cols = await dbi.select(`PRAGMA table_info('${name}')`);
+      result[name] = cols.map((c) => ({
+        name: c.name,
+        type: c.type,
+        notnull: !!c.notnull,
+        pk: !!c.pk,
+        dflt_value: c.dflt_value ?? null
+      }));
+    }
+    return result;
+  }
+  buildCreateTableSQL(table) {
+    return this.generateCreateTableSql(table);
+  }
+  async tableExists(name) {
+    const dbi = getDb();
+    const rows = await dbi.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`,
+      [name]
+    );
+    return rows.length > 0;
+  }
+  // Force push model to DB: add missing tables/columns, rebuild tables if incompatible
+  async forcePush(options) {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = getDb();
+    const preserve = options?.preserveData !== false;
+    for (const tbl of Object.values(this._tables)) {
+      const tableName = tbl._tableName;
+      const exists = await this.tableExists(tableName);
+      if (!exists) {
+        await this.run(this.buildCreateTableSQL(tbl));
+        continue;
+      }
+      const existingCols = await dbi.select(
+        `PRAGMA table_info('${tableName}')`
+      );
+      const existingMap = new Map(existingCols.map((c) => [c.name, c]));
+      const modelCols = Object.values(
+        tbl._schema
+      );
+      const missing = [];
+      let requiresRebuild = false;
+      for (const m of modelCols) {
+        const info = existingMap.get(m.name);
+        if (!info) {
+          missing.push(m);
+          continue;
+        }
+        const typeDiff = (info.type || "").toUpperCase() !== m.type.toUpperCase();
+        const pkDiff = !!info.pk !== !!m.isPrimaryKey;
+        const nnDiff = !!info.notnull !== !!m.isNotNull;
+        const modelDv = m.defaultValue && typeof m.defaultValue === "object" && m.defaultValue.raw ? m.defaultValue.raw : m.defaultValue ?? null;
+        const defDiff = (info.dflt_value ?? null) !== modelDv;
+        if (typeDiff || pkDiff || nnDiff && !modelDv || defDiff) {
+          requiresRebuild = true;
+        }
+      }
+      if (requiresRebuild) {
+        const tmp = `_new_${tableName}`;
+        await this.run(this.buildCreateTableSQL(tbl));
+        await this.run(
+          this.buildCreateTableSQL({ ...tbl, _tableName: tmp })
+        );
+        const existingNames = existingCols.map((c) => c.name);
+        const modelNames = modelCols.map((c) => c.name);
+        const shared = existingNames.filter((n) => modelNames.includes(n));
+        if (preserve && shared.length > 0) {
+          await this.run(
+            `INSERT INTO ${tmp} (${shared.join(", ")}) SELECT ${shared.join(
+              ", "
+            )} FROM ${tableName}`
+          );
+        }
+        await this.run(`DROP TABLE ${tableName}`);
+        await this.run(`ALTER TABLE ${tmp} RENAME TO ${tableName}`);
+      } else {
+        for (const m of missing) {
+          let clause = `${m.name} ${m.type}`;
+          if (m.isNotNull) clause += " NOT NULL";
+          if (m.defaultValue !== void 0) {
+            const dv = m.defaultValue;
+            if (dv && typeof dv === "object" && "raw" in dv)
+              clause += ` DEFAULT ${dv.raw}`;
+            else if (typeof dv === "string")
+              clause += ` DEFAULT '${dv.replace(/'/g, "''")}'`;
+            else clause += ` DEFAULT ${dv}`;
+          }
+          await this.run(`ALTER TABLE ${tableName} ADD COLUMN ${clause}`);
+        }
+      }
+    }
+    await this.setSchemaMeta("schema_signature", this.computeModelSignature());
+  }
 };
 var db2 = new TauriORM();
 function relations(baseTable, builder) {

package/package.json

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