forge-sql-orm 1.1.31 → 2.0.1

package/README.md

@@ -5,6 +5,7 @@
 **Forge-SQL-ORM** is an ORM designed for working with [@forge/sql](https://developer.atlassian.com/platform/forge/storage-reference/sql-tutorial/) in **Atlassian Forge**. It is built on top of [Drizzle ORM](https://orm.drizzle.team) and provides advanced capabilities for working with relational databases inside Forge.
 
 ## Key Features
+- ✅ **Custom Drizzle Driver** for direct integration with @forge/sql
 - ✅ **Supports complex SQL queries** with joins and filtering using Drizzle ORM
 - ✅ **Batch insert support** with duplicate key handling
 - ✅ **Schema migration support**, allowing automatic schema evolution
@@ -14,6 +15,23 @@
 - ✅ **Optimistic Locking** Ensures data consistency by preventing conflicts when multiple users update the same record
 - ✅ **Type Safety** Full TypeScript support with proper type inference
 
+## Usage Approaches
+
+### 1. Direct Drizzle Usage
+```typescript
+import { drizzle } from "drizzle-orm/mysql-core";
+import { forgeDriver } from "forge-sql-orm";
+const db = drizzle(forgeDriver);
+```
+Best for: Simple CRUD operations without optimistic locking
+
+### 2. Full Forge-SQL-ORM Usage
+```typescript
+import ForgeSQL from "forge-sql-orm";
+const forgeSQL = new ForgeSQL();
+```
+Best for: Advanced features like optimistic locking and automatic versioning
+
 ## Installation
 
 Forge-SQL-ORM is designed to work with @forge/sql and requires some additional setup to ensure compatibility within Atlassian Forge.
@@ -22,8 +40,7 @@ Forge-SQL-ORM is designed to work with @forge/sql and requires some additional s
 
 ```sh
 npm install forge-sql-orm -S
-npm install @forge/sql -S
-npm install drizzle-orm mysql2
+npm install @forge/sql drizzle-orm -S
 npm install mysql2 @types/mysql2 -D
 ```
 
@@ -33,6 +50,38 @@ This will:
 - Install Drizzle ORM and its MySQL driver
 - Install TypeScript types for MySQL
 
+## Direct Drizzle Usage with Custom Driver
+
+If you prefer to use Drizzle ORM directly without the additional features of Forge-SQL-ORM (like optimistic locking), you can use the custom driver:
+
+```typescript
+import { drizzle } from "drizzle-orm/mysql-core";
+import { forgeDriver } from "forge-sql-orm";
+
+// Initialize drizzle with the custom driver
+const db = drizzle(forgeDriver);
+
+// Use drizzle directly
+const users = await db.select().from(users);
+```
+
+##  Drizzle Usage with forge-sql-orm
+
+If you prefer to use Drizzle ORM  with the additional features of Forge-SQL-ORM (like optimistic locking), you can use the custom driver:
+
+```typescript
+import ForgeSQL from "forge-sql-orm";
+const forgeSQL = new ForgeSQL();
+forgeSQL.crud().insert(...);
+forgeSQL.crud().updateById(...);
+const db = forgeSQL.getDrizzleQueryBuilder();
+
+// Use drizzle
+const users = await db.select().from(users);
+```
+
+This approach gives you direct access to all Drizzle ORM features while still using the @forge/sql backend.
+
 ## Step-by-Step Migration Workflow
 
 1. **Generate initial schema from an existing database**
@@ -155,6 +204,68 @@ export default (migrationRunner: MigrationRunner): MigrationRunner => {
 
 ---
 
+## Date and Time Types
+
+When working with date and time fields in your models, you should use the custom types provided by Forge-SQL-ORM to ensure proper handling of date/time values. This is necessary because Forge SQL has specific format requirements for date/time values:
+
+| Date type | Required Format | Example |
+|-----------|----------------|---------|
+| DATE | YYYY-MM-DD | 2024-09-19 |
+| TIME | HH:MM:SS[.fraction] | 06:40:34 |
+| TIMESTAMP | YYYY-MM-DD HH:MM:SS[.fraction] | 2024-09-19 06:40:34.999999 |
+
+```typescript
+// ❌ Don't use standard Drizzle date/time types
+export const testEntityTimeStampVersion = mysqlTable('test_entity', {
+  id: int('id').primaryKey().autoincrement(),
+  time_stamp: timestamp('times_tamp').notNull(),
+  date_time: datetime('date_time').notNull(),
+  time: time('time').notNull(),
+  date: date('date').notNull(),
+});
+
+// ✅ Use Forge-SQL-ORM custom types instead
+import { forgeDateTimeString, forgeDateString, mySqlTimestampString, mySqlTimeString } from 'forge-sql-orm'
+
+export const testEntityTimeStampVersion = mysqlTable('test_entity', {
+  id: int('id').primaryKey().autoincrement(),
+  time_stamp: forgeTimestampString('times_tamp').notNull(),
+  date_time: forgeDateTimeString('date_time').notNull(),
+  time: forgeTimeString('time').notNull(),
+  date: forgeDateString('date').notNull(),
+});
+```
+
+### Why Custom Types?
+
+The custom types in Forge-SQL-ORM handle the conversion between JavaScript Date objects and Forge SQL's required string formats automatically. Without these custom types, you would need to manually format dates like this:
+
+```typescript
+// Without custom types, you'd need to do this manually:
+const date = moment().format("YYYY-MM-DD");
+const time = moment().format("HH:mm:ss.SSS");
+const timestamp = moment().format("YYYY-MM-DDTHH:mm:ss.SSS");
+```
+
+Our custom types provide:
+- Automatic conversion between JavaScript Date objects and Forge SQL's required string formats
+- Consistent date/time handling across your application
+- Type safety for date/time fields
+- Proper handling of timezone conversions
+- Support for all Forge SQL date/time types (datetime, timestamp, date, time)
+
+### Available Custom Types
+
+- `forgeDateTimeString` - For datetime fields (YYYY-MM-DD HH:MM:SS[.fraction])
+- `forgeTimestampString` - For timestamp fields (YYYY-MM-DD HH:MM:SS[.fraction])
+- `forgeDateString` - For date fields (YYYY-MM-DD)
+- `forgeTimeString` - For time fields (HH:MM:SS[.fraction])
+
+Each type ensures that the data is properly formatted according to Forge SQL's requirements while providing a clean, type-safe interface for your application code.
+
+
+
+
 # Connection to ORM
 
 ```js
@@ -162,20 +273,35 @@ import ForgeSQL from "forge-sql-orm";
 
 const forgeSQL = new ForgeSQL();
 ```
+or 
+
+```typescript
+import { drizzle } from "drizzle-orm/mysql-core";
+import { forgeDriver } from "forge-sql-orm";
+
+// Initialize drizzle with the custom driver
+const db = drizzle(forgeDriver);
+
+// Use drizzle directly
+const users = await db.select().from(users);
+```
 
 ## Fetch Data
 
 ### Basic Fetch Operations
 
 ```js
-// Using executeQuery for single result
+// Using forgeSQL.getDrizzleQueryBuilder()
 const user = await forgeSQL
-  .fetch()
-  .executeQuery(
-    forgeSQL.getDrizzleQueryBuilder()
-      .select("*").from(Users)
-      .where(eq(Users.id, 1))
-  );
+  .getDrizzleQueryBuilder()
+  .select("*").from(Users)
+  .where(eq(Users.id, 1));
+
+// OR using direct drizzle with custom driver
+const db = drizzle(forgeDriver);
+const user = await db
+  .select("*").from(Users)
+  .where(eq(Users.id, 1));
 // Returns: { id: 1, name: "John Doe" }
 
 // Using executeQueryOnlyOne for single result with error handling
@@ -191,34 +317,47 @@ const user = await forgeSQL
 // Throws error if multiple records found
 // Returns undefined if no records found
 
-// Using executeQuery with aliases
+// Using with aliases
+// With forgeSQL
 const usersAlias = alias(Users, "u");
 const result = await forgeSQL
-  .fetch()
-  .executeQuery(
-    forgeSQL
-      .getDrizzleQueryBuilder()
-      .select({
-        userId: rawSql`${usersAlias.id} as \`userId\``,
-        userName: rawSql`${usersAlias.name} as \`userName\``
-      }).from(usersAlias)
-  );
+  .getDrizzleQueryBuilder()
+  .select({
+    userId: rawSql`${usersAlias.id} as \`userId\``,
+    userName: rawSql`${usersAlias.name} as \`userName\``
+  }).from(usersAlias);
+
+// OR with direct drizzle
+const db = drizzle(forgeDriver);
+const result = await db
+  .select({
+    userId: rawSql`${usersAlias.id} as \`userId\``,
+    userName: rawSql`${usersAlias.name} as \`userName\``
+  }).from(usersAlias);
 // Returns: { userId: 1, userName: "John Doe" }
 
