forge-sql-orm 2.0.10 → 2.0.12

package/README.md

@@ -24,7 +24,7 @@ import { drizzle } from "drizzle-orm/mysql-proxy";
 import { forgeDriver } from "forge-sql-orm";
 const db = drizzle(forgeDriver);
 ```
-Best for: Simple CRUD operations without optimistic locking. Note that you need to manually set `mapSelectFieldsWithAlias` for select fields to prevent field name collisions in Atlassian Forge SQL.
+Best for: Simple CRUD operations without optimistic locking. Note that you need to manually patch drizzle `patchDbWithSelectAliased` for select fields to prevent field name collisions in Atlassian Forge SQL.
 
 ### 2. Full Forge-SQL-ORM Usage
 ```typescript
@@ -55,13 +55,13 @@ await forgeSQL
 ### Using Direct Drizzle
 ```typescript
 import { drizzle } from "drizzle-orm/mysql-proxy";
-import { forgeDriver, mapSelectFieldsWithAlias } from "forge-sql-orm";
+import { forgeDriver, patchDbWithSelectAliased } from "forge-sql-orm";
 
-const db = drizzle(forgeDriver);
+const db = patchDbWithSelectAliased(drizzle(forgeDriver));
 
 // Manual field name collision prevention
 await db
-  .select(mapSelectFieldsWithAlias({user: users, order: orders}))
+  .selectAliased({user: users, order: orders})
   .from(orders)
   .innerJoin(users, eq(orders.userId, users.id));
 ```
@@ -96,10 +96,10 @@ If you prefer to use Drizzle ORM directly without the additional features of For
 
 ```typescript
 import { drizzle } from "drizzle-orm/mysql-proxy";
-import { forgeDriver } from "forge-sql-orm";
+import { forgeDriver, patchDbWithSelectAliased } from "forge-sql-orm";
 
-// Initialize drizzle with the custom driver
-const db = drizzle(forgeDriver);
+// Initialize drizzle with the custom driver and patch it for aliased selects
+const db = patchDbWithSelectAliased(drizzle(forgeDriver));
 
 // Use drizzle directly
 const users = await db.select().from(users);
@@ -379,7 +379,6 @@ const result = await db
 
 ### Complex Queries
 ```js
-
 // Using joins with automatic field name collision prevention
 // With forgeSQL
 const orderWithUser = await forgeSQL
@@ -388,9 +387,9 @@ const orderWithUser = await forgeSQL
   .innerJoin(users, eq(orders.userId, users.id));
 
 // OR with direct drizzle
-const db = drizzle(forgeDriver);
+const db = patchDbWithSelectAliased(drizzle(forgeDriver));
 const orderWithUser = await db
-  .select(mapSelectFieldsWithAlias({user: users, order: orders}))
+  .selectAliased({user: users, order: orders})
   .from(orders)
   .innerJoin(users, eq(orders.userId, users.id));
 // Returns: { 
@@ -400,33 +399,11 @@ const orderWithUser = await db
 //   order_product: "Product 1"
 // }
 
-// Using distinct select with automatic field name collision prevention
-const uniqueOrdersWithUsers = await forgeSQL
-  .selectDistinct({user: users, order: orders})
-  .from(orders)
-  .innerJoin(users, eq(orders.userId, users.id));
-
-// Finding duplicates
-// With forgeSQL
-const duplicates = await forgeSQL
-  .getDrizzleQueryBuilder()
-  .select({
-    name: Users.name,
-    count: sql<number>`COUNT(*) as \`count\``
-  }).from(Users)
-  .groupBy(Users.name)
-  .having(sql`COUNT(*) > 1`);
-
-// OR with direct drizzle
-const db = drizzle(forgeDriver);
-const duplicates = await db
-  .select({
-    name: Users.name,
-    count: sql<number>`COUNT(*) as \`count\``
-  }).from(Users)
-  .groupBy(Users.name)
-  .having(sql`COUNT(*) > 1`);
-// Returns: { name: "John Doe", count: 2 }
+// Using distinct with aliases
+const uniqueUsers = await db
+  .selectAliasedDistinct({user: users})
+  .from(users);
+// Returns unique users with aliased fields
 
 // Using executeQueryOnlyOne for unique results
 const userStats = await forgeSQL

