forge-sql-orm 1.0.30 → 1.1.31

package/src/core/ForgeSQLSelectOperations.ts

@@ -1,103 +1,213 @@
 import { sql, UpdateQueryResponse } from "@forge/sql";
-import type { EntitySchema } from "@mikro-orm/core/metadata/EntitySchema";
-import { parseDateTime } from "../utils/sqlUtils";
-import { ComplexQuerySchemaBuilder, ForgeSqlOrmOptions, SchemaSqlForgeSql} from "./ForgeSQLQueryBuilder";
-import {SqlParameters} from "@forge/sql/out/sql-statement";
-import {DynamicEntity, DynamicEntitySchemaBuilder} from "./ComplexQuerySchemaBuilder";
-import {EntityKey} from "@mikro-orm/core";
+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.
+ * Provides methods for executing queries and mapping results to entity types.
+ */
 export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
-    private readonly options: ForgeSqlOrmOptions;
+  private readonly options: ForgeSqlOrmOptions;
 
-    constructor(options: ForgeSqlOrmOptions) {
-        this.options = options;
+  /**
+   * Creates a new instance of ForgeSQLSelectOperations.
+   * @param {ForgeSqlOrmOptions} options - Configuration options for the ORM
+   */
+  constructor(options: ForgeSqlOrmOptions) {
+    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 };
     }
 