-// Using executeQuery with joins
+// Using joins
+// With forgeSQL
 const orderWithUser = await forgeSQL
-  .fetch()
-  .executeQuery(
-    forgeSQL
-      .getDrizzleQueryBuilder()
-      .select({
-        orderId: rawSql`${Orders.id} as \`orderId\``,
-        product: Orders.product,
-        userName: rawSql`${Users.name} as \`userName\``
-      }).from(Orders)
-      .innerJoin(Users, eq(Orders.userId, Users.id))
-      .where(eq(Orders.id, 1))
-  );
+  .getDrizzleQueryBuilder()
+  .select({
+    orderId: rawSql`${Orders.id} as \`orderId\``,
+    product: Orders.product,
+    userName: rawSql`${Users.name} as \`userName\``
+  }).from(Orders)
+  .innerJoin(Users, eq(Orders.userId, Users.id))
+  .where(eq(Orders.id, 1));
+
+// OR with direct drizzle
+const db = drizzle(forgeDriver);
+const orderWithUser = await db
+  .select({
+    orderId: rawSql`${Orders.id} as \`orderId\``,
+    product: Orders.product,
+    userName: rawSql`${Users.name} as \`userName\``
+  }).from(Orders)
+  .innerJoin(Users, eq(Orders.userId, Users.id))
+  .where(eq(Orders.id, 1));
 // Returns: { orderId: 1, product: "Product 1", userName: "John Doe" }
 ```
 
@@ -226,18 +365,25 @@ const orderWithUser = await forgeSQL
 
 ```js
 // Finding duplicates
