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

package/entity/EntityAssigner.js

@@ -71,7 +71,10 @@ export class EntityAssigner {
             value = customType.convertToJSValue(value, options.platform);
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
-            if (options.updateNestedEntities && Object.hasOwn(entity, propName) && Utils.isEntity(entity[propName], true) && Utils.isPlainObject(value)) {
+            if (options.updateNestedEntities &&
+                Object.hasOwn(entity, propName) &&
+                Utils.isEntity(entity[propName], true) &&
+                Utils.isPlainObject(value)) {
                 const unwrappedEntity = Reference.unwrapReference(entity[propName]);
                 const wrapped = helper(unwrappedEntity);
                 if (options.updateByPrimaryKey) {
@@ -95,12 +98,14 @@ export class EntityAssigner {
         }
         if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
             validateProperty(prop, value, entity);
-            return entity[prop.name] = value;
+            return (entity[prop.name] = value);
         }
         if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
             return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
         }
-        if (options.mergeObjectProperties && Utils.isPlainObject(entity[propName]) && Utils.isPlainObject(value)) {
+        if (options.mergeObjectProperties &&
+            Utils.isPlainObject(entity[propName]) &&
+            Utils.isPlainObject(value)) {
             entity[propName] ??= {};
             entity[propName] = Utils.merge({}, entity[propName], value);
         }
@@ -141,7 +146,9 @@ export class EntityAssigner {
             entity[prop.name] = Reference.wrapReference(value, prop);
         }
         else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = prop.mapToPk ? value : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
+            entity[prop.name] = prop.mapToPk
+                ? value
+                : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
         }
         else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
             entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
@@ -174,7 +181,10 @@ export class EntityAssigner {
                 return this.createCollectionItem(item, em, prop, invalid, options);
             }
             /* v8 ignore next */
-            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && helper(collection[idx])?.isInitialized()) {
+            if (options.updateNestedEntities &&
+                !options.updateByPrimaryKey &&
+                collection[idx] &&
+                helper(collection[idx])?.isInitialized()) {
                 return EntityAssigner.assign(collection[idx], item, options);
             }
             return this.createCollectionItem(item, em, prop, invalid, options);
@@ -186,7 +196,8 @@ export class EntityAssigner {
         if (Array.isArray(value)) {
             collection.set(items);
         }
-        else { // append to the collection in case of assigning a single value instead of array
+        else {
+            // append to the collection in case of assigning a single value instead of array
             collection.add(items);
         }
     }
@@ -207,11 +218,12 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
-        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
-            convertCustomTypes: options.convertCustomTypes,
-            newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
-        });
-        entity[propName] = (options.mergeEmbeddedProperties ? (entity[propName] || create()) : create());
+        const create = () => EntityAssigner.validateEM(em) &&
+            em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
+                convertCustomTypes: options.convertCustomTypes,
+                newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
+            });
+        entity[propName] = (options.mergeEmbeddedProperties ? entity[propName] || create() : create());
         Object.keys(value).forEach(key => {
             EntityAssigner.assignProperty(entity[propName], key, prop.embeddedProps, value, options);
         });

package/entity/EntityFactory.js

@@ -70,11 +70,15 @@ export class EntityFactory {
                         if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                             continue;
                         }
-                        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+                        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                            Utils.isPlainObject(data[prop.name])) {
                             data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                         }
                         if (prop.customType instanceof JsonType && this.platform.convertsJsonAutomatically()) {
-                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, {
+                                key: prop.name,
+                                mode: 'hydration',
+                            });
                         }
                     }
                 }
