@mikro-orm/core 7.0.0-dev.60 → 7.0.0-dev.62

package/MikroORM.js

@@ -39,7 +39,6 @@ export class MikroORM {
      * - no support for folder based discovery
      */
     constructor(options) {
-        ConfigurationLoader.registerDotenv(options);
         const env = ConfigurationLoader.loadEnvironmentVarsSync();
         const coreVersion = ConfigurationLoader.checkPackageVersion();
         options = Utils.merge(options, env);

package/decorators/Embeddable.d.ts

@@ -1,6 +1,8 @@
 import type { AnyString, Dictionary, EntityClass } from '../typings.js';
 export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
 export interface EmbeddableOptions<T> {
+    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
+    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
     discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;

package/decorators/Entity.d.ts

@@ -16,6 +16,8 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     discriminatorValue?: number | string;
     /**	Enforce use of constructor when creating managed entity instances. */
     forceConstructor?: boolean;
+    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
+    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
     /** Specify comment to table. (SQL only) */
     comment?: string;
     /**	Marks entity as abstract, such entities are inlined during discovery. */

package/entity/ArrayCollection.js

@@ -32,9 +32,7 @@ export class ArrayCollection {
         if (this.items.size === 0) {
             return [];
         }
-        const meta = this.property.targetMeta;
-        const args = meta.toJsonParams.map(() => undefined);
-        return this.map(item => wrap(item).toJSON(...args));
+        return this.map(item => wrap(item).toJSON());
     }
     toJSON() {
         return this.toArray();

package/entity/EntityFactory.js

@@ -60,7 +60,7 @@ export class EntityFactory {
         wrapped.__initialized = options.initialized;
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
             const tmp = { ...data };
-            meta.constructorParams.forEach(prop => delete tmp[prop]);
+            meta.constructorParams?.forEach(prop => delete tmp[prop]);
             this.hydrate(entity, meta2, tmp, options);
             // since we now process only a copy of the `data` via hydrator, but later we register the state with the full snapshot,
             // we need to go through all props with custom types that have `ensureComparable: true` and ensure they are comparable
@@ -299,32 +299,37 @@ export class EntityFactory {
      * returns parameters for entity constructor, creating references from plain ids
      */
     extractConstructorParams(meta, data, options) {
+        if (!meta.constructorParams) {
+            return [data];
+        }
         return meta.constructorParams.map(k => {
-            if (meta.properties[k] && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
-                const pk = Reference.unwrapReference(data[k]);
-                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema, true);
+            const prop = meta.properties[k];
+            const value = data[k];
+            if (prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && value) {
+                const pk = Reference.unwrapReference(value);
+                const entity = this.unitOfWork.getById(prop.type, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }
-                if (Utils.isEntity(data[k])) {
-                    return data[k];
+                if (Utils.isEntity(value)) {
+                    return value;
                 }
-                const nakedPk = Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
-                if (Utils.isObject(data[k]) && !nakedPk) {
-                    return this.create(meta.properties[k].type, data[k], options);
+                const nakedPk = Utils.extractPK(value, prop.targetMeta, true);
+                if (Utils.isObject(value) && !nakedPk) {
+                    return this.create(prop.type, value, options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                const target = this.createReference(meta.properties[k].type, nakedPk, rest);
-                return Reference.wrapReference(target, meta.properties[k]);
+                const target = this.createReference(prop.type, nakedPk, rest);
+                return Reference.wrapReference(target, prop);
             }
-            if (meta.properties[k]?.kind === ReferenceKind.EMBEDDED && data[k]) {
+            if (prop?.kind === ReferenceKind.EMBEDDED && value) {
                 /* v8 ignore next 3 */
-                if (Utils.isEntity(data[k])) {
-                    return data[k];
+                if (Utils.isEntity(value)) {
+                    return value;
                 }
-                return this.createEmbeddable(meta.properties[k].type, data[k], options);
+                return this.createEmbeddable(prop.type, value, options);
             }
-            if (!meta.properties[k]) {
+            if (!prop) {
                 const tmp = { ...data };
                 for (const prop of meta.props) {
                     if (!options.convertCustomTypes || !prop.customType || tmp[prop.name] == null) {
@@ -339,10 +344,10 @@ export class EntityFactory {
                 }
                 return tmp;
             }
-            if (options.convertCustomTypes && meta.properties[k].customType && data[k] != null) {
-                return meta.properties[k].customType.convertToJSValue(data[k], this.platform);
+            if (options.convertCustomTypes && prop.customType && value != null) {
+                return prop.customType.convertToJSValue(value, this.platform);
             }
-            return data[k];
+            return value;
         });
     }
     get unitOfWork() {

package/entity/EntityHelper.js

@@ -32,7 +32,7 @@ export class EntityHelper {
         const prototype = meta.prototype;
         if (!prototype.toJSON) { // toJSON can be overridden
             prototype.toJSON = function (...args) {
-                return EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
+                return EntityTransformer.toObject(this, ...args);
             };
         }
     }

package/metadata/EntitySchema.js

@@ -157,9 +157,7 @@ export class EntitySchema {
         this._meta.prototype = proto.prototype;
         this._meta.className = proto.name;
         if (!sameClass || !this._meta.constructorParams) {
-            const tokens = Utils.tokenize(proto);
-            this._meta.constructorParams = Utils.getParamNames(tokens, 'constructor');
-            this._meta.toJsonParams = Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
+            this._meta.constructorParams = Utils.getConstructorParams(proto);
         }
         if (!this.internal) {
             EntitySchema.REGISTRY.set(proto, this);

package/metadata/MetadataDiscovery.js

@@ -731,12 +731,9 @@ export class MetadataDiscovery {
         Utils.keys(base.hooks).forEach(type => {
             meta.hooks[type] = Utils.unique([...base.hooks[type], ...(meta.hooks[type] || [])]);
         });
-        if (meta.constructorParams.length === 0 && base.constructorParams.length > 0) {
+        if ((meta.constructorParams?.length ?? 0) === 0 && (base.constructorParams?.length ?? 0) > 0) {
             meta.constructorParams = [...base.constructorParams];
         }
-        if (meta.toJsonParams.length === 0 && base.toJsonParams.length > 0) {
-            meta.toJsonParams = [...base.toJsonParams];
-        }
         return order;
     }
     initPolyEmbeddables(embeddedProp, discovered, visited = new Set()) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.60",
+  "version": "7.0.0-dev.62",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -52,9 +52,7 @@
     "access": "public"
   },
   "dependencies": {
-    "dotenv": "17.2.3",
-    "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.60",
+    "mikro-orm": "7.0.0-dev.62",
     "reflect-metadata": "0.2.2"
   },
   "peerDependencies": {

package/typings.d.ts

@@ -451,9 +451,8 @@ export interface EntityMetadata<T = any> {
     discriminatorValue?: number | string;
     discriminatorMap?: Dictionary<string>;
     embeddable: boolean;
-    constructorParams: EntityKey<T>[];
+    constructorParams?: (keyof T)[];
     forceConstructor: boolean;
-    toJsonParams: string[];
     extends: string;
     collection: string;
     path: string;

package/utils/ConfigurationLoader.d.ts

@@ -25,7 +25,6 @@ export declare class ConfigurationLoader {
      * This method is used only in CLI context.
      */
     static registerTypeScriptSupport(configPath?: string, tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto'): Promise<boolean>;
-    static registerDotenv<D extends IDatabaseDriver>(options: Options<D>): void;
     static loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
     static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getORMPackages(): Set<string>;

package/utils/ConfigurationLoader.js

@@ -1,4 +1,3 @@
-import dotenv from 'dotenv';
 import { realpathSync } from 'node:fs';
 import { colors } from '../logging/colors.js';
 import { Configuration } from './Configuration.js';
@@ -185,17 +184,6 @@ export class ConfigurationLoader {
         console.warn('Neither `swc`, `tsx`, `jiti` nor `tsimp` found in the project dependencies, support for working with TypeScript files might not work. To use `swc`, you need to install both `@swc-node/register` and `@swc/core`.');
         return false;
     }
-    static registerDotenv(options) {
-        const path = process.env.MIKRO_ORM_ENV ?? ((options.baseDir ?? process.cwd()) + '/.env');
-        const env = {};
-        dotenv.config({ path, processEnv: env, quiet: true });
-        // only propagate known env vars
-        for (const key of Object.keys(env)) {
-            if (key.startsWith('MIKRO_ORM_')) {
-                process.env[key] ??= env[key]; // respect user provided values
-            }
-        }
-    }
     static async loadEnvironmentVars() {
         const ret = this.loadEnvironmentVarsSync();
         // only to keep some sort of back compatibility with those using env vars only, to support `MIKRO_ORM_TYPE`

package/utils/Utils.d.ts

@@ -2,7 +2,6 @@ import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadat
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { ScalarReference } from '../entity/Reference.js';
-export declare const ObjectBindingPattern: unique symbol;
 export declare function compareObjects(a: any, b: any): boolean;
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;
 export declare function compareBooleans(a: unknown, b: unknown): boolean;
@@ -101,26 +100,11 @@ export declare class Utils {
      */
     static renameKey<T>(payload: T, from: string | keyof T, to: string): void;
     /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
+     * Returns array of functions argument names. Uses basic regex for source code analysis, might not work with advanced syntax.
      */
-    static tokenize(func: {
+    static getConstructorParams(func: {
         toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[]): {
-        type: string;
-        value: string;
-    }[];
-    /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
-     */
-    static getParamNames(func: {
-        toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[], methodName?: string): string[];
+    }): string[] | undefined;
     /**
      * Checks whether the argument looks like primary key (string, number or ObjectId).
      */

package/utils/Utils.js

@@ -3,11 +3,9 @@ import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:pa
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, globSync, statSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { tokenize } from 'esprima';
 import { clone } from './clone.js';
 import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, PlainObject, QueryOperator, ReferenceKind, } from '../enums.js';
 import { helper } from '../entity/wrap.js';
-export const ObjectBindingPattern = Symbol('ObjectBindingPattern');
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -357,53 +355,37 @@ export class Utils {
         }
     }
     /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
+     * Returns array of functions argument names. Uses basic regex for source code analysis, might not work with advanced syntax.
      */
-    static tokenize(func) {
-        if (Array.isArray(func)) {
-            return func;
-        }
-        /* v8 ignore next 5 */
-        try {
-            return tokenize(func.toString(), { tolerant: true });
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
-     */
-    static getParamNames(func, methodName) {
-        const ret = [];
-        const tokens = this.tokenize(func);
-        let inside = 0;
-        let currentBlockStart = 0;
-        for (let i = 0; i < tokens.length; i++) {
-            const token = tokens[i];
-            if (token.type === 'Identifier' && token.value === methodName) {
-                inside = 1;
-                currentBlockStart = i;
-                continue;
+    static getConstructorParams(func) {
+        const source = func.toString();
+        const i = source.indexOf('constructor');
+        if (i === -1) {
+            return undefined;
+        }
+        const start = source.indexOf('(', i);
+        if (start === -1) {
+            return undefined;
+        }
+        let depth = 0;
+        let end = start;
+        for (; end < source.length; end++) {
+            if (source[end] === '(') {
+                depth++;
             }
-            if (inside === 1 && token.type === 'Punctuator' && token.value === '(') {
-                inside = 2;
-                currentBlockStart = i;
-                continue;
+            if (source[end] === ')') {
+                depth--;
             }
-            if (inside === 2 && token.type === 'Punctuator' && token.value === ')') {
+            if (depth === 0) {
                 break;
             }
-            if (inside === 2 && token.type === 'Punctuator' && token.value === '{' && i === currentBlockStart + 1) {
-                ret.push(ObjectBindingPattern);
-                i = tokens.findIndex((t, idx) => idx > i + 2 && t.type === 'Punctuator' && t.value === '}');
-                continue;
-            }
-            if (inside === 2 && token.type === 'Identifier') {
-                ret.push(token.value);
-            }
         }
-        return ret;
+        const raw = source.slice(start + 1, end);
+        return raw
+            .split(',')
+            .map(s => s.trim().replace(/=.*$/, '').trim())
+            .filter(Boolean)
+            .map(raw => raw.startsWith('{') && raw.endsWith('}') ? '' : raw);
     }
     /**
      * Checks whether the argument looks like primary key (string, number or ObjectId).