@type32/tauri-sqlite-orm 0.1.18-17 → 0.1.18-19

package/dist/index.d.mts

@@ -246,7 +246,7 @@ declare class OneRelation<T extends AnyTable = AnyTable> extends Relation<T> {
 declare class ManyRelation<T extends AnyTable = AnyTable> extends Relation<T> {
     constructor(foreignTable: T);
 }
-declare const relations: <T extends AnyTable, R extends Record<string, Relation>>(_table: T, relationsCallback: (helpers: RelationsBuilder) => R) => R;
+declare const relations: <T extends AnyTable, R extends Record<string, Relation>>(table: T, relationsCallback: (helpers: RelationsBuilder) => R) => R;
 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"]>;
 

package/dist/index.d.ts

@@ -246,7 +246,7 @@ declare class OneRelation<T extends AnyTable = AnyTable> extends Relation<T> {
 declare class ManyRelation<T extends AnyTable = AnyTable> extends Relation<T> {
     constructor(foreignTable: T);
 }
-declare const relations: <T extends AnyTable, R extends Record<string, Relation>>(_table: T, relationsCallback: (helpers: RelationsBuilder) => R) => R;
+declare const relations: <T extends AnyTable, R extends Record<string, Relation>>(table: T, relationsCallback: (helpers: RelationsBuilder) => R) => R;
 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"]>;
 

package/dist/index.js

@@ -186,7 +186,10 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     this.table = table;
     this.columns = columns;
     this.selectedTableAlias = table._.name;
-    this.selectedColumns = columns ? columns.map((c) => `${this.selectedTableAlias}.${table._.columns[c]._.name}`) : [`${this.selectedTableAlias}.*`];
+    const selected = columns ? columns.map((c) => this.table._.columns[c]) : Object.values(this.table._.columns);
+    this.selectedColumns = selected.map(
+      (col) => `${this.selectedTableAlias}.${col._.name} AS "${this.selectedTableAlias}.${col._.name}"`
+    );
     this.query = `FROM ${table._.name} ${this.selectedTableAlias}`;
   }
   isDistinct = false;
@@ -214,12 +217,18 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
   }
   leftJoin(table, condition, alias2) {
     this.joins.push({ type: "LEFT", table, condition, alias: alias2 });
-    this.selectedColumns.push(`${alias2}.*`);
+    const aliasedColumns = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} AS "${alias2}.${col._.name}"`
+    );
+    this.selectedColumns.push(...aliasedColumns);
     return this;
   }
   innerJoin(table, condition, alias2) {
     this.joins.push({ type: "INNER", table, condition, alias: alias2 });
-    this.selectedColumns.push(`${alias2}.*`);
+    const aliasedColumns = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} AS "${alias2}.${col._.name}"`
+    );
+    this.selectedColumns.push(...aliasedColumns);
     return this;
   }
   include(relations2) {
@@ -244,7 +253,10 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
       }
       const foreignTable = relation.foreignTable;
       const foreignAlias = `${this.selectedTableAlias}_${relationName}`;
