forge-sql-orm 1.1.31 → 2.0.1

package/src/core/ForgeSQLSelectOperations.ts

@@ -1,12 +1,9 @@
 import { sql, UpdateQueryResponse } from "@forge/sql";
-import { extractAlias, parseDateTime } from "../utils/sqlUtils";
 import { ForgeSqlOrmOptions, SchemaSqlForgeSql } from "./ForgeSQLQueryBuilder";
-import { AnyMySqlSelect } from "drizzle-orm/mysql-core";
 import {
   AnyMySqlSelectQueryBuilder,
   MySqlSelectDynamic,
 } from "drizzle-orm/mysql-core/query-builders/select.types";
-import { Column, SQL, SQLChunk, StringChunk } from "drizzle-orm";
 
 /**
  * Class implementing SQL select operations for ForgeSQL ORM.
@@ -23,134 +20,6 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
     this.options = options;
   }
 
-  /**
-   * Executes a Drizzle query and returns the results.
-   * Maps the raw database results to the appropriate entity types.
-   *
-   * @template T - The type of the query builder
-   * @param {T} query - The Drizzle query to execute
-   * @returns {Promise<Awaited<T>>} The query results mapped to entity types
-   */
-  async executeQuery<T extends MySqlSelectDynamic<AnyMySqlSelectQueryBuilder>>(
-    query: T,
-  ): Promise<Awaited<T>> {
-    const queryType = <AnyMySqlSelect>query;
-    const querySql = queryType.toSQL();
-    const datas = await this.executeRawSQL<unknown>(querySql.sql, querySql.params);
-
-    if (!datas.length) return [] as Awaited<T>;
-
-    return datas.map((r) => {
-      const rawModel = r as Record<string, unknown>;
-      const newModel: any = {};
-
-      // @ts-ignore - Drizzle internal property
-      const columns = queryType.config.fields;
-
-      Object.entries(columns).forEach(([name, column]: [string, any]) => {
-        const { realColumn, aliasName } = this.extractColumnInfo(column);
-        const value = rawModel[aliasName];
-
-        if (value === null || value === undefined) {
-          newModel[name] = value;
-          return;
-        }
-
-        newModel[name] = this.parseColumnValue(realColumn, value);
-      });
-
-      return newModel;
-    }) as Awaited<T>;
-  }
-
-  /**
-   * Extracts column information and alias name from a column definition.
-   * @param {any} column - The column definition from Drizzle
-   * @returns {Object} Object containing the real column and its alias name
-   */
-  private extractColumnInfo(column: any): { realColumn: Column; aliasName: string } {
-    if (column instanceof SQL) {
-      const realColumnSql = <SQL>column;
-      const realColumn = realColumnSql.queryChunks.find(
-        (q: SQLChunk) => q instanceof Column,
-      ) as Column;
-
-      let stringChunk = this.findAliasChunk(realColumnSql);
-      let withoutAlias = false;
-
-      if (!realColumn && (!stringChunk || !stringChunk.value || !stringChunk.value?.length)) {
-        stringChunk = realColumnSql.queryChunks
-          .filter((q: SQLChunk) => q instanceof StringChunk)
-          .find((q: SQLChunk) => (q as StringChunk).value[0]) as StringChunk;
-        withoutAlias = true;
-      }
-
-      const aliasName = this.resolveAliasName(stringChunk, realColumn, withoutAlias);
-
-      return { realColumn, aliasName };
-    }
-
-    return { realColumn: column, aliasName: column.name };
-  }
-
-  /**
-   * Finds the alias chunk in SQL query chunks.
-   * @param {SQL} realColumnSql - The SQL query chunks
-   * @returns {StringChunk | undefined} The string chunk containing the alias or undefined
-   */
-  private findAliasChunk(realColumnSql: SQL): StringChunk | undefined {
-    return realColumnSql.queryChunks
-      .filter((q: SQLChunk) => q instanceof StringChunk)
-      .find((q: SQLChunk) =>
-        (q as StringChunk).value.find((f) => f.toLowerCase().includes("as")),
-      ) as StringChunk;
-  }
-
-  /**
-   * Resolves the alias name from the string chunk or column.
-   * @param {StringChunk | undefined} stringChunk - The string chunk containing the alias
-   * @param {Column | undefined} realColumn - The real column definition
-   * @param {boolean} withoutAlias - Whether the column has no alias
-   * @returns {string} The resolved alias name
-   */
-  private resolveAliasName(
-    stringChunk: StringChunk | undefined,
-    realColumn: Column | undefined,
-    withoutAlias: boolean,
-  ): string {
-    if (stringChunk) {
-      if (withoutAlias) {
-        return stringChunk.value[0];
-      }
-      const asClause = stringChunk.value.find((f) => f.toLowerCase().includes("as"));
-      return asClause ? extractAlias(asClause.trim()) : realColumn?.name || "";
-    }
-    return realColumn?.name || "";
-  }
-
-  /**
-   * Parses a column value based on its SQL type.
-   * Handles datetime, date, and time types with appropriate formatting.
-   *
-   * @param {Column} column - The column definition
-   * @param {unknown} value - The raw value to parse
-   * @returns {unknown} The parsed value
-   */
-  private parseColumnValue(column: Column, value: unknown): unknown {
-    if (!column) return value;
-
-    switch (column.getSQLType()) {
-      case "datetime":
-        return parseDateTime(value as string, "YYYY-MM-DDTHH:mm:ss.SSS");
-      case "date":
-        return parseDateTime(value as string, "YYYY-MM-DD");
-      case "time":
-        return parseDateTime(value as string, "HH:mm:ss.SSS");
-      default:
-        return value;
-    }
-  }
-
   /**
    * Executes a Drizzle query and returns a single result.
    * Throws an error if more than one record is returned.
@@ -165,7 +34,7 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
   ): Promise<
     Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined
   > {
-    const results: Awaited<T> = await this.executeQuery<T>(query);
+    const results: Awaited<T> = await query;
     const datas = results as unknown[];
     if (!datas.length) {
       return undefined;
@@ -192,6 +61,9 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
     }
     const sqlStatement = sql.prepare<T>(query);
     if (params) {
+      if (this.options.logRawSqlQuery && this.options.logRawSqlQueryParams) {
+        console.debug("Executing with SQL Params: " + JSON.stringify(params));
+      }
       sqlStatement.bindParams(...params);
     }
     const result = await sqlStatement.execute();

package/src/index.ts

@@ -4,5 +4,6 @@ export * from "./core/ForgeSQLQueryBuilder";
 export * from "./core/ForgeSQLCrudOperations";
 export * from "./core/ForgeSQLSelectOperations";
 export * from "./utils/sqlUtils";
+export * from "./utils/forgeDriver";
 
 export default ForgeSQLORM;

package/src/utils/forgeDriver.ts

@@ -0,0 +1,37 @@
+import { sql } from "@forge/sql";
+import {AnyMySql2Connection} from "drizzle-orm/mysql2/driver";
+
+interface ForgeSQLResult {
+    rows: Record<string, unknown>[] | Record<string, unknown>;
+}
+
+export const forgeDriver = {
+    query: async (query: { sql: string }, params?: unknown[]) => {
+        try {
+            const sqlStatement = await sql.prepare<unknown>(query.sql);
+            if (params) {
+                await sqlStatement.bindParams(...params);
+            }
+            const result = await sqlStatement.execute() as ForgeSQLResult;
+
+            let rows;
+            if (Array.isArray(result.rows)) {
+                rows = [
+                    result.rows.map(r => Object.values(r as Record<string, unknown>))
+                ];
+            } else {
+                rows = [
+                    result.rows as Record<string, unknown>
+                ];
+            }
+
+            return rows;
+        } catch (error) {
+            console.error("SQL Error:", JSON.stringify(error));
+            throw error;
+        }
+    },
+    transaction: async (transactionFn: (tx: any) => Promise<void>) => {
+        // Implementation will be added later
+    },
+} as unknown as AnyMySql2Connection;

package/src/utils/sqlUtils.ts

@@ -2,7 +2,7 @@ import moment from "moment";
 import { AnyColumn } from "drizzle-orm";
 import { AnyMySqlTable } from "drizzle-orm/mysql-core/index";
 import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
-import { AnyIndexBuilder, IndexBuilder } from "drizzle-orm/mysql-core/indexes";
+import { AnyIndexBuilder } from "drizzle-orm/mysql-core/indexes";
 import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
 import { ForeignKeyBuilder } from "drizzle-orm/mysql-core/foreign-keys";
 import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
@@ -29,6 +29,14 @@ export interface MetadataInfo {
   extras: any[];
 }
 
+/**
+ * Interface for config builder data
+ */
+interface ConfigBuilderData {
+  value?: any;
+  [key: string]: any;
+}
+
 /**
  * Parses a date string into a Date object using the specified format
  * @param value - The date string to parse
@@ -57,11 +65,9 @@ export function extractAlias(query: string): string {
  * Gets primary keys from the schema.
  * @template T - The type of the table schema
  * @param {T} table - The table schema
- * @returns {[string, AnyColumn][] | undefined} Array of primary key name and column pairs or undefined if no primary keys found
+ * @returns {[string, AnyColumn][]} Array of primary key name and column pairs
  */
