@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/utils/EntityComparator.js

@@ -6,20 +6,20 @@ import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 export class EntityComparator {
-    metadata;
-    platform;
-    config;
-    comparators = new Map();
-    mappers = new Map();
-    snapshotGenerators = new Map();
-    pkGetters = new Map();
-    pkGettersConverted = new Map();
-    pkSerializers = new Map();
-    tmpIndex = 0;
+    #comparators = new Map();
+    #mappers = new Map();
+    #snapshotGenerators = new Map();
+    #pkGetters = new Map();
+    #pkGettersConverted = new Map();
+    #pkSerializers = new Map();
+    #tmpIndex = 0;
+    #metadata;
+    #platform;
+    #config;
     constructor(metadata, platform, config) {
-        this.metadata = metadata;
-        this.platform = platform;
-        this.config = config;
+        this.#metadata = metadata;
+        this.#platform = platform;
+        this.#config = config;
     }
     /**
      * Computes difference between two entities.
@@ -51,7 +51,7 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
-        const exists = this.pkGetters.get(meta);
+        const exists = this.#pkGetters.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -93,15 +93,15 @@ export class EntityComparator {
         }
         const code = `// compiled pk getter for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
         const fnKey = `pkGetter-${meta.uniqueName}`;
-        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.pkGetters.set(meta, pkSerializer);
+        const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#pkGetters.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetterConverted(meta) {
-        const exists = this.pkGettersConverted.get(meta);
+        const exists = this.#pkGettersConverted.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -144,22 +144,22 @@ export class EntityComparator {
         const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n` +
             `return function(entity) {\n${lines.join('\n')}\n}`;
         const fnKey = `pkGetterConverted-${meta.uniqueName}`;
-        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.pkGettersConverted.set(meta, pkSerializer);
+        const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkSerializer(meta) {
-        const exists = this.pkSerializers.get(meta);
+        const exists = this.#pkSerializers.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
-        context.set('getCompositeKeyValue', (val) => Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.platform)));
+        context.set('getCompositeKeyValue', (val) => Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.#platform)));
         context.set('getPrimaryKeyHash', (val) => Utils.getPrimaryKeyHash(Utils.asArray(val)));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const pks = entity.__helper.__pk ? getCompositeKeyValue(entity.__helper.__pk) : [`);
@@ -186,7 +186,7 @@ export class EntityComparator {
             }
             else if (prop.customType) {
                 const convertorKey = this.registerCustomType(meta.properties[pk], context);
-                const idx = this.tmpIndex++;
+                const idx = this.#tmpIndex++;
                 lines.push(`  const val_${idx} = convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)});`);
                 lines.push(`  return getPrimaryKeyHash(val_${idx});`);
             }
@@ -196,23 +196,23 @@ export class EntityComparator {
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
         const fnKey = `pkSerializer-${meta.uniqueName}`;
-        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.pkSerializers.set(meta, pkSerializer);
+        const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator(entityName) {
-        const meta = this.metadata.find(entityName);
-        const exists = this.snapshotGenerators.get(meta);
+        const meta = this.#metadata.find(entityName);
+        const exists = this.#snapshotGenerators.get(meta);
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
         context.set('clone', clone);
-        context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
+        context.set('cloneEmbeddable', (o) => this.#platform.cloneEmbeddable(o)); // do not clone prototypes
         if (meta.root.inheritanceType === 'sti' && meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
         }
@@ -226,8 +226,8 @@ export class EntityComparator {
             .forEach(prop => lines.push(this.getPropertySnapshot(meta, prop, context, this.wrap(prop.name), this.wrap(prop.name), [prop.name])));
         const code = `return function(entity) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
         const fnKey = `snapshotGenerator-${meta.uniqueName}`;
-        const snapshotGenerator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.snapshotGenerators.set(meta, snapshotGenerator);
+        const snapshotGenerator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
     }
     /**
@@ -271,21 +271,21 @@ export class EntityComparator {
         if (part.length === 1) {
             return this.formatCompositeKeyPart(part[0]);
         }
-        const formatted = part.map(this.formatCompositeKeyPart).join(', ');
+        const formatted = part.map(p => this.formatCompositeKeyPart(p)).join(', ');
         return `[${formatted}]`;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getResultMapper(meta) {
-        const exists = this.mappers.get(meta);
+        const exists = this.#mappers.get(meta);
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
         context.set('PolymorphicRef', PolymorphicRef);
-        const tz = this.platform.getTimezone();
+        const tz = this.#platform.getTimezone();
         const parseDate = (key, value, padding = '') => {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
             lines.push(`${padding}      ${key} = ${value};`);
@@ -345,15 +345,15 @@ export class EntityComparator {
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
-                else if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
+                else if (prop.runtimeType === 'Date' && !this.#platform.isNumericProperty(prop)) {
                     lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
-                    context.set('parseDate', (value) => this.platform.parseDate(value));
+                    context.set('parseDate', (value) => this.#platform.parseDate(value));
                     parseDate('ret' + this.wrap(prop.name), this.propName(prop.fieldNames[0]), padding);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
                 else if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
-                    const idx = this.tmpIndex++;
+                    const idx = this.#tmpIndex++;
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
                         const item = parseJsonSafe(data);
                         if (Array.isArray(item)) {
@@ -392,8 +392,8 @@ export class EntityComparator {
         const code = `// compiled mapper for entity ${meta.className}\n` +
             `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
         const fnKey = `resultMapper-${meta.uniqueName}`;
-        const resultMapper = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.mappers.set(meta, resultMapper);
+        const resultMapper = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#mappers.set(meta, resultMapper);
         return resultMapper;
     }
     getPropertyCondition(path) {
@@ -404,7 +404,7 @@ export class EntityComparator {
         let tail = '';
         return parts
             .map(k => {
-            if (k.match(/^\[idx_\d+]$/)) {
+            if (/^\[idx_\d+]$/.exec(k)) {
                 tail += k;
                 return '';
             }
@@ -419,7 +419,7 @@ export class EntityComparator {
         const entityKey = path.map(k => this.wrap(k)).join('');
         const ret = [];
         const padding = ' '.repeat(level * 2);
-        const idx = this.tmpIndex++;
+        const idx = this.#tmpIndex++;
         ret.push(`${padding}if (Array.isArray(entity${entityKey})) {`);
         ret.push(`${padding}  ret${dataKey} = [];`);
         ret.push(`${padding}  entity${entityKey}.forEach((_, idx_${idx}) => {`);
@@ -445,7 +445,7 @@ export class EntityComparator {
     getEmbeddedPropertySnapshot(meta, prop, context, level, path, dataKey, object = prop.object) {
         const padding = ' '.repeat(level * 2);
         const nullCond = `entity${path.map(k => this.wrap(k)).join('')} === null`;
-        let ret = `${level === 1 ? '' : '\n'}`;
+        let ret = level === 1 ? '' : '\n';
         if (object) {
             ret += `${padding}if (${nullCond}) ret${dataKey} = null;\n`;
         }
@@ -517,7 +517,7 @@ export class EntityComparator {
             if (Raw.isKnownFragment(val)) {
                 return val;
             }
-            return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
+            return prop.customType.convertToDatabaseValue(val, this.#platform, { mode: 'serialization' });
         });
         return convertorKey;
     }
@@ -602,7 +602,7 @@ export class EntityComparator {
             return (ret + `    ret${dataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap}));\n  }\n`);
         }
         if (prop.runtimeType === 'Date') {
-            context.set('processDateProperty', this.platform.processDateProperty.bind(this.platform));
+            context.set('processDateProperty', this.#platform.processDateProperty.bind(this.#platform));
             return ret + `    ret${dataKey} = clone(processDateProperty(entity${entityKey}${unwrap}));\n  }\n`;
         }
         return ret + `    ret${dataKey} = clone(entity${entityKey}${unwrap});\n  }\n`;
@@ -611,8 +611,8 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getEntityComparator(entityName) {
-        const meta = this.metadata.find(entityName);
-        const exists = this.comparators.get(meta);
+        const meta = this.#metadata.find(entityName);
+        const exists = this.#comparators.get(meta);
         if (exists) {
             return exists;
         }
@@ -637,8 +637,8 @@ export class EntityComparator {
         const code = `// compiled comparator for entity ${meta.className}\n` +
             `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
         const fnKey = `comparator-${meta.uniqueName}`;
-        const comparator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.comparators.set(meta, comparator);
+        const comparator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#comparators.set(meta, comparator);
         return comparator;
     }
     getGenericComparator(prop, cond) {
@@ -669,7 +669,7 @@ export class EntityComparator {
         }
         if (prop.customType) {
             if (prop.customType.compareValues) {
-                const idx = this.tmpIndex++;
+                const idx = this.#tmpIndex++;
                 context.set(`compareValues_${idx}`, (a, b) => {
                     if (Raw.isKnownFragment(a) || Raw.isKnownFragment(b)) {
                         return Raw.getKnownFragment(a) === Raw.getKnownFragment(b);
@@ -708,10 +708,10 @@ export class EntityComparator {
         return this.getGenericComparator(this.wrap(prop.name), `!equals(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
     }
     wrap(key) {
-        if (key.match(/^\[.*]$/)) {
+        if (/^\[.*]$/.exec(key)) {
             return key;
         }
-        return key.match(/^\w+$/) ? `.${key}` : `['${key}']`;
+        return /^\w+$/.exec(key) ? `.${key}` : `['${key}']`;
     }
     safeKey(key) {
         return key.replace(/\W/g, '_');

package/utils/QueryHelper.d.ts

@@ -25,8 +25,23 @@ export declare class QueryHelper {
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;
     private static processJsonCondition;
-    private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
+    /**
+     * 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.
+     */
+    private static convertCompositeEntityRefs;
+    /**
+     * 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.
+     */
+    private static extractJoinColumnValues;
+    /**
+     * Extracts the value for a specific column from an entity by finding which PK property
+     * owns that column and recursively traversing FK references.
+     */
+    private static extractColumnValue;
     /**
      * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
      * RawQueryFragment symbol keys are never deduped (each is unique).

package/utils/QueryHelper.js

@@ -133,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);
         }
@@ -183,7 +186,7 @@ export class QueryHelper {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
             // oxfmt-ignore
-            const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
+            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);
             }
@@ -280,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('.');
@@ -312,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/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;

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

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-rc.3';
+    static #ORM_VERSION = '7.0.1-dev.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -543,7 +543,7 @@ export class Utils {
             !!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.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
@@ -559,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';
         }
@@ -613,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) {
@@ -677,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 */
         }

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/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

@@ -150,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

@@ -101,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('.');