@type32/tauri-sqlite-orm 0.1.18-11 → 0.1.18-12

package/dist/index.d.mts

@@ -49,7 +49,7 @@ declare class BaseQueryBuilder {
     };
 }
 
-declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable["_"]["columns"])[] | undefined = undefined> extends BaseQueryBuilder {
+declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable['_']['columns'])[] | undefined = undefined> extends BaseQueryBuilder {
     private table;
     private columns?;
     private isDistinct;
@@ -57,15 +57,17 @@ declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns exten
     private havingCondition;
     private joins;
     private includeRelations;
+    private selectedTableAlias;
     constructor(db: Database, table: TTable, columns?: TSelectedColumns | undefined);
     distinct(): this;
     groupBy(...columns: AnySQLiteColumn[]): this;
     having(condition: SQLCondition): this;
-    leftJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias?: string): this;
-    innerJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias?: string): this;
+    leftJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias: string): this;
+    innerJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias: string): this;
     include(relations: Record<string, boolean>): this;
     private buildJoins;
     execute(): Promise<any[]>;
+    private processRelationResults;
     all(): Promise<any[]>;
     get(): Promise<any | undefined>;
 }
@@ -247,7 +249,7 @@ declare const relations: <T extends AnyTable, R extends Record<string, Relation>
 declare const getTableColumns: <T extends AnyTable>(table: T) => Record<string, AnySQLiteColumn>;
 declare const alias: <T extends AnyTable>(table: T, alias: string) => Table<T["_"]["columns"], T["_"]["name"]>;
 
-declare const eq: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const eq: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => SQLCondition;
 declare const and: (...conditions: SQLCondition[]) => SQLCondition;
 declare const or: (...conditions: SQLCondition[]) => SQLCondition;
 declare const not: (condition: SQLCondition) => SQLCondition;

package/dist/index.d.ts

@@ -49,7 +49,7 @@ declare class BaseQueryBuilder {
     };
 }
 
-declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable["_"]["columns"])[] | undefined = undefined> extends BaseQueryBuilder {
+declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable['_']['columns'])[] | undefined = undefined> extends BaseQueryBuilder {
     private table;
     private columns?;
     private isDistinct;
@@ -57,15 +57,17 @@ declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns exten
     private havingCondition;
     private joins;
     private includeRelations;
+    private selectedTableAlias;
     constructor(db: Database, table: TTable, columns?: TSelectedColumns | undefined);
     distinct(): this;
     groupBy(...columns: AnySQLiteColumn[]): this;
     having(condition: SQLCondition): this;
-    leftJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias?: string): this;
-    innerJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias?: string): this;
+    leftJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias: string): this;
+    innerJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias: string): this;
     include(relations: Record<string, boolean>): this;
     private buildJoins;
     execute(): Promise<any[]>;
+    private processRelationResults;
     all(): Promise<any[]>;
     get(): Promise<any | undefined>;
 }
@@ -247,7 +249,7 @@ declare const relations: <T extends AnyTable, R extends Record<string, Relation>
 declare const getTableColumns: <T extends AnyTable>(table: T) => Record<string, AnySQLiteColumn>;
 declare const alias: <T extends AnyTable>(table: T, alias: string) => Table<T["_"]["columns"], T["_"]["name"]>;
 
-declare const eq: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const eq: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => SQLCondition;
 declare const and: (...conditions: SQLCondition[]) => SQLCondition;
 declare const or: (...conditions: SQLCondition[]) => SQLCondition;
 declare const not: (condition: SQLCondition) => SQLCondition;

package/dist/index.js

@@ -103,10 +103,13 @@ var BaseQueryBuilder = class {
 };
 
 // src/operators.ts
-var eq = (column, value) => ({
-  sql: `${column._.name} = ?`,
-  params: [value]
-});
+var eq = (column, value, tableAlias) => {
+  const columnName = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  return {
+    sql: `${columnName} = ?`,
+    params: [value]
+  };
+};
 var and = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" AND "),
   params: conditions.flatMap((c) => c.params)
@@ -182,14 +185,17 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     super(db);
     this.table = table;
     this.columns = columns;
