@mikro-orm/core 7.0.0-rc.1 → 7.0.0-rc.3

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/EntityRepository.d.ts

@@ -150,7 +150,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = '*', Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
+    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = never, Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
     /**
      * Creates new instance of given entity and populates it with given data.
      * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.

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.d.ts

@@ -1,6 +1,6 @@
 import type { PopulatePath } from '../enums.js';
 import type { EntityManager } from '../EntityManager.js';
-import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, SerializeDTO, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 import { Reference } from './Reference.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
@@ -44,12 +44,12 @@ export declare class WrappedEntity<Entity extends object> {
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject<Ignored extends EntityKey<Entity> = never>(ignoreFields?: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
-    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): SerializeDTO<Entity, Hint, Exclude>;
     toPOJO(): EntityDTO<Entity>;
     toJSON(...args: any[]): EntityDictionary<Entity>;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
-    populate<Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     hasPrimaryKey(): boolean;
     getPrimaryKey(convertCustomTypes?: boolean): Primary<Entity> | null;
     getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;

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) {