-      this.selectedColumns.push(`${foreignAlias}.*`);
+      const aliasedColumns = Object.values(foreignTable._.columns).map(
+        (col) => `${foreignAlias}.${col._.name} AS "${foreignAlias}.${col._.name}"`
+      );
+      this.selectedColumns.push(...aliasedColumns);
       if (relation.type === "one" && relation.fields && relation.references) {
         const conditions = relation.fields.map((field, i) => {
           const localColumn = `${this.selectedTableAlias}.${field._.name}`;
@@ -289,16 +301,40 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const { sql: sql2, params } = this.build();
     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;
+    const hasIncludes = Object.values(this.includeRelations).some((i) => i);
+    if (hasIncludes) {
+      return this.processRelationResults(rawResults);
     }
-    return rawResults;
+    const hasJoins = this.joins.length > 0;
+    if (hasJoins) {
+      return rawResults;
+    }
+    const prefix = `${this.selectedTableAlias}.`;
+    return rawResults.map((row) => {
+      const newRow = {};
+      for (const key in row) {
+        if (key.startsWith(prefix)) {
+          newRow[key.substring(prefix.length)] = row[key];
+        } else {
+          newRow[key] = row[key];
+        }
+      }
+      return newRow;
+    });
   }
   processRelationResults(rawResults) {
-    if (!rawResults.length) return rawResults;
-    return rawResults.map((row) => {
-      const result = {};
+    if (!rawResults.length) return [];
+    const mainTablePks = Object.values(this.table._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+    if (mainTablePks.length === 0) {
+      return rawResults;
+    }
+    const groupedResults = /* @__PURE__ */ new Map();
+    for (const row of rawResults) {
+      const mainTableKey = mainTablePks.map((pk) => row[`${this.selectedTableAlias}.${pk}`] ?? row[pk]).join("_");
+      if (!groupedResults.has(mainTableKey)) {
+        groupedResults.set(mainTableKey, {});
+      }
+      const result = groupedResults.get(mainTableKey);
       const relations2 = {};
       for (const [key, value] of Object.entries(row)) {
         if (key.includes(".")) {
@@ -321,15 +357,25 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
         }
       }
       for (const [relName, relData] of Object.entries(relations2)) {
+        const relationConfig = this.table.relations[relName];
+        if (!relationConfig) continue;
         const hasData = Object.values(relData).some(
           (v) => v !== null && v !== void 0 && v !== ""
         );
-        if (hasData) {
+        if (!hasData) continue;
+        if (relationConfig.type === "many") {
+          if (!result[relName]) result[relName] = [];
+          const relatedPks = Object.values(relationConfig.foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+          const relDataKey = relatedPks.map((pk) => relData[pk]).join("_");
+          if (relatedPks.length === 0 || !result[relName].some((r) => relatedPks.map((pk) => r[pk]).join("_") === relDataKey)) {
+            result[relName].push(relData);
+          }
+        } else {
           result[relName] = relData;
         }
       }
-      return result;
-    });
+    }
+    return Array.from(groupedResults.values());
   }
   // Update the return type signatures
   async all() {
@@ -719,29 +765,6 @@ var TauriORM = class {
           this.tables.set(value._.name, value);
         }
       }
-      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);
-          if (table) {
-            for (const [relName, rel] of Object.entries(value)) {
-              if (rel instanceof OneRelation) {
-                table.relations[relName] = {
-                  type: "one",
-                  foreignTable: rel.foreignTable,
-                  fields: rel.config?.fields,
-                  references: rel.config?.references
-                };
-              } else if (rel instanceof ManyRelation) {
-                table.relations[relName] = {
-                  type: "many",
-                  foreignTable: rel.foreignTable
-                };
-              }
-            }
-          }
-        }
-      }
     }
   }
   tables = /* @__PURE__ */ new Map();
@@ -920,15 +943,31 @@ var ManyRelation = class extends Relation {
     super(foreignTable);
   }
 };