-    /**
-     * 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(): ComplexQuerySchemaBuilder<DynamicEntity> {
-        return new DynamicEntitySchemaBuilder();
+    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 || "";
+  }
 
-  async executeSchemaSQLOnlyOne<T extends object>(query: string, schema: EntitySchema<T>): Promise<T|undefined> {
-        const results = await this.executeSchemaSQL(query, schema);
-        if (!results || results.length === 0){
-          return undefined;
-        }
-        if (results.length>1){
-          throw new Error('Expected 1 record but returned '+results.length)
-        }
-        return results[0];
+  /**
+   * 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 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.
+   * 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 executeSchemaSQL<T extends object>(query: string, schema: EntitySchema<T>): Promise<T[]> {
-    const datas = await this.executeRawSQL<unknown>(query);
-    if (!datas.length) return [];
+  async executeQueryOnlyOne<T extends MySqlSelectDynamic<AnyMySqlSelectQueryBuilder>>(
+    query: T,
+  ): Promise<
+    Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined
+  > {
+    const results: Awaited<T> = await this.executeQuery<T>(query);
+    const datas = results as unknown[];
+    if (!datas.length) {
+      return undefined;
+    }
+    if (datas.length > 1) {
+      throw new Error(`Expected 1 record but returned ${datas.length}`);
+    }
 
-    return datas.map((r) => {
-      const rawModel = r as Record<string, unknown>;
-        const newModel = Object.create(schema.meta.prototype) as T;
-
-      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] as string,
-                    "YYYY-MM-DDTHH:mm:ss.SSS",
-                )  as unknown as T[EntityKey<T>];
-              break;
-            case "date":
-              newModel[fieldName] = parseDateTime(rawModel[rawFieldName] as string, "YYYY-MM-DD")  as unknown as T[EntityKey<T>];
-              break;
-            case "time":
-              newModel[fieldName] = parseDateTime(rawModel[rawFieldName] as string, "HH:mm:ss.SSS")  as unknown as T[EntityKey<T>];
-              break;
-            default:
-              newModel[fieldName] = rawModel[rawFieldName]  as unknown as T[EntityKey<T>];
-          }
-        });
-      return newModel as T;
-    });
+    return datas[0] as Awaited<T> extends Array<any> ? Awaited<T>[number] : Awaited<T>;
   }
 
   /**
    * 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<T extends object | unknown>(query: string): Promise<T[]> {
+  async executeRawSQL<T extends object | unknown>(query: string, params?: unknown[]): Promise<T[]> {
     if (this.options.logRawSqlQuery) {
       console.debug("Executing raw SQL: " + query);
     }
-    const sqlStatement = await sql.prepare<T>(query).execute();
-    return sqlStatement.rows as T[];
+    const sqlStatement = sql.prepare<T>(query);
+    if (params) {
+      sqlStatement.bindParams(...params);
+    }
+    const result = await sqlStatement.execute();
+    return result.rows as T[];
   }
 
   /**
    * 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: string, params?: SqlParameters[]): Promise<UpdateQueryResponse> {
+  async executeRawUpdateSQL(query: string, params?: unknown[]): Promise<UpdateQueryResponse> {
     const sqlStatement = sql.prepare<UpdateQueryResponse>(query);
     if (params) {
-      sqlStatement.bindParams(params);
+      sqlStatement.bindParams(...params);
     }
     const updateQueryResponseResults = await sqlStatement.execute();
     return updateQueryResponseResults.rows;

package/src/core/SystemTables.ts

@@ -0,0 +1,7 @@
+import { int, mysqlTable, timestamp, varchar } from "drizzle-orm/mysql-core/index";
+
+export const migrations = mysqlTable("__migrations", {
+  id: int("id").primaryKey().autoincrement(),
+  name: varchar("name", { length: 255 }).notNull(),
+  created_at: timestamp("created_at").defaultNow().notNull(),
+});

package/src/index.ts

@@ -3,7 +3,6 @@ import ForgeSQLORM from "./core/ForgeSQLORM";
 export * from "./core/ForgeSQLQueryBuilder";
 export * from "./core/ForgeSQLCrudOperations";
 export * from "./core/ForgeSQLSelectOperations";
-export * from "@mikro-orm/mysql";
-export * from "@mikro-orm/entity-generator";
+export * from "./utils/sqlUtils";
 
 export default ForgeSQLORM;

package/src/utils/sqlUtils.ts

@@ -1,30 +1,40 @@
 import moment from "moment";
-import { AnyString } from "@mikro-orm/core/typings";
-import {types} from "..";
+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 { 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";
 
-const wrapIfNeeded=(data:string, wrap:boolean):string => {
-  return wrap?`'${data}'`:data;
+/**
+ * Interface representing table metadata information
+ */
+export interface MetadataInfo {
+  /** The name of the table */
+  tableName: string;
+  /** Record of column names and their corresponding column definitions */
+  columns: Record<string, AnyColumn>;
+  /** Array of index builders */
+  indexes: AnyIndexBuilder[];
+  /** Array of check constraint builders */
+  checks: CheckBuilder[];
+  /** Array of foreign key builders */
+  foreignKeys: ForeignKeyBuilder[];
+  /** Array of primary key builders */
+  primaryKeys: PrimaryKeyBuilder[];
+  /** Array of unique constraint builders */
+  uniqueConstraints: UniqueConstraintBuilder[];
+  /** Array of all extra builders */
+  extras: any[];
 }
 
