@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/utils/Utils.js

@@ -1,27 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Utils = exports.ObjectBindingPattern = void 0;
-exports.compareObjects = compareObjects;
-exports.compareArrays = compareArrays;
-exports.compareBooleans = compareBooleans;
-exports.compareBuffers = compareBuffers;
-exports.equals = equals;
-exports.parseJsonSafe = parseJsonSafe;
-const node_module_1 = require("node:module");
-const globby_1 = __importDefault(require("globby"));
-const node_path_1 = require("node:path");
-const node_os_1 = require("node:os");
-const node_url_1 = require("node:url");
-const fs_extra_1 = require("fs-extra");
-const node_crypto_1 = require("node:crypto");
-const esprima_1 = require("esprima");
-const clone_1 = require("./clone");
-const enums_1 = require("../enums");
-const wrap_1 = require("../entity/wrap");
-exports.ObjectBindingPattern = Symbol('ObjectBindingPattern');
+import { isAbsolute, normalize, relative } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { clone } from './clone.js';
+import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
+import { helper } from '../entity/wrap.js';
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -34,10 +15,7 @@ function compareConstructors(a, b) {
     }
     return false;
 }
-function isRawSql(value) {
-    return typeof value === 'object' && !!value && '__raw' in value;
-}
-function compareObjects(a, b) {
+export function compareObjects(a, b) {
     if (a === b || (a == null && b == null)) {
         return true;
     }
@@ -56,6 +34,7 @@ function compareObjects(a, b) {
         }
         return timeA === timeB;
     }
+    /* 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) ||
@@ -82,7 +61,7 @@ function compareObjects(a, b) {
     }
     return true;
 }
-function compareArrays(a, b) {
+export function compareArrays(a, b) {
     const length = a.length;
     if (length !== b.length) {
         return false;
@@ -95,12 +74,12 @@ function compareArrays(a, b) {
     }
     return true;
 }
-function compareBooleans(a, b) {
+export function compareBooleans(a, b) {
     a = typeof a === 'number' ? Boolean(a) : a;
     b = typeof b === 'number' ? Boolean(b) : b;
     return a === b;
 }
-function compareBuffers(a, b) {
+export function compareBuffers(a, b) {
     const length = a.length;
     if (length !== b.length) {
         return false;
@@ -115,7 +94,7 @@ function compareBuffers(a, b) {
 /**
  * Checks if arguments are deeply (but not strictly) equal.
  */
-function equals(a, b) {
+export function equals(a, b) {
     if (a === b) {
         return true;
     }
@@ -131,8 +110,9 @@ function equals(a, b) {
     return Number.isNaN(a) && Number.isNaN(b);
 }
 const equalsFn = equals;
-function parseJsonSafe(value) {
+export function parseJsonSafe(value) {
     if (typeof value === 'string') {
+        /* v8 ignore next */
         try {
             return JSON.parse(value);
         }
@@ -143,54 +123,17 @@ function parseJsonSafe(value) {
     }
     return value;
 }
-class Utils {
+export class Utils {
     static PK_SEPARATOR = '~~~';
-    /* istanbul ignore next */
+    static #ORM_VERSION = '7.0.0-dev.100';
+    /* v8 ignore next */
     static dynamicImportProvider = (id) => import(id);
-    /**
-     * Checks if the argument is not undefined
-     */
-    static isDefined(data) {
-        return typeof data !== 'undefined';
-    }
     /**
      * 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
      */
@@ -220,7 +163,6 @@ class Utils {
     static getObjectKeysSize(object) {
         let size = 0;
         for (const key in object) {
-            /* istanbul ignore else */
             if (Object.hasOwn(object, key)) {
                 size++;
             }
@@ -233,25 +175,12 @@ class Utils {
      */
     static hasObjectKeys(object) {
         for (const key in object) {
-            /* istanbul ignore else */
             if (Object.hasOwn(object, key)) {
                 return true;
             }
         }
         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.
      */
@@ -297,7 +226,7 @@ class Utils {
                         target[key] = Utils.copy(value);
                         continue;
                     }
-                    /* istanbul ignore next */
+                    /* v8 ignore next */
                     if (!(key in target)) {
                         Object.assign(target, { [key]: {} });
                     }
@@ -310,35 +239,11 @@ 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.
      */
     static copy(entity, respectCustomCloneMethod = true) {
-        return (0, clone_1.clone)(entity, respectCustomCloneMethod);
+        return clone(entity, respectCustomCloneMethod);
     }
     /**
      * Normalize the argument to always be an array.
@@ -374,53 +279,37 @@ 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;
-        }
-        try {
-            return (0, esprima_1.tokenize)(func.toString(), { tolerant: true });
+    static getConstructorParams(func) {
+        const source = func.toString();
+        const i = source.indexOf('constructor');
+        if (i === -1) {
+            return undefined;
         }
-        catch {
-            /* istanbul ignore next */
-            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(exports.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).
@@ -433,7 +322,7 @@ 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)) {
@@ -450,7 +339,11 @@ class Utils {
             return data;
         }
         if (Utils.isEntity(data, true)) {
-            return (0, wrap_1.helper)(data).getPrimaryKey();
+            const wrapped = helper(data);
+            if (wrapped.__meta.compositePK) {
+                return wrapped.getPrimaryKeys();
+            }
+            return wrapped.getPrimaryKey();
         }
         if (strict && meta && Utils.getObjectKeysSize(data) !== meta.primaryKeys.length) {
             return null;
@@ -459,7 +352,7 @@ 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;
     }
@@ -498,8 +391,8 @@ class Utils {
     static splitPrimaryKeys(key) {
         return key.split(this.PK_SEPARATOR);
     }
-    static getPrimaryKeyValues(entity, primaryKeys, allowScalar = false, convertCustomTypes = false) {
-        /* istanbul ignore next */
+    static getPrimaryKeyValues(entity, meta, allowScalar = false, convertCustomTypes = false) {
+        /* v8 ignore next */
         if (entity == null) {
             return entity;
         }
@@ -509,15 +402,28 @@ class Utils {
             }
             return val;
         }
-        const pk = Utils.isEntity(entity, true)
-            ? (0, wrap_1.helper)(entity).getPrimaryKey(convertCustomTypes)
-            : primaryKeys.reduce((o, pk) => { o[pk] = entity[pk]; return o; }, {});
-        if (primaryKeys.length > 1) {
+        let pk;
+        if (Utils.isEntity(entity, true)) {
+            pk = helper(entity).getPrimaryKey(convertCustomTypes);
+        }
+        else {
+            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);
+                }
+                else {
+                    o[pk] = entity[pk];
+                }
+                return o;
+            }, {});
+        }
+        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;
         }
@@ -561,7 +467,7 @@ class Utils {
             return o;
         }, {});
     }
-    static getOrderedPrimaryKeys(id, meta, platform, convertCustomTypes = false) {
+    static getOrderedPrimaryKeys(id, meta, platform, convertCustomTypes = false, allowScalar = false) {
         const data = (Utils.isPrimaryKey(id) ? { [meta.primaryKeys[0]]: id } : id);
         const pks = meta.primaryKeys.map((pk, idx) => {
             const prop = meta.properties[pk];
@@ -570,12 +476,15 @@ class Utils {
             if (convertCustomTypes && platform && prop.customType && !prop.targetMeta) {
                 value = prop.customType.convertToJSValue(value, platform);
             }
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR && prop.targetMeta) {
-                const value2 = this.getOrderedPrimaryKeys(value, prop.targetMeta, platform, convertCustomTypes);
+            if (prop.kind !== ReferenceKind.SCALAR && prop.targetMeta) {
+                const value2 = this.getOrderedPrimaryKeys(value, prop.targetMeta, platform, convertCustomTypes, allowScalar);
                 value = value2.length > 1 ? value2 : value2[0];
             }
             return value;
         });
+        if (allowScalar && pks.length === 1) {
+            return pks[0];
+        }
         // we need to flatten the PKs as composite PKs can be build from another composite PKs
         // and this method is used to get the PK hash in identity map, that expects flat array
         return Utils.flatten(pks);
@@ -598,12 +507,6 @@ 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).
      */
@@ -631,55 +534,21 @@ class Utils {
             .map(field => field === allSymbol ? allSymbol : field.substring(prefix.length + 1));
     }
     /**
-     * Tries to detect `ts-node` runtime.
+     * Tries to detect TypeScript support.
      */
-    static detectTsNode() {
-        /* istanbul ignore next */
+    static detectTypeScriptSupport() {
+        /* v8 ignore next */
         return process.argv[0].endsWith('ts-node') // running via ts-node directly
-            // @ts-ignore
-            || !!process[Symbol.for('ts-node.register.instance')] // check if internal ts-node symbol exists
+            || !!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.includes('ts-node')) // registering ts-node runner
-            || process.execArgv.some(arg => arg === 'ts-node/esm') // check for ts-node/esm module loader
-            || (require.extensions && !!require.extensions['.ts']); // check if the extension is registered
-    }
-    /**
-     * 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
-            const reflectLine = stack.findIndex(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;
-        }
+            || 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
+            });
     }
     /**
      * Gets the type of the argument.
@@ -690,11 +559,11 @@ class Utils {
             return simple;
         }
         const objectType = Object.prototype.toString.call(value);
-        const type = objectType.match(/\[object (\w+)]/)[1];
+        const type = objectType.match(/^\[object (.+)]$/)[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`)
@@ -705,7 +574,7 @@ class Utils {
             && typeof value.constructor === 'function'
             && (Object.hasOwn(value.constructor.prototype, 'isPrototypeOf') || Object.getPrototypeOf(value.constructor.prototype) === null))
             || (value && Object.getPrototypeOf(value) === null)
-            || value instanceof enums_1.PlainObject;
+            || value instanceof PlainObject;
     }
     /**
      * Executes the `cb` promise serially on every element of the `items` array and returns array of resolved values.
@@ -722,7 +591,7 @@ class Utils {
     }
     static fileURLToPath(url) {
         // expose `fileURLToPath` on Utils so that it can be properly mocked in tests
-        return (0, node_url_1.fileURLToPath)(url);
+        return fileURLToPath(url);
     }
     /**
      * Resolves and normalizes a series of path parts relative to each preceding part.
@@ -735,7 +604,7 @@ class Utils {
         let start = 0;
         for (let i = 0; i < parts.length; i++) {
             const part = parts[i];
-            if ((0, node_path_1.isAbsolute)(part)) {
+            if (isAbsolute(part)) {
                 start = i;
             }
             else if (part.startsWith('file:')) {
@@ -747,7 +616,7 @@ class Utils {
             parts = parts.slice(start);
         }
         let path = parts.join('/').replace(/\\/g, '/').replace(/\/$/, '');
-        path = (0, node_path_1.normalize)(path).replace(/\\/g, '/');
+        path = normalize(path).replace(/\\/g, '/');
         return (path.match(/^[/.]|[a-zA-Z]:/) || path.startsWith('!')) ? path : './' + path;
     }
     /**
@@ -762,7 +631,7 @@ class Utils {
         if (path.startsWith('.')) {
             return path;
         }
-        path = (0, node_path_1.relative)(Utils.normalizePath(relativeTo), path);
+        path = relative(Utils.normalizePath(relativeTo), path);
         return Utils.normalizePath(path);
     }
     /**
@@ -773,13 +642,19 @@ class Utils {
         if (!path) {
             return Utils.normalizePath(baseDir);
         }
-        if (!(0, node_path_1.isAbsolute)(path) && !path.startsWith('file://')) {
+        if (!isAbsolute(path) && !path.startsWith('file://')) {
             path = baseDir + '/' + path;
         }
         return Utils.normalizePath(path);
     }
+    // FNV-1a 64-bit
     static hash(data, length) {
-        const hash = (0, node_crypto_1.createHash)('md5').update(data).digest('hex');
+        let h1 = 0xcbf29ce484222325n;
+        for (let i = 0; i < data.length; i++) {
+            h1 ^= BigInt(data.charCodeAt(i));
+            h1 = (h1 * 0x100000001b3n) & 0xffffffffffffffffn;
+        }
+        const hash = h1.toString(16).padStart(16, '0');
         if (length) {
             return hash.substring(0, length);
         }
@@ -811,13 +686,6 @@ class Utils {
     static randomInt(min, max) {
         return Math.round(Math.random() * (max - min)) + min;
     }
-    static async pathExists(path, options = {}) {
-        if (globby_1.default.hasMagic(path)) {
-            const found = await (0, globby_1.default)(path, options);
-            return found.length > 0;
-        }
-        return (0, fs_extra_1.pathExistsSync)(path);
-    }
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -839,18 +707,9 @@ class Utils {
     }
     static isOperator(key, includeGroupOperators = true) {
         if (!includeGroupOperators) {
-            return key in enums_1.QueryOperator;
+            return key in QueryOperator;
         }
-        return key in enums_1.GroupOperator || key in enums_1.QueryOperator;
-    }
-    static isGroupOperator(key) {
-        return key in enums_1.GroupOperator;
-    }
-    static isArrayOperator(key) {
-        return enums_1.ARRAY_OPERATORS.includes(key);
-    }
-    static isJsonKeyOperator(key) {
-        return enums_1.JSON_KEY_OPERATORS.includes(key);
+        return key in GroupOperator || key in QueryOperator;
     }
     static hasNestedKey(object, key) {
         if (!object) {
@@ -864,60 +723,18 @@ 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 (!(0, node_path_1.extname)(from)) {
-            from = (0, node_path_1.join)(from, '__fake.js');
-        }
-        return (0, node_module_1.createRequire)((0, node_path_1.resolve)(from))(id);
-    }
     static async dynamicImport(id) {
-        /* istanbul ignore next */
-        if ((0, node_os_1.platform)() === 'win32') {
-            try {
-                id = (0, node_url_1.pathToFileURL)(id).toString();
-            }
-            catch {
-                // ignore
-            }
-            // If the extension is not registered, we need to fall back to a file path.
-            if (require.extensions && !require.extensions[(0, node_path_1.extname)(id)]) {
-                id = (0, node_url_1.fileURLToPath)(id);
-            }
-        }
-        /* istanbul ignore next */
-        return this.dynamicImportProvider(id);
-    }
-    /* istanbul ignore next */
-    static setDynamicImportProvider(provider) {
-        this.dynamicImportProvider = provider;
+        /* v8 ignore next */
+        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
+        return this.dynamicImportProvider(specifier);
     }
     static getORMVersion() {
-        /* istanbul ignore next */
-        try {
-            // this works with ts-node during development (where we have `src` folder)
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            return require('../../package.json').version;
-        }
-        catch {
-            // this works with node in production build (where we do not have the `src` folder)
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            return require('../package.json').version;
-        }
+        return this.#ORM_VERSION;
     }
-    /* istanbul ignore next */
     static createFunction(context, code) {
         try {
             return new Function(...context.keys(), `'use strict';\n` + code)(...context.values());
+            /* v8 ignore next */
         }
         catch (e) {
             // eslint-disable-next-line no-console
@@ -925,12 +742,12 @@ class Utils {
             throw e;
         }
     }
-    /* istanbul ignore next */
     static callCompiledFunction(fn, ...args) {
         try {
             return fn(...args);
         }
         catch (e) {
+            /* 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();
@@ -950,14 +767,6 @@ class Utils {
             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 = [];
@@ -1037,44 +846,21 @@ class Utils {
             }
         }
     }
-    static tryRequire({ module, from, allowError, warning }) {
-        allowError ??= `Cannot find module '${module}'`;
-        from ??= process.cwd();
+    static async tryImport({ module, warning }) {
         try {
-            return Utils.requireFrom(module, from);
+            return await import(module);
         }
         catch (err) {
-            if (err.message.includes(allowError)) {
-                // eslint-disable-next-line no-console
-                console.warn(warning);
+            if (err.code === 'ERR_MODULE_NOT_FOUND') {
+                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);
     }
@@ -1087,9 +873,6 @@ class Utils {
     static entries(obj) {
         return Object.entries(obj);
     }
-    static isRawSql(value) {
-        return isRawSql(value);
-    }
     static primaryKeyToObject(meta, primaryKey, visible) {
         const pks = meta.compositePK && Utils.isPlainObject(primaryKey) ? Object.values(primaryKey) : Utils.asArray(primaryKey);
         const pkProps = meta.getPrimaryProps();
@@ -1107,4 +890,3 @@ class Utils {
         }, {});
     }
 }
-exports.Utils = Utils;