package/dist/ForgeSQLORM.js

@@ -131,32 +131,36 @@ function generateDropTableStatements(tables) {
   dropStatements.push(`DELETE FROM __migrations;`);
   return dropStatements;
 }
-function mapSelectTableToAlias(table2) {
+function mapSelectTableToAlias(table2, aliasMap) {
   const { columns, tableName } = getTableMetadata(table2);
   const selectionsTableFields = {};
   Object.keys(columns).forEach((name) => {
     const column = columns[name];
-    const fieldAlias = drizzleOrm.sql.raw(`${tableName}_${column.name}`);
+    const uniqName = `a_${tableName}_${column.name}`;
+    const fieldAlias = drizzleOrm.sql.raw(uniqName);
     selectionsTableFields[name] = drizzleOrm.sql`${column} as \`${fieldAlias}\``;
+    aliasMap[uniqName] = column;
   });
   return selectionsTableFields;
 }
 function isDrizzleColumn(column) {
   return column && typeof column === "object" && "table" in column;
 }
-function mapSelectAllFieldsToAlias(selections, name, fields) {
+function mapSelectAllFieldsToAlias(selections, name, fields, aliasMap) {
   if (drizzleOrm.isTable(fields)) {
-    selections[name] = mapSelectTableToAlias(fields);
+    selections[name] = mapSelectTableToAlias(fields, aliasMap);
   } else if (isDrizzleColumn(fields)) {
     const column = fields;
-    let aliasName = drizzleOrm.sql.raw(`${table.getTableName(column.table)}_${column.name}`);
+    const uniqName = `a_${table.getTableName(column.table)}_${column.name}`;
+    let aliasName = drizzleOrm.sql.raw(uniqName);
     selections[name] = drizzleOrm.sql`${column} as \`${aliasName}\``;
+    aliasMap[uniqName] = column;
   } else if (sql.isSQLWrapper(fields)) {
     selections[name] = fields;
   } else {
     const innerSelections = {};
     Object.entries(fields).forEach(([iname, ifields]) => {
-      mapSelectAllFieldsToAlias(innerSelections, iname, ifields);
+      mapSelectAllFieldsToAlias(innerSelections, iname, ifields, aliasMap);
     });
     selections[name] = innerSelections;
   }
@@ -166,11 +170,65 @@ function mapSelectFieldsWithAlias(fields) {
   if (!fields) {
     throw new Error("fields is empty");
   }
+  const aliasMap = {};
   const selections = {};
   Object.entries(fields).forEach(([name, fields2]) => {
-    mapSelectAllFieldsToAlias(selections, name, fields2);
+    mapSelectAllFieldsToAlias(selections, name, fields2, aliasMap);
+  });
+  return { selections, aliasMap };
+}
+function getAliasFromDrizzleAlias(value) {
+  const isSQL = value !== null && typeof value === "object" && sql.isSQLWrapper(value) && "queryChunks" in value;
+  if (isSQL) {
+    const sql2 = value;
+    const queryChunks = sql2.queryChunks;
+    if (queryChunks.length > 3) {
+      const aliasNameChunk = queryChunks[queryChunks.length - 2];
+      if (sql.isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
+        const aliasNameChunkSql = aliasNameChunk;
+        if (aliasNameChunkSql && aliasNameChunkSql.queryChunks.length === 1) {
+          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
+          if (queryChunksStringChunc && "value" in queryChunksStringChunc) {
+            const values = queryChunksStringChunc.value;
+            if (values && values.length === 1) {
+              return values[0];
+            }
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function transformValue(value, alias, aliasMap) {
+  const column = aliasMap[alias];
+  if (!column) return value;
+  let customColumn = column;
+  const fromDriver = customColumn?.mapFrom;
+  if (fromDriver && value !== null && value !== void 0) {
+    return fromDriver(value);
+  }
+  return value;
+}
+function transformObject(obj, selections, aliasMap) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const selection = selections[key];
+    const alias = getAliasFromDrizzleAlias(selection);
+    if (alias && aliasMap[alias]) {
+      result[key] = transformValue(value, alias, aliasMap);
+    } else if (selection && typeof selection === "object" && !sql.isSQLWrapper(selection)) {
+      result[key] = transformObject(value, selection, aliasMap);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function applyFromDriverTransform(rows, selections, aliasMap) {
+  return rows.map((row) => {
+    return transformObject(row, selections, aliasMap);
   });
-  return selections;
 }
 class ForgeSQLCrudOperations {
   forgeOperations;
@@ -549,6 +607,52 @@ const forgeDriver = async (query, params, method) => {
     throw error;
   }
 };
+function createAliasedSelectBuilder(db, fields, selectFn) {
+  const { selections, aliasMap } = mapSelectFieldsWithAlias(fields);
+  const builder = selectFn(selections);
+  const wrapBuilder = (rawBuilder) => {
+    return new Proxy(rawBuilder, {
+      get(target, prop, receiver) {
+        if (prop === "execute") {
+          return async (...args) => {
+            const rows = await target.execute(...args);
+            return applyFromDriverTransform(rows, selections, aliasMap);
+          };
+        }
+        if (prop === "then") {
+          return (onfulfilled, onrejected) => target.execute().then(
+            (rows) => {
+              const transformed = applyFromDriverTransform(rows, selections, aliasMap);
+              return onfulfilled?.(transformed);
+            },
+            onrejected
+          );
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return (...args) => {
+            const result = value.apply(target, args);
+            if (typeof result === "object" && result !== null && "execute" in result) {
+              return wrapBuilder(result);
+            }
+            return result;
+          };
+        }
+        return value;
+      }
+    });
+  };
+  return wrapBuilder(builder);
+}
+function patchDbWithSelectAliased(db) {
+  db.selectAliased = function(fields) {
+    return createAliasedSelectBuilder(db, fields, (selections) => db.select(selections));
+  };
+  db.selectAliasedDistinct = function(fields) {
+    return createAliasedSelectBuilder(db, fields, (selections) => db.selectDistinct(selections));
+  };
+  return db;
+}
 class ForgeSQLORMImpl {
   static instance = null;
   drizzle;
@@ -567,7 +671,7 @@ class ForgeSQLORMImpl {
       if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.drizzle = mysqlProxy.drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
+      this.drizzle = patchDbWithSelectAliased(mysqlProxy.drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery }));
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -632,7 +736,7 @@ class ForgeSQLORMImpl {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.select(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliased(fields);
   }
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -654,7 +758,7 @@ class ForgeSQLORMImpl {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliasedDistinct(fields);
   }
 }
 class ForgeSQLORM {
@@ -679,7 +783,7 @@ class ForgeSQLORM {
    * ```
    */
   select(fields) {
-    return this.ormInstance.getDrizzleQueryBuilder().select(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.select(fields);
   }
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -698,7 +802,7 @@ class ForgeSQLORM {
    * ```
    */
   selectDistinct(fields) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.selectDistinct(fields);
   }
   /**
    * Proxies the `crud` method from `ForgeSQLORMImpl`.
@@ -862,6 +966,7 @@ const getHttpResponse = (statusCode, body) => {
 };
 exports.ForgeSQLCrudOperations = ForgeSQLCrudOperations;
 exports.ForgeSQLSelectOperations = ForgeSQLSelectOperations;
+exports.applyFromDriverTransform = applyFromDriverTransform;
 exports.applySchemaMigrations = applySchemaMigrations;
 exports.default = ForgeSQLORM;
 exports.dropSchemaMigrations = dropSchemaMigrations;
@@ -878,6 +983,6 @@ exports.getPrimaryKeys = getPrimaryKeys;
 exports.getTableMetadata = getTableMetadata;
 exports.mapSelectAllFieldsToAlias = mapSelectAllFieldsToAlias;
 exports.mapSelectFieldsWithAlias = mapSelectFieldsWithAlias;
-exports.mapSelectTableToAlias = mapSelectTableToAlias;
 exports.parseDateTime = parseDateTime;
+exports.patchDbWithSelectAliased = patchDbWithSelectAliased;
 //# sourceMappingURL=ForgeSQLORM.js.map