forge-sql-orm 2.0.10 → 2.0.12

package/src/core/ForgeSQLORM.ts

@@ -9,8 +9,8 @@ import { ForgeSQLSelectOperations } from "./ForgeSQLSelectOperations";
 import { drizzle, MySqlRemoteDatabase, MySqlRemotePreparedQueryHKT } from "drizzle-orm/mysql-proxy";
 import { forgeDriver } from "../utils/forgeDriver";
 import type { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
-import { mapSelectFieldsWithAlias } from "../utils/sqlUtils";
 import { MySqlSelectBuilder } from "drizzle-orm/mysql-core";
+import {patchDbWithSelectAliased} from "../lib/drizzle/extensions/selectAliased";
 
 /**
  * Implementation of ForgeSQLORM that uses Drizzle ORM for query building.
@@ -37,7 +37,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
         console.debug("Initializing ForgeSQLORM...");
       }
       // Initialize Drizzle instance with our custom driver
-      this.drizzle = drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
+      this.drizzle =  patchDbWithSelectAliased(drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery }));
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -109,7 +109,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.select(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliased(fields);
   }
 
   /**
@@ -134,7 +134,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliasedDistinct(fields);
   }
 }
 
@@ -168,7 +168,7 @@ class ForgeSQLORM implements ForgeSqlOperation {
   select<TSelection extends SelectedFields>(
     fields: TSelection,
   ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
-    return this.ormInstance.getDrizzleQueryBuilder().select(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.select(fields);
   }
 
   /**
@@ -191,8 +191,7 @@ class ForgeSQLORM implements ForgeSqlOperation {
     fields: TSelection,
   ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
     return this.ormInstance
-      .getDrizzleQueryBuilder()
-      .selectDistinct(mapSelectFieldsWithAlias(fields));
+      .selectDistinct(fields);
   }
 
   /**

package/src/index.ts

@@ -6,5 +6,6 @@ export * from "./core/ForgeSQLSelectOperations";
 export * from "./utils/sqlUtils";
 export * from "./utils/forgeDriver";
 export * from "./webtriggers";
+export * from "./lib/drizzle/extensions/selectAliased";
 
 export default ForgeSQLORM;

package/src/lib/drizzle/extensions/selectAliased.ts

@@ -0,0 +1,74 @@
+import {MySqlRemoteDatabase} from "drizzle-orm/mysql-proxy";
+import type {SelectedFields} from "drizzle-orm/mysql-core/query-builders/select.types";
+import {applyFromDriverTransform, mapSelectFieldsWithAlias} from "../../..";
+import {MySqlSelectBuilder} from "drizzle-orm/mysql-core";
+import {MySqlRemotePreparedQueryHKT} from "drizzle-orm/mysql-proxy";
+
+function createAliasedSelectBuilder<TSelection extends SelectedFields>(
+    db: MySqlRemoteDatabase<any>,
+    fields: TSelection,
+    selectFn: (selections: any) => MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>
+): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
+    const { selections, aliasMap } = mapSelectFieldsWithAlias(fields);
+    const builder = selectFn(selections);
+
+    const wrapBuilder = (rawBuilder: any): any => {
+        return new Proxy(rawBuilder, {
+            get(target, prop, receiver) {
+                if (prop === 'execute') {
+                    return async (...args: any[]) => {
+                        const rows = await target.execute(...args);
+                        return applyFromDriverTransform(rows, selections, aliasMap);
+                    };
+                }
+
+                if (prop === 'then') {
+                    return (onfulfilled: any, onrejected: any) =>
+                        target.execute().then(
+                            (rows: unknown[]) => {
+                                const transformed = applyFromDriverTransform(rows, selections, aliasMap);
+                                return onfulfilled?.(transformed);
+                            },
+                            onrejected,
+                        );
+                }
+
+                const value = Reflect.get(target, prop, receiver);
+
+                if (typeof value === 'function') {
+                    return (...args: any[]) => {
+                        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);
+}
+
+export function patchDbWithSelectAliased(db: MySqlRemoteDatabase<any>): MySqlRemoteDatabase<any> & {
+    selectAliased:<TSelection extends SelectedFields>(
+        fields: TSelection,
+    )=> MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>,
+    selectAliasedDistinct:<TSelection extends SelectedFields>(
+        fields: TSelection,
+    )=> MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>  } {
+    db.selectAliased = function <TSelection extends SelectedFields>(fields: TSelection) {
+        return createAliasedSelectBuilder(db, fields, (selections) => db.select(selections));
+    };
+
+    db.selectAliasedDistinct = function <TSelection extends SelectedFields>(fields: TSelection) {
+        return createAliasedSelectBuilder(db, fields, (selections) => db.selectDistinct(selections));
+    };
+
+    return db;
+}

package/src/lib/drizzle/extensions/types.d.ts

@@ -0,0 +1,14 @@
+import { SelectedFields } from 'drizzle-orm';
+import {MySqlSelectBuilder} from "drizzle-orm/mysql-core";
+import {MySqlRemotePreparedQueryHKT} from "drizzle-orm/mysql-proxy";
+
+declare module 'drizzle-orm/mysql-proxy' {
+    interface MySqlRemoteDatabase<> {
+        selectAliased<TSelection extends SelectedFields>(
+            fields: TSelection,
+        ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>;
+        selectAliasedDistinct<TSelection extends SelectedFields>(
+            fields: TSelection,
+        ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>;
+    }
+}

package/src/utils/sqlUtils.ts

@@ -1,6 +1,6 @@
 import moment from "moment";
-import { AnyColumn, Column, isTable, sql } from "drizzle-orm";
-import { AnyMySqlTable } from "drizzle-orm/mysql-core/index";
+import {AnyColumn, Column, isTable, SQL, sql, StringChunk} from "drizzle-orm";
+import {AnyMySqlTable, MySqlCustomColumn} from "drizzle-orm/mysql-core/index";
 import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
 import { AnyIndexBuilder } from "drizzle-orm/mysql-core/indexes";
 import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
@@ -9,7 +9,7 @@ import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constrain
 import type { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
 import { MySqlTable } from "drizzle-orm/mysql-core";
 import { getTableName } from "drizzle-orm/table";
-import { isSQLWrapper } from "drizzle-orm/sql/sql";
+import {isSQLWrapper} from "drizzle-orm/sql/sql";
 
 /**
  * Interface representing table metadata information
@@ -48,11 +48,11 @@ interface ConfigBuilderData {
  * @returns Date object
  */
 export const parseDateTime = (value: string, format: string): Date => {
-  const m = moment(value, format, true);
-  if (!m.isValid()) {
-    return moment(value).toDate();
-  }
-  return m.toDate();
+    const m = moment(value, format, true);
+    if (!m.isValid()) {
+        return moment(value).toDate();
+    }
+    return m.toDate();
 };
 
 /**
@@ -61,8 +61,8 @@ export const parseDateTime = (value: string, format: string): Date => {
  * @returns The extracted alias or the original query if no alias found
  */
 export function extractAlias(query: string): string {
-  const match = query.match(/\bas\s+(['"`]?)([\w*]+)\1$/i);
-  return match ? match[2] : query;
+    const match = query.match(/\bas\s+(['"`]?)([\w*]+)\1$/i);
+    return match ? match[2] : query;
 }
 
 /**
@@ -189,8 +189,8 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
   builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);
 
   // Process extra configuration if available
-  if (extraSymbol) {
-    // @ts-ignore
+    if (extraSymbol) {
+        // @ts-ignore
     const extraConfigBuilder = table[extraSymbol];
     if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
       const configBuilderData = extraConfigBuilder(table);
@@ -231,7 +231,7 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
     }
   }
 
-  return {
+    return {
     tableName: nameSymbol ? (table as any)[nameSymbol] : "",
     columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},
     ...builders,
@@ -259,13 +259,17 @@ export function generateDropTableStatements(tables: AnyMySqlTable[]): string[] {
   return dropStatements;
 }
 
-export function mapSelectTableToAlias(table: MySqlTable): any {
+type AliasColumnMap = Record<string, AnyColumn>;
+
+function mapSelectTableToAlias(table: MySqlTable, aliasMap: AliasColumnMap): any {
   const { columns, tableName } = getTableMetadata(table);
   const selectionsTableFields: Record<string, unknown> = {};
   Object.keys(columns).forEach((name) => {
     const column = columns[name] as AnyColumn;
-    const fieldAlias = sql.raw(`${tableName}_${column.name}`);
+    const uniqName = `a_${tableName}_${column.name}`;
+    const fieldAlias = sql.raw(uniqName);
     selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;
+    aliasMap[uniqName]= column;
   });
   return selectionsTableFields;
 }
@@ -274,19 +278,21 @@ function isDrizzleColumn(column: any): boolean {
   return column && typeof column === "object" && "table" in column;
 }
 
-export function mapSelectAllFieldsToAlias(selections: any, name: string, fields: any): any {
+export function mapSelectAllFieldsToAlias(selections: any, name: string, fields: any, aliasMap: AliasColumnMap): any {
   if (isTable(fields)) {
-    selections[name] = mapSelectTableToAlias(fields as MySqlTable);
+    selections[name] = mapSelectTableToAlias(fields as MySqlTable, aliasMap);
   } else if (isDrizzleColumn(fields)) {
     const column = fields as Column;
-    let aliasName = sql.raw(`${getTableName(column.table)}_${column.name}`);
+    const uniqName = `a_${getTableName(column.table)}_${column.name}`;
+    let aliasName = sql.raw(uniqName);
     selections[name] = sql`${column} as \`${aliasName}\``;
+    aliasMap[uniqName] = column;
   } else if (isSQLWrapper(fields)) {
     selections[name] = fields;
   } else {
     const innerSelections: any = {};
     Object.entries(fields).forEach(([iname, ifields]) => {
-      mapSelectAllFieldsToAlias(innerSelections, iname, ifields);
+      mapSelectAllFieldsToAlias(innerSelections, iname, ifields, aliasMap);
     });
     selections[name] = innerSelections;
   }
@@ -294,13 +300,83 @@ export function mapSelectAllFieldsToAlias(selections: any, name: string, fields:
 }
 export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(
   fields: TSelection,
-): TSelection {
+): { selections: TSelection; aliasMap: AliasColumnMap } {
   if (!fields) {
     throw new Error("fields is empty");
   }
+  const aliasMap: AliasColumnMap = {};
   const selections: any = {};
   Object.entries(fields).forEach(([name, fields]) => {
-    mapSelectAllFieldsToAlias(selections, name, fields);
+    mapSelectAllFieldsToAlias(selections, name, fields, aliasMap);
+  });
+  return {selections, aliasMap};
+}
+
+
+
+function getAliasFromDrizzleAlias(value: unknown): string|undefined {
+  const isSQL = value !== null &&
+      typeof value === 'object' &&
+      isSQLWrapper(value) && 'queryChunks' in value;
+  if (isSQL){
+    const  sql = value as SQL;
+    const queryChunks = sql.queryChunks;
+    if (queryChunks.length>3){
+      const aliasNameChunk = queryChunks[queryChunks.length-2];
+      if (isSQLWrapper(aliasNameChunk) && 'queryChunks' in aliasNameChunk){
+        const  aliasNameChunkSql = aliasNameChunk as SQL;
+        if (aliasNameChunkSql && aliasNameChunkSql.queryChunks.length === 1) {
+          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
+          if (queryChunksStringChunc && 'value' in queryChunksStringChunc) {
+            const values = (queryChunksStringChunc as StringChunk).value;
+            if (values && values.length===1){
+              return values[0]
+            }
+          }
+        }
+      }
+    }
+  }
+  return undefined
+}
+
+function transformValue(value: unknown, alias: string, aliasMap: Record<string, AnyColumn>): unknown {
+  const column = aliasMap[alias];
+  if (!column) return value;
+
+  let customColumn = column as MySqlCustomColumn<any>;
+  // @ts-ignore
+  const fromDriver = customColumn?.mapFrom;
+  if (fromDriver && value !== null && value !== undefined) {
+    return fromDriver(value);
+  }
+  return value;
+}
+
+function transformObject(obj: Record<string, unknown>, selections: Record<string, unknown>, aliasMap: Record<string, AnyColumn>): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  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' && !isSQLWrapper(selection)) {
+      result[key] = transformObject(value as Record<string, unknown>, selection as Record<string, unknown>, aliasMap);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+export function applyFromDriverTransform<T, TSelection>(
+  rows: T[],
+  selections: TSelection,
+  aliasMap: Record<string, AnyColumn>
+): T[] {
+  return rows.map((row) => {
+    return transformObject(row as Record<string, unknown>, selections as Record<string, unknown>, aliasMap) as T;
   });
-  return selections;
 }