forge-sql-orm 2.0.0 → 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;

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;