-export function getPrimaryKeys<T extends AnyMySqlTable>(
-  table: T,
-): [string, AnyColumn][] | undefined {
+export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyColumn][] {
   const { columns, primaryKeys } = getTableMetadata(table);
 
   // First try to find primary keys in columns
@@ -91,11 +97,10 @@ export function getPrimaryKeys<T extends AnyMySqlTable>(
         });
     });
 
-    const result = Array.from(primaryKeyColumns);
-    return result.length > 0 ? result : undefined;
+    return Array.from(primaryKeyColumns);
   }
 
-  return undefined;
+  return [];
 }
 
 /**
@@ -108,7 +113,6 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
   const nameSymbol = symbols.find((s) => s.toString().includes("Name"));
   const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));
   const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));
-  const foreignKeysSymbol = symbols.find((s) => s.toString().includes("MySqlInlineForeignKeys)"));
 
   // Initialize builders arrays
   const builders = {
@@ -119,42 +123,48 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
     uniqueConstraints: [] as UniqueConstraintBuilder[],
     extras: [] as any[],
   };
-  if (foreignKeysSymbol) {
-    // @ts-ignore
-    const foreignKeys: any[] = table[foreignKeysSymbol];
-    if (foreignKeys) {
-      for (const foreignKey of foreignKeys) {
-        builders.foreignKeys.push(foreignKey);
-      }
-    }
-  }
 
   // Process extra configuration if available
   if (extraSymbol) {
     // @ts-ignore
     const extraConfigBuilder = table[extraSymbol];
     if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
-      const configBuilders = extraConfigBuilder(table);
-      let configBuildersArray: any[] = [];
-      if (!Array.isArray(configBuilders)) {
-        configBuildersArray = Object.values(configBuilders);
-      } else {
-        configBuildersArray = configBuilders as any[];
+      const configBuilderData = extraConfigBuilder(table);
+      if (configBuilderData) {
+        // Convert configBuilderData to array if it's an object
+        const configBuilders = Array.isArray(configBuilderData)
+          ? configBuilderData
+          : Object.values(configBuilderData).map(
+              (item) => (item as ConfigBuilderData).value || item,
+            );
+
+        // Process each builder
+        configBuilders.forEach((builder) => {
+          if (!builder?.constructor) return;
+
+          const builderName = builder.constructor.name.toLowerCase();
+
+          // Map builder types to their corresponding arrays
+          const builderMap = {
+            indexbuilder: builders.indexes,
+            checkbuilder: builders.checks,
+            foreignkeybuilder: builders.foreignKeys,
+            primarykeybuilder: builders.primaryKeys,
+            uniqueconstraintbuilder: builders.uniqueConstraints,
+          };
+
+          // Add builder to appropriate array if it matches any type
+          for (const [type, array] of Object.entries(builderMap)) {
+            if (builderName.includes(type)) {
+              array.push(builder);
+              break;
+            }
+          }
+
+          // Always add to extras array
+          builders.extras.push(builder);
+        });
       }
-      configBuildersArray.forEach((builder) => {
-        if (builder instanceof IndexBuilder) {
-          builders.indexes.push(builder);
-        } else if (builder instanceof CheckBuilder) {
-          builders.checks.push(builder);
-        } else if (builder instanceof ForeignKeyBuilder) {
-          builders.foreignKeys.push(builder);
-        } else if (builder instanceof PrimaryKeyBuilder) {
-          builders.primaryKeys.push(builder);
-        } else if (builder instanceof UniqueConstraintBuilder) {
-          builders.uniqueConstraints.push(builder);
-        }
-        builders.extras.push(builder);
-      });
     }
   }