-    const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
-    this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
+    this.selectedTableAlias = table._.name;
+    const columnNames = columns ? columns.map((c) => `${this.selectedTableAlias}.${table._.columns[c]._.name}`) : [`${this.selectedTableAlias}.*`];
+    this.query = `SELECT ${columnNames.join(", ")}
+                      FROM ${table._.name} ${this.selectedTableAlias}`;
   }
   isDistinct = false;
   groupByColumns = [];
   havingCondition = null;
   joins = [];
   includeRelations = {};
+  selectedTableAlias;
   distinct() {
     this.isDistinct = true;
     this.query = this.query.replace("SELECT", "SELECT DISTINCT");
@@ -197,7 +203,7 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
   }
   groupBy(...columns) {
     this.groupByColumns.push(...columns);
-    const columnNames = columns.map((col) => col._.name).join(", ");
+    const columnNames = columns.map((col) => `${this.selectedTableAlias}.${col._.name}`).join(", ");
     this.query += ` GROUP BY ${columnNames}`;
     return this;
   }
@@ -223,48 +229,104 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     let sql2 = "";
     const params = [];
     for (const join of this.joins) {
-      const tableAlias = join.alias || join.table._.name;
-      sql2 += ` ${join.type} JOIN ${join.table._.name} ${tableAlias} ON ${join.condition.sql}`;
+      sql2 += ` ${join.type} JOIN ${join.table._.name} ${join.alias} ON ${join.condition.sql}`;
       params.push(...join.condition.params);
     }