+// With forgeSQL
 const duplicates = await forgeSQL
-  .fetch()
-  .executeQuery(
-    forgeSQL
-      .getDrizzleQueryBuilder()
-      .select({
-        name: Users.name,
-        count: rawSql`COUNT(*) as \`count\``
-      }).from(Users)
-      .groupBy(Users.name)
-      .having(rawSql`COUNT(*) > 1`)
-  );
+  .getDrizzleQueryBuilder()
+  .select({
+    name: Users.name,
+    count: rawSql`COUNT(*) as \`count\``
+  }).from(Users)
+  .groupBy(Users.name)
+  .having(rawSql`COUNT(*) > 1`);
+
+// OR with direct drizzle
+const db = drizzle(forgeDriver);
+const duplicates = await db
+  .select({
+    name: Users.name,
+    count: rawSql`COUNT(*) as \`count\``
+  }).from(Users)
+  .groupBy(Users.name)
+  .having(rawSql`COUNT(*) > 1`);
 // Returns: { name: "John Doe", count: 2 }
 
 // Using executeQueryOnlyOne for unique results

package/dist/ForgeSQLORM.js

@@ -2,11 +2,6 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const drizzleOrm = require("drizzle-orm");
 const moment = require("moment");
-const primaryKeys = require("drizzle-orm/mysql-core/primary-keys");
-const indexes = require("drizzle-orm/mysql-core/indexes");
-const checks = require("drizzle-orm/mysql-core/checks");
-const foreignKeys = require("drizzle-orm/mysql-core/foreign-keys");
-const uniqueConstraint = require("drizzle-orm/mysql-core/unique-constraint");
 const sql = require("@forge/sql");
 const mysql2 = require("drizzle-orm/mysql2");
 const mysqlCore = require("drizzle-orm/mysql-core");
@@ -23,31 +18,29 @@ function extractAlias(query) {
   return match ? match[2] : query;
 }
 function getPrimaryKeys(table) {
-  const { columns, primaryKeys: primaryKeys2 } = getTableMetadata(table);
+  const { columns, primaryKeys } = getTableMetadata(table);
   const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary);
   if (columnPrimaryKeys.length > 0) {
     return columnPrimaryKeys;
   }
