@mikro-orm/core 7.0.0-dev.300 → 7.0.0-dev.302

package/utils/AbstractMigrator.js

@@ -49,9 +49,7 @@ export class AbstractMigrator {
         await this.init();
         const all = await this.discoverMigrations();
         const executed = new Set(await this.storage.executed());
-        return all
-            .filter(m => !executed.has(m.name))
-            .map(m => ({ name: m.name, path: m.path }));
+        return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
     }
     /**
      * @inheritDoc
@@ -74,7 +72,7 @@ export class AbstractMigrator {
             const { fs } = await import('@mikro-orm/core/fs-utils');
             this.detectSourceFolder(fs);
             /* v8 ignore next */
-            const key = (this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs) ? 'pathTs' : 'path';
+            const key = this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs ? 'pathTs' : 'path';
             this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
             fs.ensureDir(this.absolutePath);
         }
@@ -132,7 +130,7 @@ export class AbstractMigrator {
         const buildDir = fs.pathExists(baseDir + '/build');
         // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
         /* v8 ignore next */
-        const path = distDir ? './dist' : (buildDir ? './build' : './src');
+        const path = distDir ? './dist' : buildDir ? './build' : './src';
         // only if the user did not provide any values and if the default path does not exist
         if (!this.options.path && !this.options.pathTs && !exists) {
             this.options.path = `${path}/migrations`;

package/utils/AbstractSchemaGenerator.js

@@ -112,7 +112,8 @@ export class AbstractSchemaGenerator {
             }
             meta = metadata.pop();
         }
-        return calc.sort()
+        return calc
+            .sort()
             .map(cls => this.metadata.getById(cls))
             .filter(meta => {
             const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());

package/utils/AsyncContext.js

@@ -13,7 +13,7 @@ function createFallbackAsyncContext() {
     console.warn('AsyncLocalStorage not available');
     return {
         getStore: () => store,
-        enterWith: value => store = value,
+        enterWith: value => (store = value),
         run: (value, cb) => {
             const prev = store;
             store = value;

package/utils/Configuration.js

@@ -262,7 +262,10 @@ export class Configuration {
      * Gets instance of CacheAdapter for result cache. (cached)
      */
     getResultCacheAdapter() {
-        return this.getCachedService(this.options.resultCache.adapter, { expiration: this.options.resultCache.expiration, ...this.options.resultCache.options });
+        return this.getCachedService(this.options.resultCache.adapter, {
+            expiration: this.options.resultCache.expiration,
+            ...this.options.resultCache.options,
+        });
     }
     /**
      * Gets EntityRepository class to be instantiated.
@@ -338,10 +341,10 @@ export class Configuration {
     validateOptions() {
         /* v8 ignore next */
         if ('type' in this.options) {
-            throw new Error('The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export default defineConfig({ ... })`).');
+            throw new Error("The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from '@mikro-orm/mysql'; export default defineConfig({ ... })`).");
         }
         if (!this.options.driver) {
-            throw new Error('No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export defineConfig({ ... })`).');
+            throw new Error("No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from '@mikro-orm/mysql'; export defineConfig({ ... })`).");
         }
         if (!this.options.dbName && !this.options.clientUrl) {
             throw new Error('No database specified, please fill in `dbName` or `clientUrl` option');
@@ -349,7 +352,8 @@ export class Configuration {
         if (this.options.entities.length === 0 && this.options.discovery.warnWhenNoEntities) {
             throw new Error('No entities found, please use `entities` option');
         }
-        if (typeof this.options.driverOptions === 'function' && this.options.driverOptions.constructor.name === 'AsyncFunction') {
+        if (typeof this.options.driverOptions === 'function' &&
+            this.options.driverOptions.constructor.name === 'AsyncFunction') {
             throw new Error('`driverOptions` callback cannot be async');
         }
     }

package/utils/Cursor.js

@@ -118,7 +118,7 @@ export class Cursor {
                 value = value.unwrap();
             }
             if (object) {
-                return ({ [prop]: value });
+                return { [prop]: value };
             }
             return value;
         };
@@ -167,7 +167,9 @@ export class Cursor {
                 }
                 const prop = meta.properties[key];
                 /* v8 ignore next */
-                if (!prop || !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
+                if (!prop ||
+                    !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+                        (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                     continue;
                 }
                 ret.push([prop.name, order[prop.name]]);

package/utils/DataloaderUtils.js

@@ -101,26 +101,27 @@ export class DataloaderUtils {
             const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
             const meta = em.getMetadata().getByUniqueName(uniqueName);
-            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0 ?
-                {
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0
+                ? {
                     $and: [
                         {
                             $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                                return ({ [prop]: Array.from(pks) });
+                                return { [prop]: Array.from(pks) };
                             }),
                         },
                         opts.where,
                     ],
-                } : {
-                // The entries of the filter Map will be used as the values of the $or operator
-                $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                    return ({ [prop]: Array.from(pks) });
-                }),
-            }, {
+                }
+                : {
+                    // The entries of the filter Map will be used as the values of the $or operator
+                    $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                        return { [prop]: Array.from(pks) };
+                    }),
+                }, {
                 ...opts,
                 // We need to populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s)
                 populate: [
-                    ...(opts.populate === false ? [] : opts.populate ?? []),
+                    ...(opts.populate === false ? [] : (opts.populate ?? [])),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
                     prop => meta.properties[prop]?.ref !== true),
@@ -207,7 +208,9 @@ export class DataloaderUtils {
                     options.refresh ??= c[1]?.refresh;
                 }
                 options.where = wrap({ $or });
-                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                const r = await em
+                    .getEntityLoader()
+                    .findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
                 ret.push(...r);
             }
             return ret;
@@ -224,7 +227,7 @@ export class DataloaderUtils {
         }
         catch {
             /* v8 ignore next */
-            throw new Error('DataLoader is not found, make sure `dataloader` package is installed in your project\'s dependencies.');
+            throw new Error("DataLoader is not found, make sure `dataloader` package is installed in your project's dependencies.");
         }
     }
 }

package/utils/EntityComparator.js

@@ -1,6 +1,6 @@
 import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
-import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
+import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils, } from './Utils.js';
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
@@ -91,8 +91,7 @@ export class EntityComparator {
             }
             lines.push(`  return entity${this.wrap(pk)};`);
         }
-        const code = `// compiled pk getter for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        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);
@@ -142,8 +141,8 @@ export class EntityComparator {
                 lines.push(`  return entity${this.wrap(pk)};`);
             }
         }
-        const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        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);
@@ -195,8 +194,7 @@ export class EntityComparator {
                 lines.push(`  return '' + entity${this.wrap(pk)};`);
             }
         }
-        const code = `// compiled pk serializer for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        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);
@@ -359,7 +357,7 @@ export class EntityComparator {
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
                         const item = parseJsonSafe(data);
                         if (Array.isArray(item)) {
-                            return item.map(row => row == null ? row : this.getResultMapper(prop.targetMeta)(row));
+                            return item.map(row => (row == null ? row : this.getResultMapper(prop.targetMeta)(row)));
                         }
                         return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
@@ -391,8 +389,8 @@ export class EntityComparator {
             mapEntityProperties(meta);
         }
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined) ret[k] = result[k]; }`);
-        const code = `// compiled mapper for entity ${meta.className}\n`
-            + `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
+        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);
@@ -411,7 +409,7 @@ export class EntityComparator {
                 return '';
             }
             const mapped = `typeof entity${tail ? '.' + tail : ''}${this.wrap(k)} !== 'undefined'`;
-            tail += tail ? ('.' + k) : k;
+            tail += tail ? '.' + k : k;
             return mapped;
         })
             .filter(k => k)
@@ -453,12 +451,16 @@ export class EntityComparator {
         }
         else {
             ret += `${padding}if (${nullCond}) {\n`;
-            ret += meta.props.filter(p => p.embedded?.[0] === prop.name
-                // object for JSON embeddable
-                && (p.object || (p.persist !== false))).map(childProp => {
-                const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-                return `${padding}  ret${childDataKey} = null;`;
-            }).join('\n') + `\n`;
+            ret +=
+                meta.props
+                    .filter(p => p.embedded?.[0] === prop.name &&
+                    // object for JSON embeddable
+                    (p.object || p.persist !== false))
+                    .map(childProp => {
+                    const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    return `${padding}  ret${childDataKey} = null;`;
+                })
+                    .join('\n') + `\n`;
             ret += `${padding}}\n`;
         }
         const cond = `entity${path.map(k => this.wrap(k)).join('')} != null`;
@@ -475,28 +477,34 @@ export class EntityComparator {
             }
             return true;
         }
-        ret += meta.props.filter(p => p.embedded?.[0] === prop.name
-            // object for JSON embeddable
-            && (p.object || (p.persist !== false))).map(childProp => {
-            const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-            const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
-            const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
-            if (childProp.kind === ReferenceKind.EMBEDDED) {
-                return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
-            }
-            if (childProp.kind !== ReferenceKind.SCALAR) {
-                return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
-                    .split('\n').map(l => padding + l).join('\n');
-            }
-            if (shouldProcessCustomType(childProp)) {
-                const convertorKey = this.registerCustomType(childProp, context);
-                if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
-                    return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
+        ret +=
+            meta.props
+                .filter(p => p.embedded?.[0] === prop.name &&
+                // object for JSON embeddable
+                (p.object || p.persist !== false))
+                .map(childProp => {
+                const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
+                const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
+                if (childProp.kind === ReferenceKind.EMBEDDED) {
+                    return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
                 }
-                return `${padding}  if (${childCond}) ret${childDataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${childEntityKey}));`;
-            }
-            return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
-        }).join('\n') + `\n`;
+                if (childProp.kind !== ReferenceKind.SCALAR) {
+                    return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
+                        .split('\n')
+                        .map(l => padding + l)
+                        .join('\n');
+                }
+                if (shouldProcessCustomType(childProp)) {
+                    const convertorKey = this.registerCustomType(childProp, context);
+                    if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
+                        return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
+                    }
+                    return `${padding}  if (${childCond}) ret${childDataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${childEntityKey}));`;
+                }
+                return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
+            })
+                .join('\n') + `\n`;
         if (this.shouldSerialize(prop, dataKey)) {
             return `${ret + padding}  ret${dataKey} = cloneEmbeddable(ret${dataKey});\n${padding}}`;
         }
@@ -591,7 +599,7 @@ export class EntityComparator {
             if (['number', 'string', 'boolean', 'bigint'].includes(prop.customType.compareAsType().toLowerCase())) {
                 return ret + `    ret${dataKey} = convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap});\n  }\n`;
             }
-            return ret + `    ret${dataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap}));\n  }\n`;
+            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));
@@ -626,22 +634,22 @@ export class EntityComparator {
             }
         }
         lines.push(`}`);
-        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 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);
         return comparator;
     }
     getGenericComparator(prop, cond) {
-        return `  if (current${prop} === null && last${prop} === undefined) {\n` +
+        return (`  if (current${prop} === null && last${prop} === undefined) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (current${prop} == null && last${prop} == null) {\n\n` +
             `  } else if ((current${prop} != null && last${prop} == null) || (current${prop} == null && last${prop} != null)) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (${cond}) {\n` +
             `    diff${prop} = current${prop};\n` +
-            `  }\n`;
+            `  }\n`);
     }
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();

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;
@@ -139,7 +149,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 +182,12 @@ export class QueryHelper {
             if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 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';
             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 +214,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 +266,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));

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

@@ -183,7 +183,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

@@ -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>;