forge-sql-orm 1.0.29 → 1.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-sql-orm",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "Mikro-ORM integration for Forge-SQL in Atlassian Forge applications.",
   "main": "dist/ForgeSQLORM.js",
   "module": "dist/ForgeSQLORM.mjs",
@@ -29,14 +29,14 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.22.0",
-    "@mikro-orm/cli": "^6.4.9",
-    "inquirer": "^12.4.3",
-    "@mikro-orm/entity-generator": "^6.4.9",
-    "@mikro-orm/reflection": "^6.4.9",
+    "@mikro-orm/cli": "^6.4.10",
+    "inquirer": "^12.5.0",
+    "@mikro-orm/entity-generator": "^6.4.10",
+    "@mikro-orm/reflection": "^6.4.10",
     "@typescript-eslint/eslint-plugin": "^8.26.1",
     "@typescript-eslint/parser": "^8.26.1",
-    "@vitest/coverage-v8": "^3.0.8",
-    "@vitest/ui": "^3.0.8",
+    "@vitest/coverage-v8": "^3.0.9",
+    "@vitest/ui": "^3.0.9",
     "eslint": "^9.22.0",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-import": "^2.31.0",
@@ -52,9 +52,9 @@
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
     "typescript-eslint": "^8.26.1",
-    "vite": "^6.2.1",
+    "vite": "^6.2.2",
     "vite-plugin-static-copy": "^2.3.0",
-    "vitest": "^3.0.8"
+    "vitest": "^3.0.9"
   },
   "license": "MIT",
   "author": "Vasyl Zakharchenko",
@@ -71,7 +71,7 @@
     "build": "npm run clean && vite build && npm run build:types",
     "build:types": "tsc --emitDeclarationOnly",
     "build:cli": "vite build --mode cli",
-    "dependency:fix": "node ./dist-cli/forgeSqlOrmCLI.js patch:mikroorm",
+    "dependency:fix": "npm run build:cli && node ./dist-cli/forgeSqlOrmCLI.js patch:mikroorm",
     "prepublish:npm": "npm run build:cli && npm run build",
     "publish:npm": "npm publish --access public"
   },
@@ -84,13 +84,14 @@
     "README.md"
   ],
   "dependencies": {
-    "@forge/resolver": "^1.6.7",
-    "@mikro-orm/core": "6.4.9",
-    "@mikro-orm/mysql": "6.4.9",
-    "moment": "^2.30.1"
+    "@forge/resolver": "^1.6.8",
+    "@mikro-orm/core": "6.4.10",
+    "@mikro-orm/mysql": "6.4.10",
+    "moment": "^2.30.1",
+    "uuid": "^11.1.0"
   },
   "peerDependencies": {
-    "@forge/sql": "^2.4.0"
+    "@forge/sql": "^2.4.1"
   },
   "bin": {
     "forge-sql-orm": "dist-cli/forgeSqlOrmCLI.js"

package/src/core/ComplexQuerySchemaBuilder.ts

@@ -0,0 +1,63 @@
+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/core/ForgeSQLORM.ts

@@ -31,9 +31,12 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
     entities: (EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[],
     options?: ForgeSqlOrmOptions,
   ) {
-    console.debug("Initializing ForgeSQLORM...");
 
     try {
+      const newOptions: ForgeSqlOrmOptions = options ?? { logRawSqlQuery: false, disableOptimisticLocking: false };
+      if (newOptions.logRawSqlQuery){
+        console.debug("Initializing ForgeSQLORM...");
+      }
       this.mikroORM = MikroORM.initSync({
         dbName: "inmemory",
         schemaGenerator: {
@@ -53,7 +56,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
         preferTs: false,
         debug: false,
       });
-      const newOptions: ForgeSqlOrmOptions = options ?? { logRawSqlQuery: false, disableOptimisticLocking: false };
+
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {

package/src/core/ForgeSQLQueryBuilder.ts

@@ -3,8 +3,9 @@ import type { EntityName, LoggingOptions, QBFilterQuery } from "..";
 import type { EntitySchema } from "@mikro-orm/core/metadata/EntitySchema";
 import type { QueryBuilder } from "@mikro-orm/knex/query";
 import type { Knex } from "knex";
-import { EntityKey } from "@mikro-orm/core";
+import {EntityKey, EntityProperty} from "@mikro-orm/core";
 import {SqlParameters} from "@forge/sql/out/sql-statement";
+import {DynamicEntity} from "./ComplexQuerySchemaBuilder";
 
 /**
  * Interface representing the main ForgeSQL operations.
@@ -70,6 +71,13 @@ export interface SchemaSqlForgeSql {
    */
   executeRawUpdateSQL(query: string, params?: SqlParameters[]): Promise<UpdateQueryResponse>;
 
+  /**
+   * 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>
 }
 
 /**
@@ -171,3 +179,19 @@ export interface QueryBuilderForgeSql {
    */
   getKnex(): Knex<any, any[]>;
 }
+
+export interface ComplexQuerySchemaBuilder<T> {
+  /**
+   * Adds a field from an entity schema to the builder.
+   * @param field - The entity property to be added.
+   * @param alias - (Optional) Alias for the field name.
+   * @returns The updated instance of the builder.
+   */
+  addField<K>(field: Partial<EntityProperty<K>>, alias?: string): this
+
+  /**
+   * Creates and returns a new entity schema based on the added fields.
+   * @returns A new EntitySchema<T> instance.
+   */
+  createSchema(): EntitySchema<T>;
+}

package/src/core/ForgeSQLSelectOperations.ts

@@ -1,15 +1,27 @@
 import { sql, UpdateQueryResponse } from "@forge/sql";
 import type { EntitySchema } from "@mikro-orm/core/metadata/EntitySchema";
 import { parseDateTime } from "../utils/sqlUtils";
-import { ForgeSqlOrmOptions, SchemaSqlForgeSql } from "./ForgeSQLQueryBuilder";
+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";
 
 export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
-  private readonly options: ForgeSqlOrmOptions;
+    private readonly options: ForgeSqlOrmOptions;
 
-  constructor(options: ForgeSqlOrmOptions) {
-    this.options = options;
-  }
+    constructor(options: ForgeSqlOrmOptions) {
+        this.options = options;
+    }
+
+    /**
+     * 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();
+    }
 
   async executeSchemaSQLOnlyOne<T extends object>(query: string, schema: EntitySchema<T>): Promise<T|undefined> {
         const results = await this.executeSchemaSQL(query, schema);
@@ -34,7 +46,7 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
 
     return datas.map((r) => {
       const rawModel = r as Record<string, unknown>;
-      const newModel: Record<string, unknown> = {};
+        const newModel = Object.create(schema.meta.prototype) as T;
 
       schema.meta.props
         .filter((p) => p.kind === "scalar")
@@ -42,22 +54,21 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
           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");
+              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");
+              newModel[fieldName] = parseDateTime(rawModel[rawFieldName] as string, "HH:mm:ss.SSS")  as unknown as T[EntityKey<T>];
               break;
             default:
-              newModel[fieldName] = rawModel[rawFieldName];
+              newModel[fieldName] = rawModel[rawFieldName]  as unknown as T[EntityKey<T>];
           }
         });
       return newModel as T;

package/src/utils/sqlUtils.ts

@@ -1,6 +1,6 @@
-import { types } from "@mikro-orm/core/types";
 import moment from "moment";
 import { AnyString } from "@mikro-orm/core/typings";
+import {types} from "..";
 
 const wrapIfNeeded=(data:string, wrap:boolean):string => {
   return wrap?`'${data}'`:data;