-export const transformValue = <U>(value: {
-  type: keyof typeof types | AnyString;
-  value: U;
-}, wrapValue: boolean = false): U => {
-  switch (value.type) {
-    case "text":
-    case "string":
-      return <U>wrapIfNeeded(`${value.value}`,wrapValue);
-    case "datetime":
-      return <U>wrapIfNeeded(`${moment(value.value as Date).format("YYYY-MM-DDTHH:mm:ss.SSS")}`,wrapValue);
-    case "date":
-      return <U>wrapIfNeeded(`${moment(value.value as Date).format("YYYY-MM-DD")}`, wrapValue);
-    case "time":
-      return <U>wrapIfNeeded(`${moment(value.value as Date).format("HH:mm:ss.SSS")}`,wrapValue);
-    default:
-      return value.value;
-  }
-};
-
+/**
+ * Parses a date string into a Date object using the specified format
+ * @param value - The date string to parse
+ * @param format - The format to use for parsing
+ * @returns Date object
+ */
 export const parseDateTime = (value: string, format: string): Date => {
   const m = moment(value, format, true);
   if (!m.isValid()) {
@@ -32,3 +42,125 @@ export const parseDateTime = (value: string, format: string): Date => {
   }
   return m.toDate();
 };
+
+/**
+ * Extracts the alias from a SQL query
+ * @param query - The SQL query to extract the alias from
+ * @returns The extracted alias or the original query if no alias found
+ */
+export function extractAlias(query: string): string {
+  const match = query.match(/\bas\s+(['"`]?)([\w*]+)\1$/i);
+  return match ? match[2] : query;
+}
+
+/**
+ * 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
+ */
+export function getPrimaryKeys<T extends AnyMySqlTable>(
+  table: T,
+): [string, AnyColumn][] | undefined {
+  const { columns, primaryKeys } = getTableMetadata(table);
+
+  // First try to find primary keys in columns
+  const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary) as [
+    string,
+    AnyColumn,
+  ][];
+
+  if (columnPrimaryKeys.length > 0) {
+    return columnPrimaryKeys;
+  }
+
+  // If no primary keys found in columns, check primary key builders
+  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
+    // Collect all primary key columns from all primary key builders
+    const primaryKeyColumns = new Set<[string, AnyColumn]>();
+
+    primaryKeys.forEach((primaryKeyBuilder) => {
+      // Get primary key columns from each builder
+      Object.entries(columns)
+        .filter(([, column]) => {
+          // @ts-ignore - PrimaryKeyBuilder has internal columns property
+          return primaryKeyBuilder.columns.includes(column);
+        })
+        .forEach(([name, column]) => {
+          primaryKeyColumns.add([name, column]);
+        });
+    });
+
+    const result = Array.from(primaryKeyColumns);
+    return result.length > 0 ? result : undefined;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extracts table metadata from the schema.
+ * @param {AnyMySqlTable} table - The table schema
+ * @returns {MetadataInfo} Object containing table metadata
+ */
+export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
+  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)"));
+
+  // Initialize builders arrays
+  const builders = {
+    indexes: [] as AnyIndexBuilder[],
+    checks: [] as CheckBuilder[],
+    foreignKeys: [] as ForeignKeyBuilder[],
+    primaryKeys: [] as PrimaryKeyBuilder[],
+    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[];
+      }
+      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 as any)[nameSymbol] : "",
+    columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},
+    ...builders,
+  };
+}

package/dist/core/ComplexQuerySchemaBuilder.d.ts

@@ -1,38 +0,0 @@
-import { EntitySchema, EntityProperty } from "..";
-import { ComplexQuerySchemaBuilder } from "./ForgeSQLQueryBuilder";
-export declare class DynamicEntity {
-    [key: string]: unknown;
-    /**
-     * 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.
-     */
-    getSchemaBySchemaField<TYPE>(field: EntityProperty): TYPE | undefined;
-    /**
-     * Retrieves a schema field by its alias.
-     * @param alias - The alias of the field.
-     * @returns The corresponding schema field or undefined if not found.
-     */
-    getSchemaByAliasField<TYPE>(alias: string): TYPE | undefined;
-}
-export declare class EntitySchemaBuilder<T> implements ComplexQuerySchemaBuilder<T> {
-    private entityClass;
-    private properties;
-    constructor(entityClass: new () => T);
-    /**
-     * 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.
-     */
-    addField<K>(field: Partial<EntityProperty<K>>, alias?: string): this;
-    /**
-     * Creates and initializes a new EntitySchema based on the added fields.
-     * @returns A new EntitySchema<T> instance.
-     */
-    createSchema(): EntitySchema<T>;
-}
-export declare class DynamicEntitySchemaBuilder extends EntitySchemaBuilder<DynamicEntity> {
-    constructor();
-}
-//# sourceMappingURL=ComplexQuerySchemaBuilder.d.ts.map

