@mikro-orm/core 7.0.0-rc.2 → 7.0.0

package/utils/QueryHelper.js

@@ -50,17 +50,21 @@ export class QueryHelper {
         }
         const keys = Object.keys(where);
         const groupOperator = keys.find(k => {
-            return k in GroupOperator && Array.isArray(where[k]) && where[k].every(cond => {
-                return Utils.isPlainObject(cond) && Object.keys(cond).every(k2 => {
-                    if (Utils.isOperator(k2, false)) {
-                        if (k2 === '$not') {
-                            return Object.keys(cond[k2]).every(k3 => meta.primaryKeys.includes(k3));
-                        }
-                        return true;
-                    }
-                    return meta.primaryKeys.includes(k2);
-                });
-            });
+            return (k in GroupOperator &&
+                Array.isArray(where[k]) &&
+                where[k].every(cond => {
+                    return (Utils.isPlainObject(cond) &&
+                        Object.keys(cond).every(k2 => {
+                            if (Utils.isOperator(k2, false)) {
+                                if (k2 === '$not') {
+                                    return Object.keys(cond[k2]).every(k3 => meta.primaryKeys.includes(k3));
+                                }
+                                /* v8 ignore next */
+                                return true;
+                            }
+                            return meta.primaryKeys.includes(k2);
+                        }));
+                }));
         });
         if (groupOperator) {
             return groupOperator;
@@ -96,15 +100,21 @@ export class QueryHelper {
             return false;
         }
         if (meta.primaryKeys.every(pk => pk in where) && Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
-            return !!key && !GroupOperator[key] && key !== '$not' && Object.keys(where).every(k => !Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
-                if (Utils.isOperator(v, false)) {
-                    return true;
-                }
-                if (meta.properties[k].primary && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
-                    return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
-                }
-                return true;
-            }));
+            return (!!key &&
+                !GroupOperator[key] &&
+                key !== '$not' &&
+                Object.keys(where).every(k => !Utils.isPlainObject(where[k]) ||
+                    Object.keys(where[k]).every(v => {
+                        if (Utils.isOperator(v, false)) {
+                            return true;
+                        }
+                        if (meta.properties[k].primary &&
+                            [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
+                            return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
+                        }
+                        /* v8 ignore next */
+                        return true;
+                    })));
         }
         Object.keys(where).forEach(k => {
             const meta2 = metadata.find(meta.properties[k]?.targetMeta?.class) || meta;
@@ -123,6 +133,9 @@ export class QueryHelper {
             QueryHelper.liftGroupOperators(where, meta, metadata);
             QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
         }
+        if (meta && root) {
+            QueryHelper.convertCompositeEntityRefs(where, meta);
+        }
         if (platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
             Utils.dropUndefinedProperties(where);
         }
@@ -139,7 +152,9 @@ export class QueryHelper {
             let cond = { [rootPrimaryKey]: { $in: where } };
             // @ts-ignore
             // detect tuple comparison, use `$or` in case the number of constituents don't match
-            if (meta && !where.every(c => Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils.isPrimaryKey(i))))) {
+            if (meta &&
+                !where.every(c => Utils.isPrimaryKey(c) ||
+                    (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils.isPrimaryKey(i))))) {
                 cond = { $or: where };
             }
             return QueryHelper.processWhere({ ...options, where: cond, root: false });
@@ -170,10 +185,12 @@ export class QueryHelper {
             if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
-            const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
+            // oxfmt-ignore
+            const isJsonProperty = prop?.customType instanceof JsonType && !isRaw(value) && (Utils.isPlainObject(value) ? !['$eq', '$elemMatch'].includes(Object.keys(value)[0]) : !Array.isArray(value));
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
+            // oxfmt-ignore
             if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !(customExpression && Raw.getKnownFragment(key).params.length > 0) && options.type !== 'orderBy') {
                 // comparing single composite key - use $eq instead of $in
                 const op = composite && !value.every(v => Array.isArray(v)) ? '$eq' : '$in';
@@ -200,10 +217,10 @@ export class QueryHelper {
         }
         const opts = {};
         if (Array.isArray(options)) {
-            options.forEach(filter => opts[filter] = true);
+            options.forEach(filter => (opts[filter] = true));
         }
         else if (Utils.isPlainObject(options)) {
-            Object.keys(options).forEach(filter => opts[filter] = options[filter]);
+            Object.keys(options).forEach(filter => (opts[filter] = options[filter]));
         }
         return Object.keys(filters)
             .filter(f => QueryHelper.isFilterActive(meta, f, filters[f], opts))
@@ -252,9 +269,7 @@ export class QueryHelper {
             }, {});
         }
         if (key && JSON_KEY_OPERATORS.includes(key)) {
-            return Array.isArray(cond)
-                ? platform.marshallArray(cond)
-                : cond;
+            return Array.isArray(cond) ? platform.marshallArray(cond) : cond;
         }
         if (Array.isArray(cond) && !(key && ARRAY_OPERATORS.includes(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
@@ -268,29 +283,7 @@ export class QueryHelper {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }
     static processJsonCondition(o, value, path, platform, alias) {
-        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
-            Utils.keys(value).forEach(k => {
-                this.processJsonCondition(o, value[k], [...path, k], platform, alias);
-            });
-            return o;
-        }
-        if (path.length === 1) {
-            o[path[0]] = value;
-            return o;
-        }
-        const type = this.getValueType(value);
-        const k = platform.getSearchJsonPropertyKey(path, type, alias, value);
-        o[k] = value;
-        return o;
-    }
-    static getValueType(value) {
-        if (Array.isArray(value)) {
-            return typeof value[0];
-        }
-        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
-            return this.getValueType(Object.values(value)[0]);
-        }
-        return typeof value;
+        return platform.processJsonCondition(o, value, path, alias);
     }
     static findProperty(fieldName, options) {
         const parts = fieldName.split('.');
@@ -300,6 +293,71 @@ export class QueryHelper {
         const meta = entityName ? options.metadata.find(entityName) : undefined;
         return meta?.properties[propName];
     }
+    /**
+     * Converts entity references for composite FK properties into flat arrays
+     * of correctly-ordered join column values, before processParams flattens them
+     * incorrectly due to shared FK columns.
+     */
+    static convertCompositeEntityRefs(where, meta) {
+        if (!Utils.isPlainObject(where)) {
+            return;
+        }
+        for (const k of Object.keys(where)) {
+            if (k in GroupOperator) {
+                if (Array.isArray(where[k])) {
+                    where[k].forEach((sub) => this.convertCompositeEntityRefs(sub, meta));
+                }
+                continue;
+            }
+            if (k === '$not') {
+                this.convertCompositeEntityRefs(where[k], meta);
+                continue;
+            }
+            const prop = meta.properties[k];
+            if (!prop?.joinColumns || prop.joinColumns.length <= 1) {
+                continue;
+            }
+            const w = where[k];
+            if (Utils.isEntity(w)) {
+                where[k] = this.extractJoinColumnValues(w, prop);
+            }
+            else if (Utils.isPlainObject(w)) {
+                for (const op of Object.keys(w)) {
+                    if (Utils.isOperator(op, false) && Array.isArray(w[op])) {
+                        w[op] = w[op].map((item) => Utils.isEntity(item) ? this.extractJoinColumnValues(item, prop) : item);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Extracts values for a FK's join columns from an entity by traversing the FK chain.
+     * Handles shared FK columns (e.g., tenant_id referenced by multiple FKs) correctly.
+     */
+    static extractJoinColumnValues(entity, prop) {
+        return prop.referencedColumnNames.map(refCol => {
+            return this.extractColumnValue(entity, prop.targetMeta, refCol);
+        });
+    }
+    /**
+     * Extracts the value for a specific column from an entity by finding which PK property
+     * owns that column and recursively traversing FK references.
+     */
+    static extractColumnValue(entity, meta, columnName) {
+        for (const pk of meta.primaryKeys) {
+            const pkProp = meta.properties[pk];
+            const colIdx = pkProp.fieldNames.indexOf(columnName);
+            if (colIdx !== -1) {
+                const value = entity[pk];
+                if (pkProp.targetMeta && Utils.isEntity(value, true)) {
+                    const refCol = pkProp.referencedColumnNames[colIdx];
+                    return this.extractColumnValue(value, pkProp.targetMeta, refCol);
+                }
+                return value;
+            }
+        }
+        return null;
+    }
     /**
      * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
      * RawQueryFragment symbol keys are never deduped (each is unique).

package/utils/RawQueryFragment.d.ts

@@ -19,7 +19,7 @@ export declare class RawQueryFragment<Alias extends string = string> {
     static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
     static hasObjectFragments(object: unknown): boolean;
     static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
-    static getKnownFragment(key: unknown): RawQueryFragment<any> | undefined;
+    static getKnownFragment(key: unknown): RawQueryFragment | undefined;
 }
 export { RawQueryFragment as Raw };
 export declare function isRaw(value: unknown): value is RawQueryFragment;
@@ -102,8 +102,8 @@ export declare function raw<R = RawQueryFragment & symbol, T extends object = an
  */
 export declare function sql<R = RawQueryFragment & symbol>(sql: readonly string[], ...values: unknown[]): R;
 export declare namespace sql {
-    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment<string> & symbol;
-    var now: (length?: number) => RawQueryFragment<string> & symbol;
+    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment & symbol;
+    var now: (length?: number) => RawQueryFragment & symbol;
     var lower: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
     var upper: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
 }
@@ -123,4 +123,4 @@ export declare function createSqlFunction<R = RawQueryFragment & symbol, T exten
  */
 export declare function quote(expParts: readonly string[], ...values: (string | {
     toString(): string;
-})[]): RawQueryFragment<string> & symbol;
+})[]): RawQueryFragment & symbol;

package/utils/RawQueryFragment.js

@@ -39,7 +39,8 @@ export class RawQueryFragment {
         return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
     }
     static hasObjectFragments(object) {
-        return Utils.isPlainObject(object) && Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol));
+        return (Utils.isPlainObject(object) &&
+            Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol)));
     }
     static isKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