-    for (const [relationName, include] of Object.entries(
-      this.includeRelations
-    )) {
+    for (const [relationName, include] of Object.entries(this.includeRelations)) {
       if (!include) continue;
       const relation = this.table.relations[relationName];
       if (!relation) continue;
       const foreignTable = relation.foreignTable;
-      const foreignAlias = `${this.table._.name}_${relationName}`;
+      const foreignAlias = `${this.selectedTableAlias}_${relationName}`;
       if (relation.type === "one" && relation.fields && relation.references) {
-        const conditions = relation.fields.map(
-          (field, i) => eq(field, relation.references[i])
-        );
+        const conditions = relation.fields.map((field, i) => {
+          const localColumn = `${this.selectedTableAlias}.${field._.name}`;
+          const foreignColumn = `${foreignAlias}.${relation.references[i]._.name}`;
+          return {
+            sql: `${localColumn} = ${foreignColumn}`,
+            params: []
+          };
+        });
         const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
         sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
         params.push(...condition.params);
       } else if (relation.type === "many") {
-        const refRelation = Object.values(foreignTable.relations).find(
-          (r) => r.foreignTable === this.table
+        const refRelation = Object.entries(foreignTable.relations).find(
+          ([_, r]) => r.foreignTable === this.table
         );
-        if (refRelation && refRelation.fields && refRelation.references) {
-          const conditions = refRelation.fields.map(
-            (field, i) => eq(field, refRelation.references[i])
-          );
+        if (refRelation && refRelation[1].fields && refRelation[1].references) {
+          const [_, relationConfig] = refRelation;
+          const conditions = relationConfig.fields.map((field, i) => {
+            const localColumn = `${foreignAlias}.${field._.name}`;
+            const foreignColumn = `${this.selectedTableAlias}.${relationConfig.references[i]._.name}`;
+            return {
+              sql: `${localColumn} = ${foreignColumn}`,
+              params: []
+            };
+          });
           const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
           sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
           params.push(...condition.params);
+          this.query = this.query.replace("SELECT ", `SELECT ${this.selectedTableAlias}.*, ${foreignAlias}.* `).replace(
+            `SELECT ${this.selectedTableAlias}.*, `,
+            `SELECT ${this.selectedTableAlias}.*, ${foreignAlias}.*, `
+          );
         }
       }
     }
     return { sql: sql2, params };
   }
+  // Enhanced execute method that handles relation data mapping
   async execute() {
     const { sql: joinSql, params: joinParams } = this.buildJoins();
     this.query += joinSql;
     this.params.push(...joinParams);
     const { sql: sql2, params } = this.build();
-    return this.db.select(sql2, params);
+    console.log("Executing SQL:", sql2, "with params:", params);
+    const rawResults = await this.db.select(sql2, params);
+    if (Object.keys(this.includeRelations).some((key) => this.includeRelations[key])) {
+      const processed = this.processRelationResults(rawResults);
+      return processed;
+    }
+    return rawResults;
+  }
+  processRelationResults(rawResults) {
+    if (!rawResults.length) return rawResults;
+    return rawResults.map((row) => {
+      const result = {};
+      const relations2 = {};
+      for (const [key, value] of Object.entries(row)) {
+        if (key.includes(".")) {
+          const [tableAlias, columnName] = key.split(".");
+          if (tableAlias === this.selectedTableAlias) {
+            result[columnName] = value;
+          } else {
+            const parts = tableAlias.split("_");
+            if (parts.length >= 2 && parts[0] === this.selectedTableAlias) {
+              const relationName = parts.slice(1).join("_");
+              if (!relations2[relationName]) relations2[relationName] = {};
+              relations2[relationName][columnName] = value;
+            } else {
+              if (!result[tableAlias]) result[tableAlias] = {};
+              result[tableAlias][columnName] = value;
+            }
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      for (const [relName, relData] of Object.entries(relations2)) {
+        const hasData = Object.values(relData).some(
+          (v) => v !== null && v !== void 0 && v !== ""
+        );
+        if (hasData) {
+          result[relName] = relData;
+        }
+      }
+      return result;
+    });
   }
+  // Update the return type signatures
   async all() {
     return this.execute();
   }
@@ -477,7 +539,8 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
   constructor(db, table) {
     super(db);
     this.table = table;
-    this.query = `DELETE FROM ${table._.name}`;
+    this.query = `DELETE
+                      FROM ${table._.name}`;
   }
   returningColumns = [];
   returning(...columns) {
@@ -687,9 +750,7 @@ var TauriORM = class {
       for (const [key, value] of Object.entries(schema)) {
         if (!(value instanceof Table) && typeof value === "object") {
           const tableName = key.replace("Relations", "");
-          const table = Array.from(this.tables.values()).find(
-            (t) => t._.name === tableName
-          );
+          const table = Array.from(this.tables.values()).find((t) => t._.name === tableName);
           if (table) {
             for (const [relName, rel] of Object.entries(value)) {
               if (rel instanceof OneRelation) {
@@ -738,7 +799,10 @@ var TauriORM = class {
       );
       if (existingTableInfo.length === 0) {
         const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
-        const createSql = `CREATE TABLE ${table._.name} (${columnsSql})`;
+        const createSql = `CREATE TABLE ${table._.name}
+                                   (
+                                       ${columnsSql}
+                                   )`;
         await this.db.execute(createSql);
       } else {
         const existingColumnNames = new Set(
@@ -747,7 +811,8 @@ var TauriORM = class {
         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} ADD COLUMN ${columnSql}`;
+            const alterSql = `ALTER TABLE ${table._.name}
+                            ADD COLUMN ${columnSql}`;
             await this.db.execute(alterSql);
           }
         }
@@ -792,13 +857,25 @@ var TauriORM = class {
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
-      `CREATE TABLE IF NOT EXISTS _schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+      `CREATE TABLE IF NOT EXISTS _schema_meta
+             (
+                 key
+                 TEXT
+                 PRIMARY
+                 KEY,
+                 value
+                 TEXT
+                 NOT
+                 NULL
+             )`
     );
   }
   async getSchemaMeta(key) {
     await this.ensureSchemaMeta();
     const rows = await this.db.select(
-      `SELECT value FROM _schema_meta WHERE key = ?`,
+      `SELECT value
+             FROM _schema_meta
+             WHERE key = ?`,
       [key]
     );
     return rows?.[0]?.value ?? null;
@@ -806,7 +883,10 @@ var TauriORM = class {
   async setSchemaMeta(key, value) {
     await this.ensureSchemaMeta();
     await this.db.execute(
-      `INSERT INTO _schema_meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+      `INSERT INTO _schema_meta(key, value)
+             VALUES (?, ?) ON CONFLICT(key) DO
+             UPDATE
+             SET value = excluded.value`,
       [key, value]
     );
   }

package/dist/index.mjs

@@ -36,10 +36,13 @@ var BaseQueryBuilder = class {
 };
 
 // src/operators.ts
-var eq = (column, value) => ({
-  sql: `${column._.name} = ?`,
-  params: [value]
-});
+var eq = (column, value, tableAlias) => {
+  const columnName = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  return {
+    sql: `${columnName} = ?`,
+    params: [value]
+  };
+};
 var and = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" AND "),
   params: conditions.flatMap((c) => c.params)
@@ -115,14 +118,17 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     super(db);
     this.table = table;
     this.columns = columns;
-    const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
-    this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
+    this.selectedTableAlias = table._.name;
+    const columnNames = columns ? columns.map((c) => `${this.selectedTableAlias}.${table._.columns[c]._.name}`) : [`${this.selectedTableAlias}.*`];
+    this.query = `SELECT ${columnNames.join(", ")}
+                      FROM ${table._.name} ${this.selectedTableAlias}`;
   }
   isDistinct = false;
   groupByColumns = [];
   havingCondition = null;
   joins = [];
   includeRelations = {};
+  selectedTableAlias;
   distinct() {
     this.isDistinct = true;
     this.query = this.query.replace("SELECT", "SELECT DISTINCT");
@@ -130,7 +136,7 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
   }
   groupBy(...columns) {
     this.groupByColumns.push(...columns);
-    const columnNames = columns.map((col) => col._.name).join(", ");
+    const columnNames = columns.map((col) => `${this.selectedTableAlias}.${col._.name}`).join(", ");
     this.query += ` GROUP BY ${columnNames}`;
     return this;
   }
@@ -156,48 +162,104 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     let sql2 = "";
     const params = [];
     for (const join of this.joins) {
-      const tableAlias = join.alias || join.table._.name;
-      sql2 += ` ${join.type} JOIN ${join.table._.name} ${tableAlias} ON ${join.condition.sql}`;
+      sql2 += ` ${join.type} JOIN ${join.table._.name} ${join.alias} ON ${join.condition.sql}`;
       params.push(...join.condition.params);
     }
-    for (const [relationName, include] of Object.entries(
-      this.includeRelations
-    )) {
+    for (const [relationName, include] of Object.entries(this.includeRelations)) {
       if (!include) continue;
       const relation = this.table.relations[relationName];
       if (!relation) continue;
       const foreignTable = relation.foreignTable;
-      const foreignAlias = `${this.table._.name}_${relationName}`;
+      const foreignAlias = `${this.selectedTableAlias}_${relationName}`;
       if (relation.type === "one" && relation.fields && relation.references) {
-        const conditions = relation.fields.map(
-          (field, i) => eq(field, relation.references[i])
-        );
+        const conditions = relation.fields.map((field, i) => {
+          const localColumn = `${this.selectedTableAlias}.${field._.name}`;
+          const foreignColumn = `${foreignAlias}.${relation.references[i]._.name}`;
+          return {
+            sql: `${localColumn} = ${foreignColumn}`,
+            params: []
+          };
+        });
         const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
         sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
         params.push(...condition.params);
       } else if (relation.type === "many") {
-        const refRelation = Object.values(foreignTable.relations).find(
-          (r) => r.foreignTable === this.table
+        const refRelation = Object.entries(foreignTable.relations).find(
+          ([_, r]) => r.foreignTable === this.table
         );
-        if (refRelation && refRelation.fields && refRelation.references) {
-          const conditions = refRelation.fields.map(
-            (field, i) => eq(field, refRelation.references[i])
-          );
+        if (refRelation && refRelation[1].fields && refRelation[1].references) {
+          const [_, relationConfig] = refRelation;
+          const conditions = relationConfig.fields.map((field, i) => {
+            const localColumn = `${foreignAlias}.${field._.name}`;
+            const foreignColumn = `${this.selectedTableAlias}.${relationConfig.references[i]._.name}`;
+            return {
+              sql: `${localColumn} = ${foreignColumn}`,
+              params: []
+            };
+          });
           const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
           sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
           params.push(...condition.params);
+          this.query = this.query.replace("SELECT ", `SELECT ${this.selectedTableAlias}.*, ${foreignAlias}.* `).replace(
+            `SELECT ${this.selectedTableAlias}.*, `,
+            `SELECT ${this.selectedTableAlias}.*, ${foreignAlias}.*, `
+          );
         }
       }
     }
     return { sql: sql2, params };
   }
+  // Enhanced execute method that handles relation data mapping
   async execute() {
     const { sql: joinSql, params: joinParams } = this.buildJoins();
     this.query += joinSql;
     this.params.push(...joinParams);
     const { sql: sql2, params } = this.build();
-    return this.db.select(sql2, params);
+    console.log("Executing SQL:", sql2, "with params:", params);
+    const rawResults = await this.db.select(sql2, params);
+    if (Object.keys(this.includeRelations).some((key) => this.includeRelations[key])) {
+      const processed = this.processRelationResults(rawResults);
+      return processed;
+    }
+    return rawResults;
+  }
+  processRelationResults(rawResults) {
+    if (!rawResults.length) return rawResults;
+    return rawResults.map((row) => {
+      const result = {};
+      const relations2 = {};
+      for (const [key, value] of Object.entries(row)) {
+        if (key.includes(".")) {
+          const [tableAlias, columnName] = key.split(".");
+          if (tableAlias === this.selectedTableAlias) {
+            result[columnName] = value;
+          } else {
+            const parts = tableAlias.split("_");
+            if (parts.length >= 2 && parts[0] === this.selectedTableAlias) {
+              const relationName = parts.slice(1).join("_");
+              if (!relations2[relationName]) relations2[relationName] = {};
+              relations2[relationName][columnName] = value;
+            } else {
+              if (!result[tableAlias]) result[tableAlias] = {};
+              result[tableAlias][columnName] = value;
+            }
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      for (const [relName, relData] of Object.entries(relations2)) {
+        const hasData = Object.values(relData).some(
+          (v) => v !== null && v !== void 0 && v !== ""
+        );
+        if (hasData) {
+          result[relName] = relData;
+        }
+      }
+      return result;
+    });
   }
+  // Update the return type signatures
   async all() {
     return this.execute();
   }
@@ -410,7 +472,8 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
   constructor(db, table) {
     super(db);
     this.table = table;
-    this.query = `DELETE FROM ${table._.name}`;
+    this.query = `DELETE
+                      FROM ${table._.name}`;
   }
   returningColumns = [];
   returning(...columns) {
@@ -620,9 +683,7 @@ var TauriORM = class {
       for (const [key, value] of Object.entries(schema)) {
         if (!(value instanceof Table) && typeof value === "object") {
           const tableName = key.replace("Relations", "");
-          const table = Array.from(this.tables.values()).find(
-            (t) => t._.name === tableName
-          );
+          const table = Array.from(this.tables.values()).find((t) => t._.name === tableName);
           if (table) {
             for (const [relName, rel] of Object.entries(value)) {
               if (rel instanceof OneRelation) {
@@ -671,7 +732,10 @@ var TauriORM = class {
       );
       if (existingTableInfo.length === 0) {
         const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
-        const createSql = `CREATE TABLE ${table._.name} (${columnsSql})`;
+        const createSql = `CREATE TABLE ${table._.name}
+                                   (
+                                       ${columnsSql}
+                                   )`;
         await this.db.execute(createSql);
       } else {
         const existingColumnNames = new Set(
@@ -680,7 +744,8 @@ var TauriORM = class {
         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} ADD COLUMN ${columnSql}`;
+            const alterSql = `ALTER TABLE ${table._.name}
+                            ADD COLUMN ${columnSql}`;
             await this.db.execute(alterSql);
           }
         }
@@ -725,13 +790,25 @@ var TauriORM = class {
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
-      `CREATE TABLE IF NOT EXISTS _schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+      `CREATE TABLE IF NOT EXISTS _schema_meta
+             (
+                 key
+                 TEXT
+                 PRIMARY
+                 KEY,
+                 value
+                 TEXT
+                 NOT
+                 NULL
+             )`
     );
   }
   async getSchemaMeta(key) {
     await this.ensureSchemaMeta();
     const rows = await this.db.select(
-      `SELECT value FROM _schema_meta WHERE key = ?`,
+      `SELECT value
+             FROM _schema_meta
+             WHERE key = ?`,
       [key]
     );
     return rows?.[0]?.value ?? null;
@@ -739,7 +816,10 @@ var TauriORM = class {
   async setSchemaMeta(key, value) {
     await this.ensureSchemaMeta();
     await this.db.execute(
-      `INSERT INTO _schema_meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+      `INSERT INTO _schema_meta(key, value)
+             VALUES (?, ?) ON CONFLICT(key) DO
+             UPDATE
+             SET value = excluded.value`,
       [key, value]
     );
   }

package/package.json

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