-var relations = (_table, relationsCallback) => {
-  return relationsCallback({
-    one: (table, config) => {
-      return new OneRelation(table, config);
+var relations = (table, relationsCallback) => {
+  const builtRelations = relationsCallback({
+    one: (foreignTable, config) => {
+      return new OneRelation(foreignTable, config);
     },
-    many: (table) => {
-      return new ManyRelation(table);
+    many: (foreignTable) => {
+      return new ManyRelation(foreignTable);
     }
   });
+  for (const [name, relation] of Object.entries(builtRelations)) {
+    if (relation instanceof OneRelation) {
+      table.relations[name] = {
+        type: "one",
+        foreignTable: relation.foreignTable,
+        fields: relation.config?.fields,
+        references: relation.config?.references
+      };
+    } else if (relation instanceof ManyRelation) {
+      table.relations[name] = {
+        type: "many",
+        foreignTable: relation.foreignTable
+      };
+    }
+  }
+  return builtRelations;
 };
 var getTableColumns = (table) => {
   return table._.columns;

package/dist/index.mjs

@@ -119,7 +119,10 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     this.table = table;
     this.columns = columns;
     this.selectedTableAlias = table._.name;
-    this.selectedColumns = columns ? columns.map((c) => `${this.selectedTableAlias}.${table._.columns[c]._.name}`) : [`${this.selectedTableAlias}.*`];
+    const selected = columns ? columns.map((c) => this.table._.columns[c]) : Object.values(this.table._.columns);
+    this.selectedColumns = selected.map(
+      (col) => `${this.selectedTableAlias}.${col._.name} AS "${this.selectedTableAlias}.${col._.name}"`
+    );
     this.query = `FROM ${table._.name} ${this.selectedTableAlias}`;
   }
   isDistinct = false;
@@ -147,12 +150,18 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
   }
   leftJoin(table, condition, alias2) {
     this.joins.push({ type: "LEFT", table, condition, alias: alias2 });
-    this.selectedColumns.push(`${alias2}.*`);
+    const aliasedColumns = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} AS "${alias2}.${col._.name}"`
+    );
+    this.selectedColumns.push(...aliasedColumns);
     return this;
   }
   innerJoin(table, condition, alias2) {
     this.joins.push({ type: "INNER", table, condition, alias: alias2 });
-    this.selectedColumns.push(`${alias2}.*`);
+    const aliasedColumns = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} AS "${alias2}.${col._.name}"`
+    );
+    this.selectedColumns.push(...aliasedColumns);
     return this;
   }
   include(relations2) {
@@ -177,7 +186,10 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
       }
       const foreignTable = relation.foreignTable;
       const foreignAlias = `${this.selectedTableAlias}_${relationName}`;
-      this.selectedColumns.push(`${foreignAlias}.*`);
+      const aliasedColumns = Object.values(foreignTable._.columns).map(
+        (col) => `${foreignAlias}.${col._.name} AS "${foreignAlias}.${col._.name}"`
+      );
+      this.selectedColumns.push(...aliasedColumns);
       if (relation.type === "one" && relation.fields && relation.references) {
         const conditions = relation.fields.map((field, i) => {
           const localColumn = `${this.selectedTableAlias}.${field._.name}`;
@@ -222,16 +234,40 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const { sql: sql2, params } = this.build();
     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;
+    const hasIncludes = Object.values(this.includeRelations).some((i) => i);
+    if (hasIncludes) {
+      return this.processRelationResults(rawResults);
     }
-    return rawResults;
+    const hasJoins = this.joins.length > 0;
+    if (hasJoins) {
+      return rawResults;
+    }
+    const prefix = `${this.selectedTableAlias}.`;
+    return rawResults.map((row) => {
+      const newRow = {};
+      for (const key in row) {
+        if (key.startsWith(prefix)) {
+          newRow[key.substring(prefix.length)] = row[key];
+        } else {
+          newRow[key] = row[key];
+        }
+      }
+      return newRow;
+    });
   }
   processRelationResults(rawResults) {
-    if (!rawResults.length) return rawResults;
-    return rawResults.map((row) => {
-      const result = {};
+    if (!rawResults.length) return [];
+    const mainTablePks = Object.values(this.table._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+    if (mainTablePks.length === 0) {
+      return rawResults;
+    }
+    const groupedResults = /* @__PURE__ */ new Map();
+    for (const row of rawResults) {
+      const mainTableKey = mainTablePks.map((pk) => row[`${this.selectedTableAlias}.${pk}`] ?? row[pk]).join("_");
+      if (!groupedResults.has(mainTableKey)) {
+        groupedResults.set(mainTableKey, {});
+      }
+      const result = groupedResults.get(mainTableKey);
       const relations2 = {};
       for (const [key, value] of Object.entries(row)) {
         if (key.includes(".")) {
@@ -254,15 +290,25 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
         }
       }
       for (const [relName, relData] of Object.entries(relations2)) {
+        const relationConfig = this.table.relations[relName];
+        if (!relationConfig) continue;
         const hasData = Object.values(relData).some(
           (v) => v !== null && v !== void 0 && v !== ""
         );
-        if (hasData) {
+        if (!hasData) continue;
+        if (relationConfig.type === "many") {
+          if (!result[relName]) result[relName] = [];
+          const relatedPks = Object.values(relationConfig.foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+          const relDataKey = relatedPks.map((pk) => relData[pk]).join("_");
+          if (relatedPks.length === 0 || !result[relName].some((r) => relatedPks.map((pk) => r[pk]).join("_") === relDataKey)) {
+            result[relName].push(relData);
+          }
+        } else {
           result[relName] = relData;
         }
       }
-      return result;
-    });
+    }
+    return Array.from(groupedResults.values());
   }
   // Update the return type signatures
   async all() {
@@ -652,29 +698,6 @@ var TauriORM = class {
           this.tables.set(value._.name, value);
         }
       }
-      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);
-          if (table) {
-            for (const [relName, rel] of Object.entries(value)) {
-              if (rel instanceof OneRelation) {
-                table.relations[relName] = {
-                  type: "one",
-                  foreignTable: rel.foreignTable,
-                  fields: rel.config?.fields,
-                  references: rel.config?.references
-                };
-              } else if (rel instanceof ManyRelation) {
-                table.relations[relName] = {
-                  type: "many",
-                  foreignTable: rel.foreignTable
-                };
-              }
-            }
-          }
-        }
-      }
     }
   }
   tables = /* @__PURE__ */ new Map();
@@ -853,15 +876,31 @@ var ManyRelation = class extends Relation {
     super(foreignTable);
   }
 };
-var relations = (_table, relationsCallback) => {
-  return relationsCallback({
-    one: (table, config) => {
-      return new OneRelation(table, config);
+var relations = (table, relationsCallback) => {
+  const builtRelations = relationsCallback({
+    one: (foreignTable, config) => {
+      return new OneRelation(foreignTable, config);
     },
-    many: (table) => {
-      return new ManyRelation(table);
+    many: (foreignTable) => {
+      return new ManyRelation(foreignTable);
     }
   });
+  for (const [name, relation] of Object.entries(builtRelations)) {
+    if (relation instanceof OneRelation) {
+      table.relations[name] = {
+        type: "one",
+        foreignTable: relation.foreignTable,
+        fields: relation.config?.fields,
+        references: relation.config?.references
+      };
+    } else if (relation instanceof ManyRelation) {
+      table.relations[name] = {
+        type: "many",
+        foreignTable: relation.foreignTable
+      };
+    }
+  }
+  return builtRelations;
 };
 var getTableColumns = (table) => {
   return table._.columns;

package/package.json

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