@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/utils/Utils.js

@@ -1,14 +1,7 @@
-import { createRequire } from 'node:module';
-import { glob, isDynamicPattern } from 'tinyglobby';
-import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import { tokenize } from 'esprima';
 import { clone } from './clone.js';
-import { ARRAY_OPERATORS, JSON_KEY_OPERATORS, GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
+import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
-export const ObjectBindingPattern = Symbol('ObjectBindingPattern');
+import { Raw } from './RawQueryFragment.js';
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -32,7 +25,7 @@ export function compareObjects(a, b) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return a.sql === b.sql && compareArrays(a.params, b.params);
     }
-    if ((a instanceof Date && b instanceof Date)) {
+    if (a instanceof Date && b instanceof Date) {
         const timeA = a.getTime();
         const timeB = b.getTime();
         if (isNaN(timeA) || isNaN(timeB)) {
@@ -40,9 +33,8 @@ export function compareObjects(a, b) {
         }
         return timeA === timeB;
     }
-    /* v8 ignore next 9 */
+    /* v8 ignore next */
     if ((typeof a === 'function' && typeof b === 'function') ||
-        (typeof a === 'object' && a.client && ['Ref', 'Raw'].includes(a.constructor.name) && typeof b === 'object' && b.client && ['Ref', 'Raw'].includes(b.constructor.name)) || // knex qb
         (a instanceof RegExp && b instanceof RegExp) ||
         (a instanceof String && b instanceof String) ||
         (a instanceof Number && b instanceof Number)) {
@@ -118,7 +110,7 @@ export function equals(a, b) {
 const equalsFn = equals;
 export function parseJsonSafe(value) {
     if (typeof value === 'string') {
-        /* v8 ignore next 6 */
+        /* v8 ignore next */
         try {
             return JSON.parse(value);
         }
@@ -131,50 +123,13 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    /**
-     * Checks if the argument is not undefined
-     */
-    static isDefined(data) {
-        return typeof data !== 'undefined';
-    }
+    static #ORM_VERSION = '7.0.0-dev.331';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
     static isObject(o) {
         return !!o && typeof o === 'object' && !Array.isArray(o);
     }
-    /**
-     * Relation decorators allow using two signatures
-     * - using first parameter as options object
-     * - using all parameters
-     *
-     * This function validates those two ways are not mixed and returns the final options object.
-     * If the second way is used, we always consider the last parameter as options object.
-     * @internal
-     */
-    static processDecoratorParameters(params) {
-        const keys = Object.keys(params);
-        const values = Object.values(params);
-        if (!Utils.isPlainObject(values[0])) {
-            const lastKey = keys[keys.length - 1];
-            const last = params[lastKey];
-            delete params[lastKey];
-            return { ...last, ...params };
-        }
-        // validate only first parameter is used if its an option object
-        const empty = (v) => v == null || (Utils.isPlainObject(v) && !Utils.hasObjectKeys(v));
-        if (values.slice(1).some(v => !empty(v))) {
-            throw new Error('Mixing first decorator parameter as options object with other parameters is forbidden. ' +
-                'If you want to use the options parameter at first position, provide all options inside it.');
-        }
-        return values[0];
-    }
-    /**
-     * Checks if the argument is instance of `Object`, but not one of the blacklisted types. Returns false for arrays.
-     */
-    static isNotObject(o, not) {
-        return this.isObject(o) && !not.some(cls => o instanceof cls);
-    }
     /**
      * Removes `undefined` properties (recursively) so they are not saved as nulls
      */
@@ -222,18 +177,6 @@ export class Utils {
         }
         return false;
     }
-    /**
-     * Checks if the argument is string
-     */
-    static isString(s) {
-        return typeof s === 'string';
-    }
-    /**
-     * Checks if the argument is number
-     */
-    static isNumber(s) {
-        return typeof s === 'number';
-    }
     /**
      * Checks if arguments are deeply (but not strictly) equal.
      */
@@ -279,7 +222,7 @@ export class Utils {
                         target[key] = Utils.copy(value);
                         continue;
                     }
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if (!(key in target)) {
                         Object.assign(target, { [key]: {} });
                     }
@@ -292,30 +235,6 @@ export class Utils {
         }
         return Utils._merge(target, sources, ignoreUndefined);
     }
-    static getRootEntity(metadata, meta) {
-        const base = meta.extends && metadata.find(Utils.className(meta.extends));
-        if (!base || base === meta) { // make sure we do not fall into infinite loop
-            return meta;
-        }
-        const root = Utils.getRootEntity(metadata, base);
-        if (root.discriminatorColumn) {
-            return root;
-        }
-        return meta;
-    }
-    /**
-     * Computes difference between two objects, ignoring items missing in `b`.
-     */
-    static diff(a, b) {
-        const ret = {};
-        for (const k of Object.keys(b)) {
-            if (Utils.equals(a[k], b[k])) {
-                continue;
-            }
-            ret[k] = b[k];
-        }
-        return ret;
-    }
     /**
      * Creates deep copy of given object.
      */
@@ -356,53 +275,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 });
+    static getConstructorParams(func) {
+        const source = func.toString();
+        const i = source.indexOf('constructor');
+        if (i === -1) {
+            return undefined;
         }
-        catch {
-            return [];
+        const start = source.indexOf('(', i);
+        if (start === -1) {
+            return undefined;
         }
-    }
-    /**
-     * 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;
+        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).
@@ -415,7 +318,7 @@ export class Utils {
             return true;
         }
         if (Utils.isObject(key)) {
-            if (key.constructor && key.constructor.name.toLowerCase() === 'objectid') {
+            if (key.constructor?.name === 'ObjectId') {
                 return true;
             }
             if (!Utils.isPlainObject(key) && !Utils.isEntity(key, true)) {
@@ -445,7 +348,7 @@ export class Utils {
             if (meta.compositePK) {
                 return this.getCompositeKeyValue(data, meta);
             }
-            return data[meta.primaryKeys[0]] || data[meta.serializedPrimaryKey] || null;
+            return data[meta.primaryKeys[0]] ?? data[meta.serializedPrimaryKey] ?? null;
         }
         return null;
     }
@@ -471,7 +374,8 @@ export class Utils {
         return Utils.getPrimaryKeyHash(pks);
     }
     static getPrimaryKeyHash(pks) {
-        return pks.map(pk => {
+        return pks
+            .map(pk => {
             if (Buffer.isBuffer(pk)) {
                 return pk.toString('hex');
             }
@@ -479,14 +383,14 @@ export class Utils {
                 return pk.toISOString();
             }
             return pk;
-        }).join(this.PK_SEPARATOR);
+        })
+            .join(this.PK_SEPARATOR);
     }
     static splitPrimaryKeys(key) {
         return key.split(this.PK_SEPARATOR);
     }
-    // TODO v7: remove support for `primaryKeys: string[]`
-    static getPrimaryKeyValues(entity, primaryKeys, allowScalar = false, convertCustomTypes = false) {
-        /* v8 ignore next 3 */
+    static getPrimaryKeyValues(entity, meta, allowScalar = false, convertCustomTypes = false) {
+        /* v8 ignore next */
         if (entity == null) {
             return entity;
         }
@@ -496,15 +400,13 @@ export class Utils {
             }
             return val;
         }
-        const meta = Array.isArray(primaryKeys) ? undefined : primaryKeys;
-        primaryKeys = Array.isArray(primaryKeys) ? primaryKeys : meta.primaryKeys;
         let pk;
         if (Utils.isEntity(entity, true)) {
             pk = helper(entity).getPrimaryKey(convertCustomTypes);
         }
         else {
-            pk = primaryKeys.reduce((o, pk) => {
-                const targetMeta = meta?.properties[pk].targetMeta;
+            pk = meta.primaryKeys.reduce((o, pk) => {
+                const targetMeta = meta.properties[pk].targetMeta;
                 if (targetMeta && Utils.isPlainObject(entity[pk])) {
                     o[pk] = Utils.getPrimaryKeyValues(entity[pk], targetMeta, allowScalar, convertCustomTypes);
                 }
@@ -514,12 +416,12 @@ export class Utils {
                 return o;
             }, {});
         }
-        if (primaryKeys.length > 1) {
+        if (meta.primaryKeys.length > 1) {
             return toArray(pk);
         }
         if (allowScalar) {
             if (Utils.isPlainObject(pk)) {
-                return pk[primaryKeys[0]];
+                return pk[meta.primaryKeys[0]];
             }
             return pk;
         }
@@ -603,12 +505,6 @@ export class Utils {
     static isScalarReference(data, allowReference = false) {
         return typeof data === 'object' && data?.__scalarReference;
     }
-    /**
-     * Checks whether the argument is ObjectId instance
-     */
-    static isObjectID(key) {
-        return Utils.isObject(key) && key.constructor && key.constructor.name.toLowerCase() === 'objectid';
-    }
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
      */
@@ -633,61 +529,26 @@ export class Utils {
     static extractChildElements(items, prefix, allSymbol) {
         return items
             .filter(field => field === allSymbol || field.startsWith(`${prefix}.`))
-            .map(field => field === allSymbol ? allSymbol : field.substring(prefix.length + 1));
+            .map(field => (field === allSymbol ? allSymbol : field.substring(prefix.length + 1)));
     }
     /**
      * Tries to detect TypeScript support.
      */
     static detectTypeScriptSupport() {
-        /* v8 ignore next 7 */
-        return process.argv[0].endsWith('ts-node') // running via ts-node directly
-            || !!process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS // forced explicitly or enabled via `registerTypeScriptSupport()`
-            || !!process.env.TS_JEST // check if ts-jest is used (works only with v27.0.4+)
-            || !!process.env.VITEST // check if vitest is used
-            || !!process.versions.bun // check if bun is used
-            || process.argv.slice(1).some(arg => arg.match(/\.([mc]?ts|tsx)$/)) // executing `.ts` file
-            || process.execArgv.some(arg => {
-                return arg.includes('ts-node') // check for ts-node loader
-                    || arg.includes('@swc-node/register') // check for swc-node/register loader
-                    || arg.includes('node_modules/tsx/'); // check for tsx loader
-            });
-    }
-    /**
-     * Uses some dark magic to get source path to caller where decorator is used.
-     * Analyses stack trace of error created inside the function call.
-     */
-    static lookupPathFromDecorator(name, stack) {
-        // use some dark magic to get source path to caller
-        stack = stack || new Error().stack.split('\n');
-        // In some situations (e.g. swc 1.3.4+), the presence of a source map can obscure the call to
-        // __decorate(), replacing it with the constructor name. To support these cases we look for
-        // Reflect.decorate() as well. Also when babel is used, we need to check
-        // the `_applyDecoratedDescriptor` method instead.
-        let line = stack.findIndex(line => line.match(/__decorate|Reflect\.decorate|_applyDecoratedDescriptor/));
-        // bun does not have those lines at all, only the DecorateProperty/DecorateConstructor,
-        // but those are also present in node, so we need to check this only if they weren't found.
-        if (line === -1) {
-            // here we handle bun which stack is different from nodejs so we search for reflect-metadata
-            // Different bun versions might have different stack traces. The "last index" works for both 1.2.6 and 1.2.7.
-            const reflectLine = stack.findLastIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
-            if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
-                return name;
-            }
-            line = reflectLine + 2;
-        }
-        if (stack[line].includes('Reflect.decorate')) {
-            line++;
-        }
-        if (Utils.normalizePath(stack[line]).includes('node_modules/tslib/tslib')) {
-            line++;
-        }
-        try {
-            const re = stack[line].match(/\(.+\)/i) ? /\((.*):\d+:\d+\)/ : /at\s*(.*):\d+:\d+$/;
-            return Utils.normalizePath(stack[line].match(re)[1]);
-        }
-        catch {
-            return name;
-        }
+        /* v8 ignore next */
+        const process = globalThis.process ?? {};
+        /* v8 ignore next */
+        return (process.argv?.[0]?.endsWith('ts-node') || // running via ts-node directly
+            !!process.env?.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS || // forced explicitly or enabled via `registerTypeScriptSupport()`
+            !!process.env?.TS_JEST || // check if ts-jest is used
+            !!process.env?.VITEST || // check if vitest is used
+            !!process.versions?.bun || // check if bun is used
+            process.argv?.slice(1).some(arg => /\.([mc]?ts|tsx)$/.exec(arg)) || // executing `.ts` file
+            process.execArgv?.some(arg => {
+                return (arg.includes('ts-node') || // check for ts-node loader
+                    arg.includes('@swc-node/register') || // check for swc-node/register loader
+                    arg.includes('node_modules/tsx/')); // check for tsx loader
+            }));
     }
     /**
      * Gets the type of the argument.
@@ -698,22 +559,23 @@ export class Utils {
             return simple;
         }
         const objectType = Object.prototype.toString.call(value);
-        const type = objectType.match(/\[object (\w+)]/)[1];
+        const type = /^\[object (.+)]$/.exec(objectType)[1];
         if (type === 'Uint8Array') {
             return 'Buffer';
         }
-        return ['Date', 'Buffer', 'RegExp'].includes(type) ? type : type.toLowerCase();
+        return type;
     }
     /**
      * Checks whether the value is POJO (e.g. `{ foo: 'bar' }`, and not instance of `Foo`)
      */
     static isPlainObject(value) {
-        return (value !== null
-            && typeof value === 'object'
-            && typeof value.constructor === 'function'
-            && (Object.hasOwn(value.constructor.prototype, 'isPrototypeOf') || Object.getPrototypeOf(value.constructor.prototype) === null))
-            || (value && Object.getPrototypeOf(value) === null)
-            || value instanceof PlainObject;
+        return ((value !== null &&
+            typeof value === 'object' &&
+            typeof value.constructor === 'function' &&
+            (Object.hasOwn(value.constructor.prototype, 'isPrototypeOf') ||
+                Object.getPrototypeOf(value.constructor.prototype) === null)) ||
+            (value && Object.getPrototypeOf(value) === null) ||
+            value instanceof PlainObject);
     }
     /**
      * Executes the `cb` promise serially on every element of the `items` array and returns array of resolved values.
@@ -728,67 +590,14 @@ export class Utils {
     static isCollection(item) {
         return item?.__collection;
     }
-    static fileURLToPath(url) {
-        // expose `fileURLToPath` on Utils so that it can be properly mocked in tests
-        return fileURLToPath(url);
-    }
-    /**
-     * Resolves and normalizes a series of path parts relative to each preceding part.
-     * If any part is a `file:` URL, it is converted to a local path. If any part is an
-     * absolute path, it replaces preceding paths (similar to `path.resolve` in NodeJS).
-     * Trailing directory separators are removed, and all directory separators are converted
-     * to POSIX-style separators (`/`).
-     */
-    static normalizePath(...parts) {
-        let start = 0;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            if (isAbsolute(part)) {
-                start = i;
-            }
-            else if (part.startsWith('file:')) {
-                start = i;
-                parts[i] = Utils.fileURLToPath(part);
-            }
+    // FNV-1a 64-bit
+    static hash(data, length) {
+        let h1 = 0xcbf29ce484222325n;
+        for (let i = 0; i < data.length; i++) {
+            h1 ^= BigInt(data.charCodeAt(i));
+            h1 = (h1 * 0x100000001b3n) & 0xffffffffffffffffn;
         }
-        if (start > 0) {
-            parts = parts.slice(start);
-        }
-        let path = parts.join('/').replace(/\\/g, '/').replace(/\/$/, '');
-        path = normalize(path).replace(/\\/g, '/');
-        return (path.match(/^[/.]|[a-zA-Z]:/) || path.startsWith('!')) ? path : './' + path;
-    }
-    /**
-     * Determines the relative path between two paths. If either path is a `file:` URL,
-     * it is converted to a local path.
-     */
-    static relativePath(path, relativeTo) {
-        if (!path) {
-            return path;
-        }
-        path = Utils.normalizePath(path);
-        if (path.startsWith('.')) {
-            return path;
-        }
-        path = relative(Utils.normalizePath(relativeTo), path);
-        return Utils.normalizePath(path);
-    }
-    /**
-     * Computes the absolute path to for the given path relative to the provided base directory.
-     * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
-     */
-    static absolutePath(path, baseDir = process.cwd()) {
-        if (!path) {
-            return Utils.normalizePath(baseDir);
-        }
-        if (!isAbsolute(path) && !path.startsWith('file://')) {
-            path = baseDir + '/' + path;
-        }
-        return Utils.normalizePath(path);
-    }
-    static hash(data, length, algorithm) {
-        const hashAlgorithm = algorithm || 'sha256';
-        const hash = createHash(hashAlgorithm).update(data).digest('hex');
+        const hash = h1.toString(16).padStart(16, '0');
         if (length) {
             return hash.substring(0, length);
         }
@@ -804,7 +613,7 @@ export class Utils {
     }
     static findDuplicates(items) {
         return items.reduce((acc, v, i, arr) => {
-            return arr.indexOf(v) !== i && acc.indexOf(v) === -1 ? acc.concat(v) : acc;
+            return arr.indexOf(v) !== i && !acc.includes(v) ? acc.concat(v) : acc;
         }, []);
     }
     static removeDuplicates(items) {
@@ -820,13 +629,6 @@ export class Utils {
     static randomInt(min, max) {
         return Math.round(Math.random() * (max - min)) + min;
     }
-    static async pathExists(path, options = {}) {
-        if (isDynamicPattern(path)) {
-            const found = await glob(path, options);
-            return found.length > 0;
-        }
-        return this.pathExistsSync(path);
-    }
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -834,17 +636,20 @@ export class Utils {
         const keys = Object.keys(target);
         const values = Object.values(target);
         const numeric = !!values.find(v => typeof v === 'number');
-        const constEnum = values.length % 2 === 0 // const enum will have even number of items
-            && values.slice(0, values.length / 2).every(v => typeof v === 'string') // first half are strings
-            && values.slice(values.length / 2).every(v => typeof v === 'number') // second half are numbers
-            && this.equals(keys, values.slice(values.length / 2).concat(values.slice(0, values.length / 2)).map(v => '' + v)); // and when swapped, it will match the keys
+        const constEnum = values.length % 2 === 0 && // const enum will have even number of items
+            values.slice(0, values.length / 2).every(v => typeof v === 'string') && // first half are strings
+            values.slice(values.length / 2).every(v => typeof v === 'number') && // second half are numbers
+            this.equals(keys, values
+                .slice(values.length / 2)
+                .concat(values.slice(0, values.length / 2))
+                .map(v => '' + v)); // and when swapped, it will match the keys
         if (numeric || constEnum) {
             return values.filter(val => !keys.includes(val));
         }
         return values;
     }
-    static flatten(arrays) {
-        return [].concat.apply([], arrays);
+    static flatten(arrays, deep) {
+        return arrays.flatMap(v => (deep && Array.isArray(v) ? this.flatten(v, true) : v));
     }
     static isOperator(key, includeGroupOperators = true) {
         if (!includeGroupOperators) {
@@ -852,15 +657,6 @@ export class Utils {
         }
         return key in GroupOperator || key in QueryOperator;
     }
-    static isGroupOperator(key) {
-        return key in GroupOperator;
-    }
-    static isArrayOperator(key) {
-        return ARRAY_OPERATORS.includes(key);
-    }
-    static isJsonKeyOperator(key) {
-        return JSON_KEY_OPERATORS.includes(key);
-    }
     static hasNestedKey(object, key) {
         if (!object) {
             return false;
@@ -873,74 +669,17 @@ export class Utils {
         }
         return false;
     }
-    static getGlobalStorage(namespace) {
-        const key = `mikro-orm-${namespace}`;
-        globalThis[key] = globalThis[key] || {};
-        return globalThis[key];
-    }
-    /**
-     * Require a module from a specific location
-     * @param id The module to require
-     * @param [from] Location to start the node resolution
-     */
-    static requireFrom(id, from = process.cwd()) {
-        if (!extname(from)) {
-            from = join(from, '__fake.js');
-        }
-        return createRequire(resolve(from))(id);
-    }
-    /**
-     * Resolve path to a module.
-     * @param id The module to require
-     * @param [from] Location to start the node resolution
-     */
-    static resolveModulePath(id, from = process.cwd()) {
-        if (!extname(from)) {
-            from = join(from, '__fake.js');
-        }
-        const path = Utils.normalizePath(createRequire(resolve(from)).resolve(id));
-        const parts = path.split('/');
-        const idx = parts.lastIndexOf(id) + 1;
-        parts.splice(idx, parts.length - idx);
-        return parts.join('/');
-    }
-    static async dynamicImport(id) {
-        /* v8 ignore next */
-        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
-        return import(specifier);
-    }
-    static ensureDir(path) {
-        if (!existsSync(path)) {
-            mkdirSync(path, { recursive: true });
-        }
-    }
-    static pathExistsSync(path) {
-        return existsSync(path);
-    }
-    static readJSONSync(path) {
-        const file = readFileSync(path);
-        return JSON.parse(file.toString());
-    }
     static getORMVersion() {
-        try {
-            // this works during development where we have `src` folder
-            return this.requireFrom('../../package.json', import.meta.dirname).version;
-            /* v8 ignore next 5 */
-        }
-        catch {
-            try {
-                // this works in production build where we do not have the `src` folder
-                return this.requireFrom('../package.json', import.meta.dirname).version;
-            }
-            catch {
-                return 'N/A';
-            }
-        }
+        return this.#ORM_VERSION;
     }
-    static createFunction(context, code) {
+    static createFunction(context, code, compiledFunctions, key) {
+        if (key && compiledFunctions?.[key]) {
+            return compiledFunctions[key](...context.values());
+        }
         try {
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval
             return new Function(...context.keys(), `'use strict';\n` + code)(...context.values());
-            /* v8 ignore next 5 */
+            /* v8 ignore next */
         }
         catch (e) {
             // eslint-disable-next-line no-console
@@ -953,7 +692,7 @@ export class Utils {
             return fn(...args);
         }
         catch (e) {
-            /* v8 ignore start */
+            /* v8 ignore next */
             if ([SyntaxError, TypeError, EvalError, ReferenceError].some(t => e instanceof t)) {
                 const position = e.stack.match(/<anonymous>:(\d+):(\d+)/);
                 let code = fn.toString();
@@ -970,18 +709,9 @@ export class Utils {
                 // eslint-disable-next-line no-console
                 console.error(`JIT runtime error: ${e.message}\n\n${code}`);
             }
-            /* v8 ignore stop */
             throw e;
         }
     }
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue() {
-        if (process.env.BABEL_DECORATORS_COMPAT) {
-            return {};
-        }
-    }
     static unwrapProperty(entity, meta, prop, payload = false) {
         let p = prop;
         const path = [];
@@ -1061,57 +791,21 @@ export class Utils {
             }
         }
     }
-    static tryRequire({ module, from, allowError, warning }) {
-        allowError ??= `Cannot find module '${module}'`;
-        from ??= process.cwd();
-        try {
-            return Utils.requireFrom(module, from);
-        }
-        catch (err) {
-            if (err.message.includes(allowError)) {
-                // eslint-disable-next-line no-console
-                console.warn(warning);
-                return undefined;
-            }
-            throw err;
-        }
-    }
-    static async tryImport({ module, warning }) {
+    static async tryImport({ module, warning, }) {
         try {
             return await import(module);
         }
         catch (err) {
             if (err.code === 'ERR_MODULE_NOT_FOUND') {
-                // eslint-disable-next-line no-console
-                console.warn(warning);
+                if (warning) {
+                    // eslint-disable-next-line no-console
+                    console.warn(warning);
+                }
                 return undefined;
             }
             throw err;
         }
     }
-    static stripRelativePath(str) {
-        return str.replace(/^(?:\.\.\/|\.\/)+/, '/');
-    }
-    /**
-     * simple process.argv parser, supports only properties with long names, prefixed with `--`
-     */
-    static parseArgs() {
-        let lastKey;
-        return process.argv.slice(2).reduce((args, arg) => {
-            if (arg.includes('=')) {
-                const [key, value] = arg.split('=');
-                args[key.substring(2)] = value;
-            }
-            else if (lastKey) {
-                args[lastKey] = arg;
-                lastKey = undefined;
-            }
-            else if (arg.startsWith('--')) {
-                lastKey = arg.substring(2);
-            }
-            return args;
-        }, {});
-    }
     static xor(a, b) {
         return (a || b) && !(a && b);
     }
@@ -1140,4 +834,12 @@ export class Utils {
             return o;
         }, {});
     }
+    static getObjectQueryKeys(obj) {
+        return Reflect.ownKeys(obj).filter(key => {
+            if (!Object.prototype.propertyIsEnumerable.call(obj, key)) {
+                return false;
+            }
+            return typeof key === 'string' || Raw.isKnownFragmentSymbol(key);
+        });
+    }
 }