@@ -181,7 +182,7 @@ export function createSqlFunction(func, key) {
     if (typeof key === 'string') {
         return raw(`${func}(${key})`);
     }
-    return raw(a => `${func}(${(key(a))})`);
+    return raw(a => `${func}(${key(a)})`);
 }
 sql.ref = (...keys) => raw('??', [keys.join('.')]);
 sql.now = (length) => raw('current_timestamp' + (length == null ? '' : `(${length})`));

package/utils/TransactionManager.js

@@ -160,8 +160,7 @@ export class TransactionManager {
         for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
             const wrapped = helper(entity);
             const meta = wrapped.__meta;
-            // eslint-disable-next-line dot-notation
-            const parentEntity = parentUoW.getById(meta.class, wrapped.getPrimaryKey(), parent['_schema'], true);
+            const parentEntity = parentUoW.getById(meta.class, wrapped.getPrimaryKey(), parent.schema, true);
             if (parentEntity && parentEntity !== entity) {
                 const parentWrapped = helper(parentEntity);
                 parentWrapped.__data = wrapped.__data;
@@ -183,7 +182,8 @@ export class TransactionManager {
     registerDeletionHandler(fork, parent) {
         fork.getEventManager().registerSubscriber({
             afterFlush: (args) => {
-                const deletionChangeSets = args.uow.getChangeSets()
+                const deletionChangeSets = args.uow
+                    .getChangeSets()
                     .filter(cs => cs.type === ChangeSetType.DELETE || cs.type === ChangeSetType.DELETE_EARLY);
                 for (const cs of deletionChangeSets) {
                     parent.getUnitOfWork(false).unsetIdentity(cs.entity);

package/utils/Utils.d.ts

@@ -22,7 +22,7 @@ export declare class Utils {
     /**
      * Removes `undefined` properties (recursively) so they are not saved as nulls
      */
-    static dropUndefinedProperties(o: any, value?: undefined | null, visited?: Set<unknown>): void;
+    static dropUndefinedProperties(o: any, value?: null, visited?: Set<unknown>): void;
     /**
      * Returns the number of properties on `obj`. This is 20x faster than Object.keys(obj).length.
      * @see https://github.com/deepkit/deepkit-framework/blob/master/packages/core/src/core.ts
@@ -147,7 +147,7 @@ export declare class Utils {
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
-    static tryImport<T extends Dictionary = any>({ module, warning }: {
+    static tryImport<T extends Dictionary = any>({ module, warning, }: {
         module: string;
         warning?: string;
     }): Promise<T | undefined>;

package/utils/Utils.js

@@ -25,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)) {
@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-rc.2';
+    static #ORM_VERSION = '7.0.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -305,7 +305,7 @@ export class Utils {
             .split(',')
             .map(s => s.trim().replace(/=.*$/, '').trim())
             .filter(Boolean)
-            .map(raw => raw.startsWith('{') && raw.endsWith('}') ? '' : raw);
+            .map(raw => (raw.startsWith('{') && raw.endsWith('}') ? '' : raw));
     }
     /**
      * Checks whether the argument looks like primary key (string, number or ObjectId).
@@ -374,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');
             }
@@ -382,7 +383,8 @@ 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);
@@ -419,7 +421,7 @@ export class Utils {
         }
         if (allowScalar) {
             if (Utils.isPlainObject(pk)) {
-                return pk[(meta.primaryKeys)[0]];
+                return pk[meta.primaryKeys[0]];
             }
             return pk;
         }
@@ -527,7 +529,7 @@ 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.
@@ -536,17 +538,17 @@ export class Utils {
         /* 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 => 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
-            });
+        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.
@@ -557,7 +559,7 @@ export class Utils {
             return simple;
         }
         const objectType = Object.prototype.toString.call(value);
-        const type = objectType.match(/^\[object (.+)]$/)[1];
+        const type = /^\[object (.+)]$/.exec(objectType)[1];
         if (type === 'Uint8Array') {
             return 'Buffer';
         }
@@ -567,12 +569,13 @@ export class Utils {
      * 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.
@@ -610,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) {
@@ -633,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, deep) {
-        return arrays.flatMap(v => deep && Array.isArray(v) ? this.flatten(v, true) : v);
+        return arrays.flatMap(v => (deep && Array.isArray(v) ? this.flatten(v, true) : v));
     }
     static isOperator(key, includeGroupOperators = true) {
         if (!includeGroupOperators) {
@@ -671,6 +677,7 @@ export class Utils {
             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 */
         }
@@ -784,7 +791,7 @@ export class Utils {
             }
         }
     }
-    static async tryImport({ module, warning }) {
+    static async tryImport({ module, warning, }) {
         try {
             return await import(module);
         }

package/utils/clone.js

@@ -20,6 +20,7 @@ function getPropertyDescriptor(obj, prop) {
     }
     return null;
 }
+const TypedArray = Object.getPrototypeOf(Uint8Array);
 export function clone(parent, respectCustomCloneMethod = true) {
     const allParents = [];
     const allChildren = [];
@@ -74,6 +75,10 @@ export function clone(parent, respectCustomCloneMethod = true) {
             parent.copy(child);
             return child;
         }
+        else if (parent instanceof TypedArray) {
+            child = parent.slice();
+            return child;
+        }
         else if (parent instanceof Error) {
             child = new parent.constructor(parent.message);
         }

package/utils/env-vars.js

@@ -13,10 +13,11 @@ export function getEnv(key) {
 export function loadEnvironmentVars() {
     const ret = {};
     const getEnvKey = (key, envPrefix = 'MIKRO_ORM_') => {
-        return envPrefix + key
-            .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-            .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
-            .toUpperCase();
+        return (envPrefix +
+            key
+                .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+                .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+                .toUpperCase());
     };
     const array = (v) => v.split(',').map(vv => vv.trim());
     const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
@@ -28,7 +29,7 @@ export function loadEnvironmentVars() {
             o[key] = mapper(getEnv(envKey));
         }
     };
-    const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
+    const cleanup = (o, k) => (Utils.hasObjectKeys(o[k]) ? {} : delete o[k]);
     const read0 = read.bind(null, ret, 'MIKRO_ORM_');
     read0('baseDir');
     read0('entities', array);

package/utils/fs-utils.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary } from '../typings.js';
-export declare const fs: {
+export interface FsUtils {
     init(): Promise<void>;
     pathExists(path: string): boolean;
     ensureDir(path: string): void;
@@ -10,25 +10,11 @@ export declare const fs: {
     getORMPackages(): Set<string>;
     getORMPackageVersion(name: string): string | undefined;
     checkPackageVersion(): void;
-    /**
-     * 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 (`/`).
-     */
     normalizePath(...parts: string[]): string;
-    /**
-     * Determines the relative path between two paths. If either path is a `file:` URL,
-     * it is converted to a local path.
-     */
     relativePath(path: string, relativeTo: string): string;
-    /**
-     * 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.
-     */
     absolutePath(path: string, baseDir?: string): string;
     writeFile(path: string, data: string, options?: Record<string, any>): Promise<void>;
     dynamicImport<T = any>(id: string): Promise<T>;
-};
+}
+export declare const fs: FsUtils;
 export * from '../cache/FileCacheAdapter.js';

package/utils/fs-utils.js

@@ -95,10 +95,7 @@ export const fs = {
     },
     getORMPackages() {
         const pkg = this.getPackageConfig();
-        return new Set([
-            ...Object.keys(pkg.dependencies ?? {}),
-            ...Object.keys(pkg.devDependencies ?? {}),
-        ]);
+        return new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
     },
     getORMPackageVersion(name) {
         try {
@@ -153,7 +150,7 @@ export const fs = {
         }
         let path = parts.join('/').replace(/\\/g, '/').replace(/\/$/, '');
         path = normalize(path).replace(/\\/g, '/');
-        return (path.match(/^[/.]|[a-zA-Z]:/) || path.startsWith('!')) ? path : './' + path;
+        return /^[/.]|[a-zA-Z]:/.exec(path) || path.startsWith('!') ? path : './' + path;
     },
     /**
      * Determines the relative path between two paths. If either path is a `file:` URL,

package/utils/upsert-utils.js

@@ -73,7 +73,8 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     if (!meta) {
         return '*';
     }
-    const keys = meta.comparableProps.filter(p => {
+    const keys = meta.comparableProps
+        .filter(p => {
         if (p.lazy || p.embeddable) {
             return false;
         }
@@ -81,7 +82,8 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
             return true;
         }
         return Array.isArray(uniqueFields) && !uniqueFields.includes(p.name);
-    }).map(p => p.name);
+    })
+        .map(p => p.name);
     if (meta.versionProperty) {
         keys.push(meta.versionProperty);
     }
@@ -99,7 +101,7 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     return keys.filter(key => !(key in data));
 }
 function getPropertyValue(obj, key) {
-    if (key.indexOf('.') === -1) {
+    if (!key.includes('.')) {
         return obj[key];
     }
     const parts = key.split('.');
@@ -113,7 +115,8 @@ function getPropertyValue(obj, key) {
 /** @internal */
 export function getWhereCondition(meta, onConflictFields, data, where) {
     const unique = onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
-    const propIndex = !isRaw(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+    const propIndex = !isRaw(unique) &&
+        unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
     if (onConflictFields || where == null) {
         if (propIndex !== false && propIndex >= 0) {
             let key = unique[propIndex];