-  if (Array.isArray(primaryKeys2) && primaryKeys2.length > 0) {
+  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
     const primaryKeyColumns = /* @__PURE__ */ new Set();
-    primaryKeys2.forEach((primaryKeyBuilder) => {
+    primaryKeys.forEach((primaryKeyBuilder) => {
       Object.entries(columns).filter(([, column]) => {
         return primaryKeyBuilder.columns.includes(column);
       }).forEach(([name, column]) => {
         primaryKeyColumns.add([name, column]);
       });
     });
-    const result = Array.from(primaryKeyColumns);
-    return result.length > 0 ? result : void 0;
+    return Array.from(primaryKeyColumns);
   }
-  return void 0;
+  return [];
 }
 function getTableMetadata(table) {
   const symbols = Object.getOwnPropertySymbols(table);
   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)"));
   const builders = {
     indexes: [],
     checks: [],
@@ -56,38 +49,33 @@ function getTableMetadata(table) {
     uniqueConstraints: [],
     extras: []
   };
-  if (foreignKeysSymbol) {
-    const foreignKeys2 = table[foreignKeysSymbol];
-    if (foreignKeys2) {
-      for (const foreignKey of foreignKeys2) {
-        builders.foreignKeys.push(foreignKey);
-      }
-    }
-  }
   if (extraSymbol) {
     const extraConfigBuilder = table[extraSymbol];
     if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
-      const configBuilders = extraConfigBuilder(table);
-      let configBuildersArray = [];
-      if (!Array.isArray(configBuilders)) {
-        configBuildersArray = Object.values(configBuilders);
-      } else {
-        configBuildersArray = configBuilders;
+      const configBuilderData = extraConfigBuilder(table);
+      if (configBuilderData) {
+        const configBuilders = Array.isArray(configBuilderData) ? configBuilderData : Object.values(configBuilderData).map(
+          (item) => item.value || item
+        );
+        configBuilders.forEach((builder) => {
+          if (!builder?.constructor) return;
+          const builderName = builder.constructor.name.toLowerCase();
+          const builderMap = {
+            indexbuilder: builders.indexes,
+            checkbuilder: builders.checks,
+            foreignkeybuilder: builders.foreignKeys,
+            primarykeybuilder: builders.primaryKeys,
+            uniqueconstraintbuilder: builders.uniqueConstraints
+          };
+          for (const [type, array] of Object.entries(builderMap)) {
+            if (builderName.includes(type)) {
+              array.push(builder);
+              break;
+            }
+          }
+          builders.extras.push(builder);
+        });
       }
-      configBuildersArray.forEach((builder) => {
-        if (builder instanceof indexes.IndexBuilder) {
-          builders.indexes.push(builder);
-        } else if (builder instanceof checks.CheckBuilder) {
-          builders.checks.push(builder);
-        } else if (builder instanceof foreignKeys.ForeignKeyBuilder) {
-          builders.foreignKeys.push(builder);
-        } else if (builder instanceof primaryKeys.PrimaryKeyBuilder) {
-          builders.primaryKeys.push(builder);
-        } else if (builder instanceof uniqueConstraint.UniqueConstraintBuilder) {
-          builders.uniqueConstraints.push(builder);
-        }
-        builders.extras.push(builder);
-      });
     }
   }
   return {
@@ -136,8 +124,8 @@ class ForgeSQLCrudOperations {
     if (this.options?.logRawSqlQuery) {
       console.debug("INSERT SQL:", query.sql);
     }
-    const result = await this.forgeOperations.fetch().executeRawUpdateSQL(query.sql, query.params);
-    return result.insertId;
+    const result = await finalQuery;
+    return result[0].insertId;
   }
   /**
    * Deletes a record by its primary key with optional version check.
@@ -152,11 +140,11 @@ class ForgeSQLCrudOperations {
    */
   async deleteById(id, schema) {
     const { tableName, columns } = getTableMetadata(schema);
-    const primaryKeys2 = this.getPrimaryKeys(schema);
-    if (primaryKeys2.length !== 1) {
+    const primaryKeys = this.getPrimaryKeys(schema);
+    if (primaryKeys.length !== 1) {
       throw new Error("Only single primary key is supported");
     }
-    const [primaryKeyName, primaryKeyColumn] = primaryKeys2[0];
+    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
     const versionMetadata = this.validateVersionField(tableName, columns);
     const conditions = [drizzleOrm.eq(primaryKeyColumn, id)];
     if (versionMetadata && columns) {
@@ -173,8 +161,8 @@ class ForgeSQLCrudOperations {
     if (this.options?.logRawSqlQuery) {
       console.debug("DELETE SQL:", queryBuilder.toSQL().sql);
     }
-    const result = await this.forgeOperations.fetch().executeRawUpdateSQL(queryBuilder.toSQL().sql, queryBuilder.toSQL().params);
-    return result.affectedRows;
+    const result = await queryBuilder;
+    return result[0].affectedRows;
   }
   /**
    * Updates a record by its primary key with optimistic locking support.
@@ -193,11 +181,11 @@ class ForgeSQLCrudOperations {
    */
   async updateById(entity, schema) {
     const { tableName, columns } = getTableMetadata(schema);
-    const primaryKeys2 = this.getPrimaryKeys(schema);
-    if (primaryKeys2.length !== 1) {
+    const primaryKeys = this.getPrimaryKeys(schema);
+    if (primaryKeys.length !== 1) {
       throw new Error("Only single primary key is supported");
     }
-    const [primaryKeyName, primaryKeyColumn] = primaryKeys2[0];
+    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
     const versionMetadata = this.validateVersionField(tableName, columns);
     if (!(primaryKeyName in entity)) {
       throw new Error(`Primary key ${primaryKeyName} must be provided in the entity`);
@@ -223,13 +211,13 @@ class ForgeSQLCrudOperations {
     if (this.options?.logRawSqlQuery) {
       console.debug("UPDATE SQL:", queryBuilder.toSQL().sql);
     }
-    const result = await this.forgeOperations.fetch().executeRawUpdateSQL(queryBuilder.toSQL().sql, queryBuilder.toSQL().params);
-    if (versionMetadata && result.affectedRows === 0) {
+    const result = await queryBuilder;
+    if (versionMetadata && result[0].affectedRows === 0) {
       throw new Error(
         `Optimistic locking failed: record with primary key ${entity[primaryKeyName]} has been modified`
       );
     }
-    return result.affectedRows;
+    return result[0].affectedRows;
   }
   /**
    * Updates specified fields of records based on provided conditions.
@@ -251,8 +239,8 @@ class ForgeSQLCrudOperations {
     if (this.options?.logRawSqlQuery) {
       console.debug("UPDATE SQL:", queryBuilder.toSQL().sql);
     }
-    const result = await this.forgeOperations.fetch().executeRawUpdateSQL(queryBuilder.toSQL().sql, queryBuilder.toSQL().params);
-    return result.affectedRows;
+    const result = await queryBuilder;
+    return result[0].affectedRows;
   }
   // Helper methods
   /**
@@ -263,11 +251,11 @@ class ForgeSQLCrudOperations {
    * @throws {Error} If no primary keys are found
    */
   getPrimaryKeys(schema) {
-    const primaryKeys2 = getPrimaryKeys(schema);
-    if (!primaryKeys2) {
+    const primaryKeys = getPrimaryKeys(schema);
+    if (!primaryKeys) {
       throw new Error(`No primary keys found for schema: ${schema}`);
     }
-    return primaryKeys2;
+    return primaryKeys;
   }
   /**
    * Validates and retrieves version field metadata.
@@ -377,8 +365,8 @@ class ForgeSQLCrudOperations {
    */
   async getOldModel(primaryKeyValues, schema, versionField) {
     const [versionFieldName, versionFieldColumn] = versionField;
-    const primaryKeys2 = this.getPrimaryKeys(schema);
-    const [primaryKeyName, primaryKeyColumn] = primaryKeys2[0];
+    const primaryKeys = this.getPrimaryKeys(schema);
+    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
     const resultQuery = this.forgeOperations.getDrizzleQueryBuilder().select({
       [primaryKeyName]: primaryKeyColumn,
       [versionFieldName]: versionFieldColumn
@@ -399,105 +387,6 @@ class ForgeSQLSelectOperations {
   constructor(options) {
     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(query) {
-    const queryType = query;
-    const querySql = queryType.toSQL();
-    const datas = await this.executeRawSQL(querySql.sql, querySql.params);
-    if (!datas.length) return [];
-    return datas.map((r) => {
-      const rawModel = r;
-      const newModel = {};
-      const columns = queryType.config.fields;
-      Object.entries(columns).forEach(([name, column]) => {
-        const { realColumn, aliasName } = this.extractColumnInfo(column);
-        const value = rawModel[aliasName];
-        if (value === null || value === void 0) {
-          newModel[name] = value;
-          return;
-        }
-        newModel[name] = this.parseColumnValue(realColumn, value);
-      });
-      return newModel;
-    });
-  }
-  /**
-   * 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
-   */
-  extractColumnInfo(column) {
-    if (column instanceof drizzleOrm.SQL) {
-      const realColumnSql = column;
-      const realColumn = realColumnSql.queryChunks.find(
-        (q) => q instanceof drizzleOrm.Column
-      );
-      let stringChunk = this.findAliasChunk(realColumnSql);
-      let withoutAlias = false;
-      if (!realColumn && (!stringChunk || !stringChunk.value || !stringChunk.value?.length)) {
-        stringChunk = realColumnSql.queryChunks.filter((q) => q instanceof drizzleOrm.StringChunk).find((q) => q.value[0]);
-        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
-   */
-  findAliasChunk(realColumnSql) {
-    return realColumnSql.queryChunks.filter((q) => q instanceof drizzleOrm.StringChunk).find(
-      (q) => q.value.find((f) => f.toLowerCase().includes("as"))
-    );
-  }
-  /**
-   * 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
-   */
-  resolveAliasName(stringChunk, realColumn, withoutAlias) {
-    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
-   */
-  parseColumnValue(column, value) {
-    if (!column) return value;
-    switch (column.getSQLType()) {
-      case "datetime":
-        return parseDateTime(value, "YYYY-MM-DDTHH:mm:ss.SSS");
-      case "date":
-        return parseDateTime(value, "YYYY-MM-DD");
-      case "time":
-        return parseDateTime(value, "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.
@@ -508,7 +397,7 @@ class ForgeSQLSelectOperations {
    * @throws {Error} If more than one record is returned
    */
   async executeQueryOnlyOne(query) {
-    const results = await this.executeQuery(query);
+    const results = await query;
     const datas = results;
     if (!datas.length) {
       return void 0;
@@ -533,6 +422,9 @@ class ForgeSQLSelectOperations {
     }
     const sqlStatement = sql.sql.prepare(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();
@@ -553,6 +445,33 @@ class ForgeSQLSelectOperations {
     return updateQueryResponseResults.rows;
   }
 }
+const forgeDriver = {
+  query: async (query, params) => {
+    try {
+      const sqlStatement = await sql.sql.prepare(query.sql);
+      if (params) {
+        await sqlStatement.bindParams(...params);
+      }
+      const result = await sqlStatement.execute();
+      let rows;
+      if (Array.isArray(result.rows)) {
+        rows = [
+          result.rows.map((r) => Object.values(r))
+        ];
+      } else {
+        rows = [
+          result.rows
+        ];
+      }
+      return rows;
+    } catch (error) {
+      console.error("SQL Error:", JSON.stringify(error));
+      throw error;
+    }
+  },
+  transaction: async (transactionFn) => {
+  }
+};
 class ForgeSQLORMImpl {
   static instance = null;
   drizzle;
@@ -571,7 +490,7 @@ class ForgeSQLORMImpl {
       if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.drizzle = mysql2.drizzle("");
+      this.drizzle = mysql2.drizzle(forgeDriver);
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -700,6 +619,7 @@ exports.ForgeSQLCrudOperations = ForgeSQLCrudOperations;
 exports.ForgeSQLSelectOperations = ForgeSQLSelectOperations;
 exports.default = ForgeSQLORM;
 exports.extractAlias = extractAlias;
+exports.forgeDriver = forgeDriver;
 exports.getPrimaryKeys = getPrimaryKeys;
 exports.getTableMetadata = getTableMetadata;
 exports.mySqlDateString = mySqlDateString;