package/dist/core/ComplexQuerySchemaBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComplexQuerySchemaBuilder.d.ts","sourceRoot":"","sources":["../../src/core/ComplexQuerySchemaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAa,MAAM,IAAI,CAAC;AAC7D,OAAO,EAAC,yBAAyB,EAAC,MAAM,wBAAwB,CAAC;AAEjE,qBAAa,aAAa;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAEvB;;;;OAIG;IACH,sBAAsB,CAAC,IAAI,EAAE,KAAK,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS;IAIrE;;;;OAIG;IACH,qBAAqB,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;CAG/D;AAED,qBAAa,mBAAmB,CAAC,CAAC,CAAE,YAAW,yBAAyB,CAAC,CAAC,CAAC;IAG3D,OAAO,CAAC,WAAW;IAF/B,OAAO,CAAC,UAAU,CAAyC;gBAEvC,WAAW,EAAE,UAAU,CAAC;IAE5C;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAOpE;;;OAGG;IACH,YAAY,IAAI,YAAY,CAAC,CAAC,CAAC;CASlC;AAED,qBAAa,0BAA2B,SAAQ,mBAAmB,CAAC,aAAa,CAAC;;CAIjF"}

package/dist/knex/index.d.ts

@@ -1,4 +0,0 @@
-import knex from "@mikro-orm/knex";
-export * from "@mikro-orm/knex";
-export default knex;
-//# sourceMappingURL=index.d.ts.map

package/dist/knex/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/knex/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,iBAAiB,CAAC;AAEnC,cAAc,iBAAiB,CAAC;AAChC,eAAe,IAAI,CAAC"}

package/src/core/ComplexQuerySchemaBuilder.ts

@@ -1,63 +0,0 @@
-import { EntitySchema, EntityProperty, EntityKey } from "..";
-import {ComplexQuerySchemaBuilder} from "./ForgeSQLQueryBuilder";
-
-export class DynamicEntity {
-    [key: string]: unknown;
-
-    /**
-     * 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.
-     */
-    getSchemaBySchemaField<TYPE>(field: EntityProperty): TYPE | undefined {
-        return this[field.name] as TYPE | undefined;
-    }
-
-    /**
-     * Retrieves a schema field by its alias.
-     * @param alias - The alias of the field.
-     * @returns The corresponding schema field or undefined if not found.
-     */
-    getSchemaByAliasField<TYPE>(alias: string): TYPE | undefined {
-        return this[alias] as TYPE | undefined;
-    }
-}
-
-export class EntitySchemaBuilder<T> implements ComplexQuerySchemaBuilder<T> {
-    private properties: Record<string, EntityProperty<T>> = {};
-
-    constructor(private entityClass: new () => T) {}
-
-    /**
-     * 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.
-     */
-    addField<K>(field: Partial<EntityProperty<K>>, alias?: string): this {
-        const fieldName = alias || field.name;
-        const fieldNameType = fieldName as unknown as EntityKey<T>;
-        this.properties[fieldNameType] = { ...field, name: fieldNameType } as unknown as EntityProperty<T>;
-        return this;
-    }
-
-    /**
-     * Creates and initializes a new EntitySchema based on the added fields.
-     * @returns A new EntitySchema<T> instance.
-     */
-    createSchema(): EntitySchema<T> {
-        const es = new EntitySchema<T>({
-            class: this.entityClass,
-            // @ts-ignore
-            properties: this.properties,
-        });
-        es.init();
-        return es;
-    }
-}
-
-export class DynamicEntitySchemaBuilder extends EntitySchemaBuilder<DynamicEntity> {
-    constructor() {
-        super(DynamicEntity);
-    }
-}

package/src/knex/index.ts

@@ -1,4 +0,0 @@
-import knex from "@mikro-orm/knex";
-
-export * from "@mikro-orm/knex";
-export default knex;