@@ -111,23 +115,28 @@ export class EntityFactory {
         const originalEntityData = helper(entity).__originalEntityData ?? {};
         const diff = this.comparator.diffEntities(meta.class, originalEntityData, existsData);
         // version properties are not part of entity snapshots
-        if (meta.versionProperty && data[meta.versionProperty] && data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
+        if (meta.versionProperty &&
+            data[meta.versionProperty] &&
+            data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
         const diff2 = this.comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
         Utils.keys(diff).forEach(key => delete diff2[key]);
-        Utils.keys(diff2).filter(key => {
+        Utils.keys(diff2)
+            .filter(key => {
             // ignore null values if there is already present non-null value
             if (existsData[key] != null) {
                 return diff2[key] == null;
             }
             return diff2[key] === undefined;
-        }).forEach(key => delete diff2[key]);
+        })
+            .forEach(key => delete diff2[key]);
         // but always add collection properties and formulas if they are part of the `data`
         Utils.keys(data)
-            .filter(key => meta.properties[key]?.formula || [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
-            .forEach(key => diff2[key] = data[key]);
+            .filter(key => meta.properties[key]?.formula ||
+            [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
+            .forEach(key => (diff2[key] = data[key]));
         // rehydrated with the new values, skip those changed by user
         // use full hydration if the entity is already initialized, even if the caller used `initialized: false`
         // (e.g. from createReference), otherwise scalar properties in diff2 won't be applied
@@ -137,10 +146,15 @@ export class EntityFactory {
         const nullVal = this.config.get('forceUndefined') ? undefined : null;
         Utils.keys(diff2).forEach(key => {
             const prop = meta.properties[key];
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name])) {
+                // oxfmt-ignore
                 diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
             }
-            if (!options.convertCustomTypes && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
+            if (!options.convertCustomTypes &&
+                [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) &&
+                prop.customType?.ensureComparable(meta, prop) &&
+                diff2[key] != null) {
                 const converted = prop.customType.convertToJSValue(diff2[key], this.platform, { force: true });
                 diff2[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { fromQuery: true });
             }
@@ -149,7 +163,8 @@ export class EntityFactory {
         });
         // in case of joined loading strategy, we need to cascade the merging to possibly loaded relations manually
         meta.relations.forEach(prop => {
-            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && Array.isArray(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
+                Array.isArray(data[prop.name])) {
                 // instead of trying to match the collection items (which could easily fail if the collection was loaded with different ordering),
                 // we just create the entity from scratch, which will automatically pick the right one from the identity map and call `mergeData` on it
                 data[prop.name]
@@ -157,7 +172,10 @@ export class EntityFactory {
                     .forEach(child => this.create(prop.targetMeta.class, child, options)); // we can ignore the value, we just care about the `mergeData` call
                 return;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name]) && entity[prop.name] && helper(entity[prop.name]).__initialized) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name]) &&
+                entity[prop.name] &&
+                helper(entity[prop.name]).__initialized) {
                 this.create(prop.targetMeta.class, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
@@ -356,7 +374,9 @@ export class EntityFactory {
                     if (!options.convertCustomTypes || !prop.customType || tmp[prop.name] == null) {
                         continue;
                     }
-                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(tmp[prop.name]) && !Utils.extractPK(tmp[prop.name], prop.targetMeta, true)) {
+                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                        Utils.isPlainObject(tmp[prop.name]) &&
+                        !Utils.extractPK(tmp[prop.name], prop.targetMeta, true)) {
                         tmp[prop.name] = Reference.wrapReference(this.create(prop.targetMeta.class, tmp[prop.name], options), prop);
                     }
                     else if (prop.kind === ReferenceKind.SCALAR) {

package/entity/EntityHelper.js

@@ -31,7 +31,8 @@ export class EntityHelper {
             EntityHelper.defineProperties(meta, fork);
         }
         const prototype = meta.prototype;
-        if (!prototype.toJSON) { // toJSON can be overridden
+        if (!prototype.toJSON) {
+            // toJSON can be overridden
             Object.defineProperty(prototype, 'toJSON', {
                 value: function (...args) {
                     // Guard against being called on the prototype itself (e.g. by serializers
@@ -54,6 +55,7 @@ export class EntityHelper {
      * property on the entity instance, so shadowing the prototype setter.
      */
     static defineBaseProperties(meta, prototype, em) {
+        // oxfmt-ignore
         const helperParams = meta.embeddable || meta.virtual ? [] : [em.getComparator().getPkGetter(meta), em.getComparator().getPkSerializer(meta), em.getComparator().getPkGetterConverted(meta)];
         Object.defineProperties(prototype, {
             __entity: { value: !meta.embeddable, configurable: true },
@@ -83,10 +85,9 @@ export class EntityHelper {
      * than on its prototype. Thanks to this we still have those properties enumerable (e.g. part of `Object.keys(entity)`).
      */
     static defineProperties(meta, em) {
-        Object
-            .values(meta.properties)
-            .forEach(prop => {
+        Object.values(meta.properties).forEach(prop => {
             const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            // oxfmt-ignore
             const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 Object.defineProperty(meta.prototype, prop.name, {
@@ -136,9 +137,7 @@ export class EntityHelper {
             }
             // ensure we dont have internal symbols in the POJO
             [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps, EntityName].forEach(sym => delete object[sym]);
-            meta.props
-                .filter(prop => object[prop.name] === undefined)
-                .forEach(prop => delete object[prop.name]);
+            meta.props.filter(prop => object[prop.name] === undefined).forEach(prop => delete object[prop.name]);
             const ret = inspect(object, { depth });
             let name = this.constructor.name;
             const showEM = ['true', 't', '1'].includes(getEnv('MIKRO_ORM_LOG_EM_ID')?.toLowerCase() ?? '');
@@ -166,6 +165,7 @@ export class EntityHelper {
             set(val) {
                 const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                 const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                // oxfmt-ignore
                 if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
                     old[prop.inversedBy].removeWithoutPropagation(this);
                 }
@@ -197,6 +197,7 @@ export class EntityHelper {
             if ((prop2.inversedBy || prop2.mappedBy) !== prop.name) {
                 continue;
             }
+            // oxfmt-ignore
             if (prop2.targetMeta.abstract ? prop2.targetMeta.root.class !== meta.root.class : prop2.targetMeta.class !== meta.class) {
                 continue;
             }
@@ -228,7 +229,10 @@ export class EntityHelper {
     static propagateOneToOne(entity, owner, prop, prop2, value, old) {
         helper(entity).__pk = helper(entity).getPrimaryKey();
         // the inverse side will be changed on the `value` too, so we need to clean-up and schedule orphan removal there too
-        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference.unwrapReference(value[prop2.name]) !== entity) {
+        if (!prop.primary &&
+            !prop2.mapToPk &&
+            value?.[prop2.name] != null &&
+            Reference.unwrapReference(value[prop2.name]) !== entity) {
             const other = Reference.unwrapReference(value[prop2.name]);
             delete helper(other).__data[prop.name];
             if (prop2.orphanRemoval) {

package/entity/EntityLoader.js

@@ -29,7 +29,7 @@ export class EntityLoader {
             throw ValidationError.notDiscoveredEntity(entity, meta, 'populate');
         }
         const references = entities.filter(e => !helper(e).isInitialized());
-        const visited = options.visited ??= new Set();
+        const visited = (options.visited ??= new Set());
         options.where ??= {};
         options.orderBy ??= {};
         options.lookup ??= true;
@@ -59,6 +59,7 @@ export class EntityLoader {
     normalizePopulate(entityName, populate, strategy, lookup = true, exclude) {
         const meta = this.metadata.find(entityName);
         let normalized = Utils.asArray(populate).map(field => {
+            // oxfmt-ignore
             return typeof field === 'boolean' || field.field === PopulatePath.ALL ? { all: !!field, field: meta.primaryKeys[0] } : field;
         });
         if (normalized.some(p => p.all)) {
@@ -89,6 +90,7 @@ export class EntityLoader {
      */
     mergeNestedPopulate(populate) {
         const tmp = populate.reduce((ret, item) => {
+            /* v8 ignore next */
             if (item.field === PopulatePath.ALL) {
                 return ret;
             }
@@ -125,7 +127,8 @@ export class EntityLoader {
             }
         }
         if (prop.kind === ReferenceKind.SCALAR && prop.lazy) {
-            const filtered = entities.filter(e => options.refresh || (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
+            const filtered = entities.filter(e => options.refresh ||
+                (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
             if (options.ignoreLazyScalarProperties || filtered.length === 0) {
                 return entities;
             }
@@ -137,7 +140,8 @@ export class EntityLoader {
         }
         const filtered = this.filterCollections(entities, field, options, ref);
         const innerOrderBy = Utils.asArray(options.orderBy)
-            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils.isObject(orderBy[prop.name]))
+            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) ||
+            Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
         const where = await this.extractChildCondition(options, prop);
         if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
@@ -163,7 +167,13 @@ export class EntityLoader {
         const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
         const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, fields } = options;
         await this.em.find(meta.class, where, {
-            filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
+            filters,
+            convertCustomTypes,
+            lockMode,
+            strategy,
+            populateWhere,
+            connectionType,
+            logging,
             fields: fields,
             populate: [],
         });
@@ -260,7 +270,8 @@ export class EntityLoader {
                 entity[field].hydrate(items, true, partial);
             }
         }
-        else { // owning side of M:N without pivot table needs to be reordered
+        else {
+            // owning side of M:N without pivot table needs to be reordered
             for (const entity of filtered) {
                 const order = !customOrder ? [...entity[prop.name].getItems(false)] : []; // copy order of references
                 const items = children.filter(child => entity[prop.name].contains(child, false));
@@ -301,7 +312,7 @@ export class EntityLoader {
         if (!schema && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             schema = children.find(e => e.__helper.__schema)?.__helper.__schema;
         }
-        const ids = Utils.unique(children.map(e => prop.targetKey ? e[prop.targetKey] : e.__helper.getPrimaryKey()));
+        const ids = Utils.unique(children.map(e => (prop.targetKey ? e[prop.targetKey] : e.__helper.getPrimaryKey())));
         let where;
         if (polymorphicOwnerProp && Array.isArray(fk)) {
             const conditions = ids.map(id => {
@@ -315,7 +326,8 @@ export class EntityLoader {
         }
         if (polymorphicOwnerProp) {
             const parentMeta = this.metadata.find(entities[0].constructor);
-            const discriminatorValue = QueryHelper.findDiscriminatorValue(polymorphicOwnerProp.discriminatorMap, parentMeta.class) ?? parentMeta.tableName;
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(polymorphicOwnerProp.discriminatorMap, parentMeta.class) ??
+                parentMeta.tableName;
             const discriminatorColumn = polymorphicOwnerProp.fieldNames[0];
             where = { $and: [where, { [discriminatorColumn]: discriminatorValue }] };
         }
@@ -331,11 +343,20 @@ export class EntityLoader {
         }
         const orderBy = QueryHelper.mergeOrderBy(options.orderBy, prop.orderBy);
         const items = await this.em.find(meta.class, where, {
-            filters, convertCustomTypes, lockMode, populateWhere, logging,
+            filters,
+            convertCustomTypes,
+            lockMode,
+            populateWhere,
+            logging,
             orderBy,
             populate: populate.children ?? populate.all ?? [],
-            exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
-            strategy, fields, schema, connectionType,
+            exclude: Array.isArray(options.exclude)
+                ? Utils.extractChildElements(options.exclude, prop.name)
+                : options.exclude,
+            strategy,
+            fields,
+            schema,
+            connectionType,
             // @ts-ignore not a public option, will be propagated to the populate call
             refresh: refresh && !children.every(item => options.visited.has(item)),
             // @ts-ignore not a public option, will be propagated to the populate call
@@ -355,6 +376,7 @@ export class EntityLoader {
                 if (!ref) {
                     continue;
                 }
+                // oxfmt-ignore
                 const keyValue = '' + (Reference.isReference(ref) ? ref.unwrap()[prop.targetKey] : ref[prop.targetKey]);
                 const loadedItem = itemsByKey.get(keyValue);
                 if (loadedItem) {
@@ -367,7 +389,7 @@ export class EntityLoader {
             const itemsMap = new Set();
             const childrenMap = new Set();
             // Use targetKey value if set, otherwise use serialized PK
-            const getKey = (e) => prop.targetKey ? '' + e[prop.targetKey] : helper(e).getSerializedPrimaryKey();
+            const getKey = (e) => (prop.targetKey ? '' + e[prop.targetKey] : helper(e).getSerializedPrimaryKey());
             for (const item of items) {
                 /* v8 ignore next */
                 itemsMap.add(getKey(item));
@@ -394,12 +416,16 @@ export class EntityLoader {
         return { items, partial };
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
-        const cond1 = QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.class, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
+        const cond1 = QueryHelper.processWhere({
+            where: { [pk]: { $in: ids } },
+            entityName: meta.class,
+            metadata,
+            platform,
+            convertCustomTypes: !options.convertCustomTypes,
+        });
         const where = { ...options.where };
         Utils.dropUndefinedProperties(where);
-        return where[pk]
-            ? { $and: [cond1, where] }
-            : { ...cond1, ...where };
+        return where[pk] ? { $and: [cond1, where] } : { ...cond1, ...where };
     }
     async populateField(entityName, entities, populate, options) {
         const field = populate.field.split(':')[0];
@@ -436,6 +462,7 @@ export class EntityLoader {
             .filter(orderBy => Utils.isObject(orderBy[prop.name]))
             .map(orderBy => orderBy[prop.name]);
         const { refresh, filters, ignoreLazyScalarProperties, populateWhere, connectionType, logging, schema } = options;
+        // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
         const visited = options.visited;
         for (const entity of entities) {
@@ -451,7 +478,7 @@ export class EntityLoader {
         }
         const populateChildren = async (targetMeta, items) => {
             await this.populate(targetMeta.class, items, populate.children ?? populate.all, {
-                where: await this.extractChildCondition(options, prop, false),
+                where: (await this.extractChildCondition(options, prop, false)),
                 orderBy: innerOrderBy,
                 fields,
                 exclude,
@@ -489,13 +516,14 @@ export class EntityLoader {
         const refresh = options.refresh;
         let where = await this.extractChildCondition(options, prop, true);
         const fields = this.buildFields(options.fields, prop);
+        // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
         const populateFilter = options.populateFilter?.[prop.name];
         const options2 = { ...options, fields, exclude, populateFilter };
         ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
-        options2.populate = (populate?.children ?? []);
+        options2.populate = populate?.children ?? [];
         if (prop.customType) {
-            ids.forEach((id, idx) => ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform()));
+            ids.forEach((id, idx) => (ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform())));
         }
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
@@ -532,7 +560,8 @@ export class EntityLoader {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
-                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
+                    .filter((sub) => sub != null &&
+                    !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
@@ -603,7 +632,8 @@ export class EntityLoader {
                 return a;
             }, []);
         }
-        if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) {
+            // inverse side
             return filtered;
         }
         // MANY_TO_ONE or ONE_TO_ONE
@@ -706,7 +736,10 @@ export class EntityLoader {
             .forEach(prop => {
             const field = this.getRelationName(meta, prop);
             const prefixed = prefix ? `${prefix}.${field}` : field;
-            const nestedPopulate = populate.filter(p => p.field === prop.name).flatMap(p => p.children).filter(Boolean);
+            const nestedPopulate = populate
+                .filter(p => p.field === prop.name)
+                .flatMap(p => p.children)
+                .filter(Boolean);
             const nested = this.lookupEagerLoadedRelationships(prop.targetMeta.class, nestedPopulate, strategy, prefixed, visited.slice(), exclude);
             if (nested.length > 0) {
                 ret.push(...nested);
@@ -716,7 +749,7 @@ export class EntityLoader {
                 ret.push({
                     field: prefixed,
                     // enforce select-in strategy for self-referencing relations
-                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : strategy ?? prop.strategy,
+                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : (strategy ?? prop.strategy),
                 });
             }
         });

package/entity/Reference.d.ts

@@ -73,7 +73,7 @@ export interface LoadReferenceOrFailOptions<T extends object, P extends string =
 /**
  * shortcut for `wrap(entity).toReference()`
  */
-export declare function ref<I extends unknown | Ref<unknown> | undefined | null, T extends I & {}>(entity: I): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>> | AddOptional<typeof entity>;
+export declare function ref<I extends unknown | Ref<unknown> | undefined | null, T extends I & {}>(entity: I): (Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>) | AddOptional<typeof entity>;
 /**
  * shortcut for `Reference.createFromPK(entityType, pk)`
  */

package/entity/Reference.js

@@ -93,7 +93,8 @@ export class Reference {
             await wrapped.__em.populate(this.entity, options.populate, options);
         }
         if (!this.isInitialized() || options.refresh) {
-            if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
+            if (options.dataloader ??
+                [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
                 const dataLoader = await wrapped.__em.getDataLoader('ref');
                 return dataLoader.load([this, options]);
             }
@@ -219,16 +220,44 @@ export class ScalarReference {
 }
 Object.defineProperties(Reference.prototype, {
     __reference: { value: true, enumerable: false },
-    __meta: { get() { return this.entity.__meta; } },
-    __platform: { get() { return this.entity.__platform; } },
-    __helper: { get() { return this.entity.__helper; } },
-    $: { get() { return this.entity; } },
-    get: { get() { return () => this.entity; } },
+    __meta: {
+        get() {
+            return this.entity.__meta;
+        },
+    },
+    __platform: {
+        get() {
+            return this.entity.__platform;
+        },
+    },
+    __helper: {
+        get() {
+            return this.entity.__helper;
+        },
+    },
+    $: {
+        get() {
+            return this.entity;
+        },
+    },
+    get: {
+        get() {
+            return () => this.entity;
+        },
+    },
 });
 Object.defineProperties(ScalarReference.prototype, {
     __scalarReference: { value: true, enumerable: false },
-    $: { get() { return this.value; } },
-    get: { get() { return () => this.value; } },
+    $: {
+        get() {
+            return this.value;
+        },
+    },
+    get: {
+        get() {
+            return () => this.value;
+        },
+    },
 });
 /**
  * shortcut for `wrap(entity).toReference()`

package/entity/WrappedEntity.js

@@ -71,7 +71,11 @@ export class WrappedEntity {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
         }
-        return this.__em.findOne(this.entity.constructor, this.entity, { ...options, refresh: true, schema: this.__schema });
+        return this.__em.findOne(this.entity.constructor, this.entity, {
+            ...options,
+            refresh: true,
+            schema: this.__schema,
+        });
     }
     async populate(populate, options = {}) {
         if (!this.__em) {

package/entity/defineEntity.d.ts

@@ -96,7 +96,7 @@ export interface PropertyChain<Value, Options> {
     serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
     serializedName(serializedName: string): PropertyChain<Value, Options>;
     groups(...groups: string[]): PropertyChain<Value, Options>;
-    customOrder(...customOrder: (string[] | number[] | boolean[])): PropertyChain<Value, Options>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): PropertyChain<Value, Options>;
     extra(extra: string): PropertyChain<Value, Options>;
     ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): PropertyChain<Value, Options>;
     index(index?: boolean | string): PropertyChain<Value, Options>;
@@ -409,7 +409,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Specify a custom order based on the values. (SQL only)
      */
-    customOrder(...customOrder: (string[] | number[] | boolean[])): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
@@ -501,7 +501,7 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
     /** Point to the owning side property name. */
-    mappedBy(mappedBy: (keyof Value) | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
+    mappedBy(mappedBy: keyof Value | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
         kind: '1:m';
     }, IncludeKeysForOneToManyOptions>, IncludeKeysForOneToManyOptions>;
 }
@@ -659,7 +659,7 @@ export interface DefineEntityHooks<T = any> {
 }
 type PropertyValueType = PropertyOptions<any>['type'];
 type InferPropertyValueType<T extends PropertyValueType> = T extends string ? InferTypeByString<T> : T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends ArrayConstructor ? string[] : T extends Constructor<infer TType> ? TType extends Type<infer TValue, any> ? NonNullable<TValue> : TType : T extends Type<infer TValue, any> ? NonNullable<TValue> : any;
-type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<typeof types[T]> : InferColumnType<T>;
+type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<(typeof types)[T]> : InferColumnType<T>;
 type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TValue> : never;
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
 type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
@@ -686,9 +686,7 @@ type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> =
 type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;
 } ? BasePK : never;
-type CombinePrimaryKeys<ChildPK, BasePK> = [
-    ChildPK
-] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
+type CombinePrimaryKeys<ChildPK, BasePK> = [ChildPK] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
     [K in keyof Properties]: MaybeReturnType<Properties[K]> extends {
         '~options': {