forge-sql-orm 1.0.31 → 1.1.31

package/dist/ForgeSQLORM.mjs

@@ -1,26 +1,14 @@
-import { EntitySchema, MikroORM, MemoryCacheAdapter, NullCacheAdapter } from "@mikro-orm/mysql";
-export * from "@mikro-orm/mysql";
-import { sql } from "@forge/sql";
+import { eq, and, SQL, Column, StringChunk } from "drizzle-orm";
 import moment from "moment";
-export * from "@mikro-orm/entity-generator";
-const wrapIfNeeded = (data, wrap) => {
-  return wrap ? `'${data}'` : data;
-};
-const transformValue = (value, wrapValue = false) => {
-  switch (value.type) {
-    case "text":
-    case "string":
-      return wrapIfNeeded(`${value.value}`, wrapValue);
-    case "datetime":
-      return wrapIfNeeded(`${moment(value.value).format("YYYY-MM-DDTHH:mm:ss.SSS")}`, wrapValue);
-    case "date":
-      return wrapIfNeeded(`${moment(value.value).format("YYYY-MM-DD")}`, wrapValue);
-    case "time":
-      return wrapIfNeeded(`${moment(value.value).format("HH:mm:ss.SSS")}`, wrapValue);
-    default:
-      return value.value;
-  }
-};
+import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
+import { IndexBuilder } 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";
+import { sql } from "@forge/sql";
+import { drizzle } from "drizzle-orm/mysql2";
+import { customType } from "drizzle-orm/mysql-core";
+import moment$1 from "moment/moment.js";
 const parseDateTime = (value, format) => {
   const m = moment(value, format, true);
   if (!m.isValid()) {
@@ -28,576 +16,536 @@ const parseDateTime = (value, format) => {
   }
   return m.toDate();
 };
+function extractAlias(query) {
+  const match = query.match(/\bas\s+(['"`]?)([\w*]+)\1$/i);
+  return match ? match[2] : query;
+}
+function getPrimaryKeys(table) {
+  const { columns, primaryKeys } = getTableMetadata(table);
+  const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary);
+  if (columnPrimaryKeys.length > 0) {
+    return columnPrimaryKeys;
+  }
+  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
+    const primaryKeyColumns = /* @__PURE__ */ new Set();
+    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 void 0;
+}
+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: [],
+    foreignKeys: [],
+    primaryKeys: [],
+    uniqueConstraints: [],
+    extras: []
+  };
+  if (foreignKeysSymbol) {
+    const foreignKeys = table[foreignKeysSymbol];
+    if (foreignKeys) {
+      for (const foreignKey of foreignKeys) {
+        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;
+      }
+      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);
+      });
+    }
+  }
+  return {
+    tableName: nameSymbol ? table[nameSymbol] : "",
+    columns: columnsSymbol ? table[columnsSymbol] : {},
+    ...builders
+  };
+}
 class ForgeSQLCrudOperations {
   forgeOperations;
   options;
+  /**
+   * Creates a new instance of ForgeSQLCrudOperations.
+   * @param forgeSqlOperations - The ForgeSQL operations instance
+   * @param options - Configuration options for the ORM
+   */
   constructor(forgeSqlOperations, options) {
     this.forgeOperations = forgeSqlOperations;
     this.options = options;
   }
   /**
-   * Generates an SQL INSERT statement for the provided models.
-   * If a version field exists in the schema, its value is set accordingly.
-   *
-   * @param schema - The entity schema.
-   * @param models - The list of entities to insert.
-   * @param updateIfExists - Whether to update the row if it already exists.
-   * @returns An object containing the SQL query, column names, and values.
-   */
-  async generateInsertScript(schema, models, updateIfExists) {
-    const columnNames = /* @__PURE__ */ new Set();
-    const modelFieldValues = [];
-    models.forEach((model) => {
-      const fieldValues = {};
-      schema.meta.props.forEach((prop) => {
-        const value = model[prop.name];
-        if (prop.kind === "scalar" && value !== void 0) {
-          const columnName = this.getRealFieldNameFromSchema(prop);
-          columnNames.add(columnName);
-          fieldValues[columnName] = { type: prop.type, value };
-        }
-      });
-      modelFieldValues.push(fieldValues);
-    });
-    const versionField = this.getVersionField(schema);
-    if (versionField) {
-      modelFieldValues.forEach((mv) => {
-        const versionRealName = this.getRealFieldNameFromSchema(versionField);
-        if (mv[versionRealName]) {
-          mv[versionRealName].value = transformValue(
-            { value: this.createVersionField(versionField), type: versionField.name },
-            true
-          );
-        } else {
-          mv[versionRealName] = {
-            type: versionField.type,
-            value: transformValue(
-              { value: this.createVersionField(versionField), type: versionField.name },
-              true
-            )
-          };
-          columnNames.add(versionField.name);
-        }
-      });
-    }
-    const columns = Array.from(columnNames);
-    const values = modelFieldValues.flatMap(
-      (fieldValueMap) => columns.map(
-        (column) => fieldValueMap[column] || {
-          type: "string",
-          value: null
-        }
-      )
-    );
-    const insertValues = modelFieldValues.map((fieldValueMap) => {
-      const rowValues = columns.map(
-        (column) => transformValue(
-          fieldValueMap[column] || { type: "string", value: null },
-          true
-        )
-      ).join(",");
-      return `(${rowValues})`;
-    }).join(", ");
-    const insertEmptyValues = modelFieldValues.map(() => {
-      const rowValues = columns.map(
-        () => "?"
-      ).join(",");
-      return `(${rowValues})`;
-    }).join(", ");
-    const updateClause = updateIfExists ? ` ON DUPLICATE KEY UPDATE ${columns.map((col) => `${col} = VALUES(${col})`).join(",")}` : "";
-    return {
-      sql: `INSERT INTO ${schema.meta.collection} (${columns.join(",")}) VALUES ${insertValues}${updateClause}`,
-      query: `INSERT INTO ${schema.meta.collection} (${columns.join(",")}) VALUES ${insertEmptyValues}${updateClause}`,
-      fields: columns,
-      values
-    };
-  }
-  /**
-   * Inserts records into the database.
+   * Inserts records into the database with optional versioning support.
    * If a version field exists in the schema, versioning is applied.
    *
-   * @param schema - The entity schema.
-   * @param models - The list of entities to insert.
-   * @param updateIfExists - Whether to update the row if it already exists.
-   * @returns The ID of the inserted row.
+   * @template T - The type of the table schema
+   * @param {T} schema - The entity schema
+   * @param {Partial<InferInsertModel<T>>[]} models - Array of entities to insert
+   * @param {boolean} [updateIfExists=false] - Whether to update existing records
+   * @returns {Promise<number>} The number of inserted rows
+   * @throws {Error} If the insert operation fails
    */
   async insert(schema, models, updateIfExists = false) {
-    if (!models || models.length === 0) return 0;
-    const query = await this.generateInsertScript(schema, models, updateIfExists);
+    if (!models?.length) return 0;
+    const { tableName, columns } = getTableMetadata(schema);
+    const versionMetadata = this.validateVersionField(tableName, columns);
+    const preparedModels = models.map(
+      (model) => this.prepareModelWithVersion(model, versionMetadata, columns)
+    );
+    const queryBuilder = this.forgeOperations.getDrizzleQueryBuilder().insert(schema).values(preparedModels);
+    const finalQuery = updateIfExists ? queryBuilder.onDuplicateKeyUpdate({
+      set: Object.fromEntries(
+        Object.keys(preparedModels[0]).map((key) => [key, schema[key]])
+      )
+    }) : queryBuilder;
+    const query = finalQuery.toSQL();
     if (this.options?.logRawSqlQuery) {
-      console.debug("INSERT SQL: " + query.query);
-    }
-    const sqlStatement = sql.prepare(query.sql);
-    const result = await sqlStatement.execute();
-    return result.rows.insertId;
-  }
-  /**
-   * Retrieves the primary key properties from the entity schema.
-   *
-   * @param schema - The entity schema.
-   * @returns An array of primary key properties.
-   * @throws If no primary keys are found.
-   */
-  getPrimaryKeys(schema) {
-    const primaryKeys = schema.meta.props.filter((prop) => prop.primary);
-    if (!primaryKeys.length) {
-      throw new Error(`No primary keys found for schema: ${schema.meta.className}`);
+      console.debug("INSERT SQL:", query.sql);
     }
-    return primaryKeys;
+    const result = await this.forgeOperations.fetch().executeRawUpdateSQL(query.sql, query.params);
+    return result.insertId;
   }
   /**
-   * Deletes a record by its primary key.
+   * Deletes a record by its primary key with optional version check.
+   * If versioning is enabled, ensures the record hasn't been modified since last read.
    *
-   * @param id - The ID of the record to delete.
-   * @param schema - The entity schema.
-   * @returns The number of rows affected.
-   * @throws If the entity has more than one primary key.
+   * @template T - The type of the table schema
+   * @param {unknown} id - The ID of the record to delete
+   * @param {T} schema - The entity schema
+   * @returns {Promise<number>} Number of affected rows
+   * @throws {Error} If the delete operation fails
+   * @throws {Error} If multiple primary keys are found
    */
   async deleteById(id, schema) {
+    const { tableName, columns } = getTableMetadata(schema);
     const primaryKeys = this.getPrimaryKeys(schema);
-    if (primaryKeys.length > 1) {
-      throw new Error("Only one primary key is supported");
-    }
-    const primaryKey = primaryKeys[0];
-    const queryBuilder = this.forgeOperations.createQueryBuilder(schema.meta.class).delete();
-    queryBuilder.andWhere({ [primaryKey.name]: { $eq: id } });
-    const query = queryBuilder.getFormattedQuery();
-    if (this.options?.logRawSqlQuery) {
-      console.debug("DELETE SQL: " + queryBuilder.getQuery());
+    if (primaryKeys.length !== 1) {
+      throw new Error("Only single primary key is supported");
     }
-    const sqlStatement = sql.prepare(query);
-    const result = await sqlStatement.execute();
-    return result.rows.affectedRows;
-  }
-  /**
-   * Retrieves the version field from the entity schema.
-   * The version field must be of type datetime, integer, or decimal, not a primary key, and not nullable.
-   *
-   * @param schema - The entity schema.
-   * @returns The version field property if it exists.
-   */
-  getVersionField(schema) {
-    if (this.options.disableOptimisticLocking) {
-      return void 0;
-    }
-    return schema.meta.props.filter((prop) => prop.version).filter((prop) => {
-      const validType = prop.type === "datetime" || prop.type === "integer" || prop.type === "decimal";
-      if (!validType) {
-        console.warn(
-          `Version field "${prop.name}" in table ${schema.meta.tableName} must be datetime, integer, or decimal, but is "${prop.type}"`
-        );
-      }
-      return validType;
-    }).filter((prop) => {
-      if (prop.primary) {
-        console.warn(
-          `Version field "${prop.name}" in table ${schema.meta.tableName} cannot be a primary key`
-        );
-        return false;
-      }
-      return true;
-    }).find((prop) => {
-      if (prop.nullable) {
-        console.warn(
-          `Version field "${prop.name}" in table ${schema.meta.tableName} should not be nullable`
-        );
-        return false;
-      }
-      return true;
-    });
-  }
-  /**
-   * Increments the version field of an entity.
-   * For datetime types, sets the current date; for numeric types, increments by 1.
-   *
-   * @param versionField - The version field property.
-   * @param updateModel - The entity to update.
-   */
-  incrementVersionField(versionField, updateModel) {
-    const key = versionField.name;
-    switch (versionField.type) {
-      case "datetime": {
-        updateModel[key] = /* @__PURE__ */ new Date();
-        break;
-      }
-      case "decimal":
-      case "integer": {
-        updateModel[key] = updateModel[key] + 1;
-        break;
+    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
+    const versionMetadata = this.validateVersionField(tableName, columns);
+    const conditions = [eq(primaryKeyColumn, id)];
+    if (versionMetadata && columns) {
+      const versionField = columns[versionMetadata.fieldName];
+      if (versionField) {
+        const oldModel = await this.getOldModel({ [primaryKeyName]: id }, schema, [
+          versionMetadata.fieldName,
+          versionField
+        ]);
+        conditions.push(eq(versionField, oldModel[versionMetadata.fieldName]));
       }
-      default:
-        throw new Error(`Unsupported version field type: ${versionField.type}`);
     }
-  }
-  /**
-   * Creates the initial version field value for an entity.
-   * For datetime types, returns the current date; for numeric types, returns 0.
-   *
-   * @param versionField - The version field property.
-   */
-  createVersionField(versionField) {
-    switch (versionField.type) {
-      case "datetime": {
-        return /* @__PURE__ */ new Date();
-      }
-      case "decimal":
-      case "integer": {
-        return 0;
-      }
-      default:
-        throw new Error(`Unsupported version field type: ${versionField.type}`);
+    const queryBuilder = this.forgeOperations.getDrizzleQueryBuilder().delete(schema).where(and(...conditions));
+    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;
   }
   /**
-   * Updates a record by its primary key using the provided entity data.
+   * Updates a record by its primary key with optimistic locking support.
+   * If versioning is enabled:
+   * - Retrieves the current version
+   * - Checks for concurrent modifications
+   * - Increments the version on successful update
    *
-   * @param entity - The entity with updated values.
-   * @param schema - The entity schema.
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} entity - The entity with updated values
+   * @param {T} schema - The entity schema
+   * @returns {Promise<number>} Number of affected rows
+   * @throws {Error} If the primary key is not provided
+   * @throws {Error} If optimistic locking check fails
+   * @throws {Error} If multiple primary keys are found
    */
   async updateById(entity, schema) {
-    const fields = schema.meta.props.filter((prop) => prop.kind === "scalar").map((prop) => prop.name);
-    await this.updateFieldById(entity, fields, schema);
-  }
-  /**
-   * Updates specified fields of records based on provided conditions.
-   * If the "where" parameter is not provided, the WHERE clause is built from the entity fields
-   * that are not included in the list of fields to update.
-   *
-   * @param entity - The object containing values to update and potential criteria for filtering.
-   * @param fields - Array of field names to update.
-   * @param schema - The entity schema.
-   * @param where - Optional filtering conditions for the WHERE clause.
-   * @returns The number of affected rows.
-   * @throws If no filtering criteria are provided (either via "where" or from the remaining entity fields).
-   */
-  async updateFields(entity, fields, schema, where) {
-    const updateData = this.filterEntityFields(entity, fields);
-    const updateModel = this.modifyModel(updateData, schema);
-    let queryBuilder = this.forgeOperations.createQueryBuilder(schema.meta.class).getKnexQuery();
-    queryBuilder.update(updateModel);
-    if (where) {
-      queryBuilder.where(where);
-    } else {
-      const filterCriteria = Object.keys(entity).filter((key) => !fields.includes(key)).reduce((criteria, key) => {
-        if (entity[key] !== void 0) {
-          criteria[key] = entity[key];
-        }
-        return criteria;
-      }, {});
-      if (Object.keys(filterCriteria).length === 0) {
-        throw new Error(
-          "Filtering criteria (WHERE clause) must be provided either via the 'where' parameter or through non-updated entity fields"
-        );
-      }
-      queryBuilder.where(filterCriteria);
+    const { tableName, columns } = getTableMetadata(schema);
+    const primaryKeys = this.getPrimaryKeys(schema);
+    if (primaryKeys.length !== 1) {
+      throw new Error("Only single primary key is supported");
     }
-    if (this.options?.logRawSqlQuery) {
-      console.debug("UPDATE SQL (updateFields): " + queryBuilder.toSQL().sql);
+    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`);
     }
-    const sqlQuery = queryBuilder.toQuery();
-    const updateQueryResponse = await this.forgeOperations.fetch().executeRawUpdateSQL(sqlQuery);
-    return updateQueryResponse.affectedRows;
-  }
-  /**
-   * Updates specific fields of a record identified by its primary key.
-   * If a version field exists in the schema, versioning is applied.
-   *
-   * @param entity - The entity with updated values.
-   * @param fields - The list of field names to update.
-   * @param schema - The entity schema.
-   * @throws If the primary key is not included in the update fields.
-   */
-  async updateFieldById(entity, fields, schema) {
-    const primaryKeys = this.getPrimaryKeys(schema);
-    primaryKeys.forEach((pk) => {
-      if (!fields.includes(pk.name)) {
-        throw new Error("Update fields must include primary key: " + pk.name);
-      }
-    });
-    const updatedEntity = this.filterEntityFields(entity, fields);
-    let queryBuilder = this.forgeOperations.createQueryBuilder(schema.meta.class).getKnexQuery();
-    const versionField = this.getVersionField(schema);
-    const useVersion = Boolean(versionField);
-    let updateModel = { ...updatedEntity };
-    if (useVersion && versionField) {
-      let oldModel = entity;
-      if (entity[versionField.name] === void 0 || entity[versionField.name] === null) {
-        oldModel = await this.getOldModel(primaryKeys, entity, schema, versionField);
-      }
-      const primaryFieldNames = primaryKeys.map((pk) => pk.name);
-      const fieldsToRetain = primaryFieldNames.concat(versionField.name);
-      const fromEntries = Object.fromEntries(fieldsToRetain.map((key) => [key, oldModel[key]]));
-      updateModel = { ...updatedEntity, ...fromEntries };
-      this.incrementVersionField(versionField, updateModel);
-      updateModel = this.modifyModel(updateModel, schema);
-      queryBuilder.update(updateModel);
-      if (oldModel[versionField.name] !== void 0 || oldModel[versionField.name] !== null && this.isValid(oldModel[versionField.name])) {
-        queryBuilder.andWhere(this.optWhere(oldModel, versionField));
+    const currentVersion = await this.getCurrentVersion(
+      entity,
+      primaryKeyName,
+      versionMetadata,
+      columns,
+      schema
+    );
+    const updateData = this.prepareUpdateData(entity, versionMetadata, columns, currentVersion);
+    const conditions = [
+      eq(primaryKeyColumn, entity[primaryKeyName])
+    ];
+    if (versionMetadata && columns) {
+      const versionField = columns[versionMetadata.fieldName];
+      if (versionField) {
+        conditions.push(eq(versionField, currentVersion));
       }
-    } else {
-      updateModel = this.modifyModel(updatedEntity, schema);
-      queryBuilder.update(updateModel);
     }
-    this.addPrimaryWhere(queryBuilder, primaryKeys, updateModel);
-    const sqlQuery = queryBuilder.toQuery();
+    const queryBuilder = this.forgeOperations.getDrizzleQueryBuilder().update(schema).set(updateData).where(and(...conditions));
     if (this.options?.logRawSqlQuery) {
-      console.debug("UPDATE SQL: " + queryBuilder.toSQL().sql);
+      console.debug("UPDATE SQL:", queryBuilder.toSQL().sql);
     }
-    const updateQueryResponse = await this.forgeOperations.fetch().executeRawUpdateSQL(sqlQuery);
-    if (versionField && !updateQueryResponse.affectedRows) {
+    const result = await this.forgeOperations.fetch().executeRawUpdateSQL(queryBuilder.toSQL().sql, queryBuilder.toSQL().params);
+    if (versionMetadata && result.affectedRows === 0) {
       throw new Error(
-        "Optimistic locking failed: the record with primary key(s) " + primaryKeys.map((p) => updateModel[p.name]).join(", ") + " has been modified by another process."
+        `Optimistic locking failed: record with primary key ${entity[primaryKeyName]} has been modified`
       );
     }
+    return result.affectedRows;
   }
   /**
-   * Constructs an optional WHERE clause for the version field.
+   * Updates specified fields of records based on provided conditions.
+   * This method does not support versioning and should be used with caution.
    *
-   * @param updateModel - The model containing the current version field value.
-   * @param versionField - The version field property.
-   * @returns A filter query for the version field.
-   */
-  optWhere(updateModel, versionField) {
-    const currentVersionValue = transformValue(
-      { value: updateModel[versionField.name], type: versionField.type },
-      false
-    );
-    return { [versionField.name]: currentVersionValue };
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} updateData - The data to update
+   * @param {T} schema - The entity schema
+   * @param {SQL<unknown>} where - The WHERE conditions
+   * @returns {Promise<number>} Number of affected rows
+   * @throws {Error} If WHERE conditions are not provided
+   * @throws {Error} If the update operation fails
+   */
+  async updateFields(updateData, schema, where) {
+    if (!where) {
+      throw new Error("WHERE conditions must be provided");
+    }
+    const queryBuilder = this.forgeOperations.getDrizzleQueryBuilder().update(schema).set(updateData).where(where);
+    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;
   }
+  // Helper methods
   /**
-   * Retrieves the current state of a record from the database.
-   *
-   * @param primaryKeys - The primary key properties.
-   * @param entity - The entity with updated values.
-   * @param schema - The entity schema.
-   * @param versionField - The version field property.
-   * @returns The existing record from the database.
-   * @throws If the record does not exist or if multiple records are found.
+   * Gets primary keys from the schema.
+   * @template T - The type of the table schema
+   * @param {T} schema - The table schema
+   * @returns {[string, AnyColumn][]} Array of primary key name and column pairs
+   * @throws {Error} If no primary keys are found
    */
-  async getOldModel(primaryKeys, entity, schema, versionField) {
-    const primaryFieldNames = primaryKeys.map((pk) => pk.name);
-    const fieldsToSelect = primaryFieldNames.concat(versionField.name);
-    const queryBuilder = this.forgeOperations.createQueryBuilder(schema).select(fieldsToSelect);
-    this.addPrimaryWhere(queryBuilder, primaryKeys, entity);
-    const formattedQuery = queryBuilder.getFormattedQuery();
-    const models = await this.forgeOperations.fetch().executeSchemaSQL(formattedQuery, schema);
-    if (!models || models.length === 0) {
-      throw new Error(`Cannot modify record because it does not exist in table ${schema.meta.tableName}`);
-    }
-    if (models.length > 1) {
-      throw new Error(
-        `Cannot modify record because multiple rows with the same ID were found in table ${schema.meta.tableName}. Please verify the table metadata.`
-      );
+  getPrimaryKeys(schema) {
+    const primaryKeys = getPrimaryKeys(schema);
+    if (!primaryKeys) {
+      throw new Error(`No primary keys found for schema: ${schema}`);
     }
-    return models[0];
+    return primaryKeys;
   }
   /**
-   * Adds primary key conditions to the query builder.
-   *
-   * @param queryBuilder - The Knex query builder instance.
-   * @param primaryKeys - The primary key properties.
-   * @param entity - The entity containing primary key values.
-   * @throws If any primary key value is missing.
+   * Validates and retrieves version field metadata.
+   * @param {string} tableName - The name of the table
+   * @param {Record<string, AnyColumn>} columns - The table columns
+   * @returns {Object | undefined} Version field metadata if valid, undefined otherwise
    */
-  addPrimaryWhere(queryBuilder, primaryKeys, entity) {
-    primaryKeys.forEach((pk) => {
-      const fieldName = this.getRealFieldNameFromSchema(pk);
-      const value = entity[fieldName];
-      if (value === null || value === void 0) {
-        throw new Error(`Primary key ${fieldName} must exist in the model`);
+  validateVersionField(tableName, columns) {
+    if (this.options.disableOptimisticLocking) {
+      return void 0;
+    }
+    const versionMetadata = this.options.additionalMetadata?.[tableName]?.versionField;
+    if (!versionMetadata) return void 0;
+    const versionField = columns[versionMetadata.fieldName];
+    if (!versionField) {
+      console.warn(
+        `Version field "${versionMetadata.fieldName}" not found in table ${tableName}. Versioning will be skipped.`
+      );
+      return void 0;
+    }
+    if (!versionField.notNull) {
+      console.warn(
+        `Version field "${versionMetadata.fieldName}" in table ${tableName} is nullable. Versioning may not work correctly.`
+      );
+      return void 0;
+    }
+    const fieldType = versionField.getSQLType();
+    const isSupportedType = fieldType === "datetime" || fieldType === "timestamp" || fieldType === "int" || fieldType === "number" || fieldType === "decimal";
+    if (!isSupportedType) {
+      console.warn(
+        `Version field "${versionMetadata.fieldName}" in table ${tableName} has unsupported type "${fieldType}". Only datetime, timestamp, int, and decimal types are supported for versioning. Versioning will be skipped.`
+      );
+      return void 0;
+    }
+    return { fieldName: versionMetadata.fieldName, type: fieldType };
+  }
+  /**
+   * Gets the current version of an entity.
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} entity - The entity
+   * @param {string} primaryKeyName - The name of the primary key
+   * @param {Object | undefined} versionMetadata - Version field metadata
+   * @param {Record<string, AnyColumn>} columns - The table columns
+   * @param {T} schema - The table schema
+   * @returns {Promise<unknown>} The current version value
+   */
+  async getCurrentVersion(entity, primaryKeyName, versionMetadata, columns, schema) {
+    if (!versionMetadata || !columns) return void 0;
+    const versionField = columns[versionMetadata.fieldName];
+    if (!versionField) return void 0;
+    if (versionMetadata.fieldName in entity) {
+      return entity[versionMetadata.fieldName];
+    }
+    const oldModel = await this.getOldModel(
+      { [primaryKeyName]: entity[primaryKeyName] },
+      schema,
+      [versionMetadata.fieldName, versionField]
+    );
+    return oldModel[versionMetadata.fieldName];
+  }
+  /**
+   * Prepares a model for insertion with version field.
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} model - The model to prepare
+   * @param {Object | undefined} versionMetadata - Version field metadata
+   * @param {Record<string, AnyColumn>} columns - The table columns
+   * @returns {InferInsertModel<T>} The prepared model
+   */
+  prepareModelWithVersion(model, versionMetadata, columns) {
+    if (!versionMetadata || !columns) return model;
+    const versionField = columns[versionMetadata.fieldName];
+    if (!versionField) return model;
+    const modelWithVersion = { ...model };
+    const fieldType = versionField.getSQLType();
+    const versionValue = fieldType === "datetime" || fieldType === "timestamp" ? /* @__PURE__ */ new Date() : 1;
+    modelWithVersion[versionMetadata.fieldName] = versionValue;
+    return modelWithVersion;
+  }
+  /**
+   * Prepares update data with version field.
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} entity - The entity to update
+   * @param {Object | undefined} versionMetadata - Version field metadata
+   * @param {Record<string, AnyColumn>} columns - The table columns
+   * @param {unknown} currentVersion - The current version value
+   * @returns {Partial<InferInsertModel<T>>} The prepared update data
+   */
+  prepareUpdateData(entity, versionMetadata, columns, currentVersion) {
+    const updateData = { ...entity };
+    if (versionMetadata && columns) {
+      const versionField = columns[versionMetadata.fieldName];
+      if (versionField) {
+        const fieldType = versionField.getSQLType();
+        updateData[versionMetadata.fieldName] = fieldType === "datetime" || fieldType === "timestamp" ? /* @__PURE__ */ new Date() : currentVersion + 1;
       }
-      queryBuilder.andWhere({ [fieldName]: value });
-    });
+    }
+    return updateData;
   }
   /**
-   * Filters the entity to include only the specified fields.
-   *
-   * @param entity - The original entity.
-   * @param fields - The list of fields to retain.
-   * @returns A partial entity object containing only the specified fields.
+   * Retrieves an existing model by primary key.
+   * @template T - The type of the table schema
+   * @param {Record<string, unknown>} primaryKeyValues - The primary key values
+   * @param {T} schema - The table schema
+   * @param {[string, AnyColumn]} versionField - The version field name and column
+   * @returns {Promise<Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined>} The existing model
+   * @throws {Error} If the record is not found
    */
-  filterEntityFields = (entity, fields) => fields.reduce((result, field) => {
-    if (field in entity) {
-      result[field] = entity[field];
+  async getOldModel(primaryKeyValues, schema, versionField) {
+    const [versionFieldName, versionFieldColumn] = versionField;
+    const primaryKeys = this.getPrimaryKeys(schema);
+    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
+    const resultQuery = this.forgeOperations.getDrizzleQueryBuilder().select({
+      [primaryKeyName]: primaryKeyColumn,
+      [versionFieldName]: versionFieldColumn
+    }).from(schema).where(eq(primaryKeyColumn, primaryKeyValues[primaryKeyName]));
+    const model = await this.forgeOperations.fetch().executeQueryOnlyOne(resultQuery);
+    if (!model) {
+      throw new Error(`Record not found in table ${schema}`);
     }
-    return result;
-  }, {});
-  /**
-   * Transforms and modifies the updated entity model based on the schema.
-   *
-   * @param updatedEntity - The updated entity.
-   * @param schema - The entity schema.
-   * @returns The modified entity.
-   */
-  modifyModel(updatedEntity, schema) {
-    const modifiedModel = {};
-    schema.meta.props.filter((p) => p.kind === "scalar").forEach((p) => {
-      const value = updatedEntity[p.name];
-      if (value !== void 0 && value !== null) {
-        const fieldName = this.getRealFieldNameFromSchema(p);
-        modifiedModel[fieldName] = transformValue({ value, type: p.type }, false);
-      }
-    });
-    return modifiedModel;
+    return model;
   }
+}
+class ForgeSQLSelectOperations {
+  options;
   /**
-   * Returns the real field name from the entity property based on the schema.
-   *
-   * @param p - The entity property.
-   * @returns The real field name.
+   * Creates a new instance of ForgeSQLSelectOperations.
+   * @param {ForgeSqlOrmOptions} options - Configuration options for the ORM
    */
-  getRealFieldNameFromSchema(p) {
-    return p.fieldNames && p.fieldNames.length ? p.fieldNames[0] : p.name;
+  constructor(options) {
+    this.options = options;
   }
   /**
-   * Validates the provided value.
+   * Executes a Drizzle query and returns the results.
+   * Maps the raw database results to the appropriate entity types.
    *
-   * @param value - The value to validate.
-   * @returns True if the value is valid, false otherwise.
-   */
-  isValid(value) {
-    if (value instanceof Date) {
-      return !isNaN(value.getTime());
-    }
-    return true;
+   * @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;
+    });
   }
-}
-class DynamicEntity {
   /**
-   * Retrieves a schema field by its original entity property.
-   * @param field - The entity property to search for.
-   * @returns The corresponding schema field or undefined if not found.
+   * 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
    */
-  getSchemaBySchemaField(field) {
-    return this[field.name];
+  extractColumnInfo(column) {
+    if (column instanceof SQL) {
+      const realColumnSql = column;
+      const realColumn = realColumnSql.queryChunks.find(
+        (q) => q instanceof Column
+      );
+      let stringChunk = this.findAliasChunk(realColumnSql);
+      let withoutAlias = false;
+      if (!realColumn && (!stringChunk || !stringChunk.value || !stringChunk.value?.length)) {
+        stringChunk = realColumnSql.queryChunks.filter((q) => q instanceof StringChunk).find((q) => q.value[0]);
+        withoutAlias = true;
+      }
+      const aliasName = this.resolveAliasName(stringChunk, realColumn, withoutAlias);
+      return { realColumn, aliasName };
+    }
+    return { realColumn: column, aliasName: column.name };
   }
   /**
-   * Retrieves a schema field by its alias.
-   * @param alias - The alias of the field.
-   * @returns The corresponding schema field or undefined if not found.
+   * 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
    */
-  getSchemaByAliasField(alias) {
-    return this[alias];
-  }
-}
-class EntitySchemaBuilder {
-  constructor(entityClass) {
-    this.entityClass = entityClass;
+  findAliasChunk(realColumnSql) {
+    return realColumnSql.queryChunks.filter((q) => q instanceof StringChunk).find(
+      (q) => q.value.find((f) => f.toLowerCase().includes("as"))
+    );
   }
-  properties = {};
   /**
-   * Adds a field to the schema definition.
-   * @param field - The entity property to add.
-   * @param alias - (Optional) Custom alias for the field name.
-   * @returns The current instance of EntitySchemaBuilder for method chaining.
+   * 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
    */
-  addField(field, alias) {
-    const fieldName = alias || field.name;
-    const fieldNameType = fieldName;
-    this.properties[fieldNameType] = { ...field, name: fieldNameType };
-    return this;
+  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 || "";
   }
   /**
-   * Creates and initializes a new EntitySchema based on the added fields.
-   * @returns A new EntitySchema<T> instance.
-   */
-  createSchema() {
-    const es = new EntitySchema({
-      class: this.entityClass,
-      // @ts-ignore
-      properties: this.properties
-    });
-    es.init();
-    return es;
-  }
-}
-class DynamicEntitySchemaBuilder extends EntitySchemaBuilder {
-  constructor() {
-    super(DynamicEntity);
-  }
-}
-class ForgeSQLSelectOperations {
-  options;
-  constructor(options) {
-    this.options = options;
+   * 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;
+    }
   }
   /**
-   * Creates a builder for constructing complex query schemas dynamically.
-   * This method is useful when working with dynamic entity structures where fields
-   * may not be known at compile time.
-   * @returns An instance of ComplexQuerySchemaBuilder configured for dynamic entities.
-   */
-  createComplexQuerySchema() {
-    return new DynamicEntitySchemaBuilder();
-  }
-  async executeSchemaSQLOnlyOne(query, schema) {
-    const results = await this.executeSchemaSQL(query, schema);
-    if (!results || results.length === 0) {
+   * Executes a Drizzle query and returns a single result.
+   * Throws an error if more than one record is returned.
+   *
+   * @template T - The type of the query builder
+   * @param {T} query - The Drizzle query to execute
+   * @returns {Promise<Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined>} A single result object or undefined
+   * @throws {Error} If more than one record is returned
+   */
+  async executeQueryOnlyOne(query) {
+    const results = await this.executeQuery(query);
+    const datas = results;
+    if (!datas.length) {
       return void 0;
     }
-    if (results.length > 1) {
-      throw new Error("Expected 1 record but returned " + results.length);
+    if (datas.length > 1) {
+      throw new Error(`Expected 1 record but returned ${datas.length}`);
     }
-    return results[0];
-  }
-  /**
-   * Executes a schema-based SQL query and maps the result to the entity schema.
-   * @param query - The SQL query to execute.
-   * @param schema - The entity schema defining the structure.
-   * @returns A list of mapped entity objects.
-   */
-  async executeSchemaSQL(query, schema) {
-    const datas = await this.executeRawSQL(query);
-    if (!datas.length) return [];
-    return datas.map((r) => {
-      const rawModel = r;
-      const newModel = Object.create(schema.meta.prototype);
-      schema.meta.props.filter((p) => p.kind === "scalar").forEach((p) => {
-        const fieldName = p.name;
-        const fieldNames = p.fieldNames;
-        const rawFieldName = fieldNames && Array.isArray(fieldNames) ? fieldNames[0] : p.name;
-        switch (p.type) {
-          case "datetime":
-            newModel[fieldName] = parseDateTime(
-              rawModel[rawFieldName],
-              "YYYY-MM-DDTHH:mm:ss.SSS"
-            );
-            break;
-          case "date":
-            newModel[fieldName] = parseDateTime(rawModel[rawFieldName], "YYYY-MM-DD");
-            break;
-          case "time":
-            newModel[fieldName] = parseDateTime(rawModel[rawFieldName], "HH:mm:ss.SSS");
-            break;
-          default:
-            newModel[fieldName] = rawModel[rawFieldName];
-        }
-      });
-      return newModel;
-    });
+    return datas[0];
   }
   /**
    * Executes a raw SQL query and returns the results.
-   * @param query - The raw SQL query to execute.
-   * @returns A list of results as objects.
+   * Logs the query if logging is enabled.
+   *
+   * @template T - The type of the result objects
+   * @param {string} query - The raw SQL query to execute
+   * @param {SqlParameters[]} [params] - Optional SQL parameters
+   * @returns {Promise<T[]>} A list of results as objects
    */
-  async executeRawSQL(query) {
+  async executeRawSQL(query, params) {
     if (this.options.logRawSqlQuery) {
       console.debug("Executing raw SQL: " + query);
     }
-    const sqlStatement = await sql.prepare(query).execute();
-    return sqlStatement.rows;
+    const sqlStatement = sql.prepare(query);
+    if (params) {
+      sqlStatement.bindParams(...params);
+    }
+    const result = await sqlStatement.execute();
+    return result.rows;
   }
   /**
    * Executes a raw SQL update query.
-   * @param query - The raw SQL update query.
-   * @param params - sql parameters.
-   * @returns The update response containing affected rows.
+   * @param {string} query - The raw SQL update query
+   * @param {SqlParameters[]} [params] - Optional SQL parameters
+   * @returns {Promise<UpdateQueryResponse>} The update response containing affected rows
    */
   async executeRawUpdateSQL(query, params) {
     const sqlStatement = sql.prepare(query);
     if (params) {
-      sqlStatement.bindParams(params);
+      sqlStatement.bindParams(...params);
     }
     const updateQueryResponseResults = await sqlStatement.execute();
     return updateQueryResponseResults.rows;
@@ -605,39 +553,23 @@ class ForgeSQLSelectOperations {
 }
 class ForgeSQLORMImpl {
   static instance = null;
-  mikroORM;
+  drizzle;
   crudOperations;
   fetchOperations;
   /**
    * Private constructor to enforce singleton behavior.
-   * @param entities - The list of entities for ORM initialization.
    * @param options - Options for configuring ForgeSQL ORM behavior.
    */
-  constructor(entities, options) {
+  constructor(options) {
     try {
-      const newOptions = options ?? { logRawSqlQuery: false, disableOptimisticLocking: false };
+      const newOptions = options ?? {
+        logRawSqlQuery: false,
+        disableOptimisticLocking: false
+      };
       if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.mikroORM = MikroORM.initSync({
-        dbName: "inmemory",
-        schemaGenerator: {
-          disableForeignKeys: false
-        },
-        discovery: {
-          warnWhenNoEntities: true
-        },
-        resultCache: {
-          adapter: NullCacheAdapter
-        },
-        metadataCache: {
-          enabled: false,
-          adapter: MemoryCacheAdapter
-        },
-        entities,
-        preferTs: false,
-        debug: false
-      });
+      this.drizzle = drizzle("");
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -647,13 +579,12 @@ class ForgeSQLORMImpl {
   }
   /**
    * Returns the singleton instance of ForgeSQLORMImpl.
-   * @param entities - List of entities (required only on first initialization).
    * @param options - Options for configuring ForgeSQL ORM behavior.
    * @returns The singleton instance of ForgeSQLORMImpl.
    */
-  static getInstance(entities, options) {
+  static getInstance(options) {
     if (!ForgeSQLORMImpl.instance) {
-      ForgeSQLORMImpl.instance = new ForgeSQLORMImpl(entities, options);
+      ForgeSQLORMImpl.instance = new ForgeSQLORMImpl(options);
     }
     return ForgeSQLORMImpl.instance;
   }
@@ -672,28 +603,22 @@ class ForgeSQLORMImpl {
     return this.fetchOperations;
   }
   /**
-   * Creates a new query builder for the given entity.
-   * @param entityName - The entity name or an existing query builder.
-   * @param alias - The alias for the entity.
-   * @param loggerContext - Logging options.
-   * @returns The query builder instance.
-   */
-  createQueryBuilder(entityName, alias, loggerContext) {
-    return this.mikroORM.em.createQueryBuilder(entityName, alias, void 0, loggerContext);
-  }
-  /**
-   * Provides access to the underlying Knex instance for building complex query parts.
-   * enabling advanced query customization and performance tuning.
-   * @returns The Knex instance, which can be used for query building.
+   * Returns a Drizzle query builder instance.
+   *
+   * ⚠️ IMPORTANT: This method should be used ONLY for query building purposes.
+   * The returned instance should NOT be used for direct database connections or query execution.
+   * All database operations should be performed through Forge SQL's executeRawSQL or executeRawUpdateSQL methods.
+   *
+   * @returns A Drizzle query builder instance for query construction only.
    */
-  getKnex() {
-    return this.mikroORM.em.getKnex();
+  getDrizzleQueryBuilder() {
+    return this.drizzle;
   }
 }
 class ForgeSQLORM {
   ormInstance;
-  constructor(entities, options) {
-    this.ormInstance = ForgeSQLORMImpl.getInstance(entities, options);
+  constructor(options) {
+    this.ormInstance = ForgeSQLORMImpl.getInstance(options);
   }
   /**
    * Proxies the `crud` method from `ForgeSQLORMImpl`.
@@ -709,20 +634,77 @@ class ForgeSQLORM {
   fetch() {
     return this.ormInstance.fetch();
   }
-  getKnex() {
-    return this.ormInstance.getKnex();
-  }
   /**
-   * Proxies the `createQueryBuilder` method from `ForgeSQLORMImpl`.
-   * @returns A new query builder instance.
+   * Returns a Drizzle query builder instance.
+   *
+   * ⚠️ IMPORTANT: This method should be used ONLY for query building purposes.
+   * The returned instance should NOT be used for direct database connections or query execution.
+   * All database operations should be performed through Forge SQL's executeRawSQL or executeRawUpdateSQL methods.
+   *
+   * @returns A Drizzle query builder instance for query construction only.
    */
-  createQueryBuilder(entityName, alias, loggerContext) {
-    return this.ormInstance.createQueryBuilder(entityName, alias, loggerContext);
+  getDrizzleQueryBuilder() {
+    return this.ormInstance.getDrizzleQueryBuilder();
   }
 }
+const mySqlDateTimeString = customType({
+  dataType() {
+    return "datetime";
+  },
+  toDriver(value) {
+    return moment$1(value).format("YYYY-MM-DDTHH:mm:ss.SSS");
+  },
+  fromDriver(value) {
+    const format = "YYYY-MM-DDTHH:mm:ss.SSS";
+    return parseDateTime(value, format);
+  }
+});
+const mySqlTimestampString = customType({
+  dataType() {
+    return "timestamp";
+  },
+  toDriver(value) {
+    return moment$1(value).format("YYYY-MM-DDTHH:mm:ss.SSS");
+  },
+  fromDriver(value) {
+    const format = "YYYY-MM-DDTHH:mm:ss.SSS";
+    return parseDateTime(value, format);
+  }
+});
+const mySqlDateString = customType({
+  dataType() {
+    return "date";
+  },
+  toDriver(value) {
+    return moment$1(value).format("YYYY-MM-DD");
+  },
+  fromDriver(value) {
+    const format = "YYYY-MM-DD";
+    return parseDateTime(value, format);
+  }
+});
+const mySqlTimeString = customType({
+  dataType() {
+    return "time";
+  },
+  toDriver(value) {
+    return moment$1(value).format("HH:mm:ss.SSS");
+  },
+  fromDriver(value) {
+    return parseDateTime(value, "HH:mm:ss.SSS");
+  }
+});
 export {
   ForgeSQLCrudOperations,
   ForgeSQLSelectOperations,
-  ForgeSQLORM as default
+  ForgeSQLORM as default,
+  extractAlias,
+  getPrimaryKeys,
+  getTableMetadata,
+  mySqlDateString,
+  mySqlDateTimeString,
+  mySqlTimeString,
+  mySqlTimestampString,
+  parseDateTime
 };
 //# sourceMappingURL=ForgeSQLORM.mjs.map