@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/entity/Collection.d.ts

@@ -62,7 +62,6 @@ export declare class Collection<T extends object, O extends object = object> {
     init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
     private getEntityManager;
     private createCondition;
-    private createOrderBy;
     private createManyToManyCondition;
     private createLoadCountCondition;
     private checkInitialized;
@@ -104,10 +103,18 @@ export declare class Collection<T extends object, O extends object = object> {
      * Tests for the existence of an element that satisfies the given predicate.
      */
     exists(cb: (item: T) => boolean): boolean;
+    /**
+     * Returns the first element of this collection that satisfies the predicate.
+     */
+    find<S extends T>(cb: (item: T, index: number) => item is S): S | undefined;
     /**
      * Returns the first element of this collection that satisfies the predicate.
      */
     find(cb: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * Extracts a subset of the collection items.
+     */
+    filter<S extends T>(cb: (item: T, index: number) => item is S): S[];
     /**
      * Extracts a subset of the collection items.
      */

package/entity/Collection.js

@@ -83,7 +83,7 @@ export class Collection {
             return this._count = this.length;
         }
         const cond = this.createLoadCountCondition(where ?? {});
-        const count = await em.count(this.property.type, cond, countOptions);
+        const count = await em.count(this.property.targetMeta.class, cond, countOptions);
         if (!where) {
             this._count = count;
         }
@@ -92,15 +92,20 @@ export class Collection {
     async matching(options) {
         const em = this.getEntityManager();
         const { where, ctx, ...opts } = options;
-        opts.orderBy = this.createOrderBy(opts.orderBy);
         let items;
         if (this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
-            const cond = await em.applyFilters(this.property.type, where, options.filters ?? {}, 'read');
+            // M:N via pivot table bypasses em.find(), so merge all 3 levels here
+            opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy, this.property.targetMeta?.orderBy);
+            options.populate = await em.preparePopulate(this.property.targetMeta.class, options);
+            const cond = await em.applyFilters(this.property.targetMeta.class, where, options.filters ?? {}, 'read');
             const map = await em.getDriver().loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
-            items = map[helper(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.type, item, { convertCustomTypes: true }));
+            items = map[helper(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.targetMeta.class, item, { convertCustomTypes: true }));
+            await em.populate(items, options.populate, options);
         }
         else {
-            items = await em.find(this.property.type, this.createCondition(where), opts);
+            // em.find() merges entity-level orderBy, so only merge runtime + relation here
+            opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy);
+            items = await em.find(this.property.targetMeta.class, this.createCondition(where), opts);
         }
         if (options.store) {
             this.hydrate(items, true);
@@ -233,7 +238,7 @@ export class Collection {
         options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
         if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.COLLECTION].includes(em.config.getDataloaderType())) {
             const order = [...this.items]; // copy order of references
-            const orderBy = this.createOrderBy(options.orderBy);
+            const orderBy = QueryHelper.mergeOrderBy(options.orderBy, this.property.orderBy, this.property.targetMeta?.orderBy);
             const customOrder = orderBy.length > 0;
             const pivotTable = this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
             const loader = await em.getDataLoader(pivotTable ? 'm:n' : '1:m');
@@ -297,12 +302,6 @@ export class Collection {
         }
         return cond;
     }
-    createOrderBy(orderBy = []) {
-        if (Utils.isEmpty(orderBy) && this.property.orderBy) {
-            orderBy = this.property.orderBy;
-        }
-        return Utils.asArray(orderBy);
-    }
     createManyToManyCondition(cond) {
         const dict = cond;
         if (this.property.owner || this.property.pivotTable) {
@@ -330,7 +329,7 @@ export class Collection {
     }
     checkInitialized() {
         if (!this.isInitialized()) {
-            throw new Error(`Collection<${this.property.type}> of entity ${this.owner.constructor.name}[${helper(this.owner).getSerializedPrimaryKey()}] not initialized`);
+            throw new Error(`Collection<${this.property.type}> of entity ${helper(this.owner).__meta.name}[${helper(this.owner).getSerializedPrimaryKey()}] not initialized`);
         }
     }
     /**

package/entity/EntityAssigner.js

@@ -77,7 +77,7 @@ export class EntityAssigner {
                 if (options.updateByPrimaryKey) {
                     const pk = Utils.extractPK(value, prop.targetMeta);
                     if (pk) {
-                        const ref = options.em.getReference(prop.type, pk, options);
+                        const ref = options.em.getReference(prop.targetMeta.class, pk, options);
                         // if the PK differs, we want to change the target entity, not update it
                         const wrappedChild = helper(ref);
                         const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
@@ -141,13 +141,13 @@ 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.type, 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.type, value, options), prop);
+            entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
         }
         else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference.wrapReference(em.create(prop.type, value, options), prop);
+            entity[prop.name] = Reference.wrapReference(em.create(prop.targetMeta.class, value, options), prop);
         }
         else {
             const name = entity.constructor.name;
@@ -166,7 +166,7 @@ export class EntityAssigner {
             if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
                 const pk = Utils.extractPK(item, prop.targetMeta);
                 if (pk && EntityAssigner.validateEM(em)) {
-                    const ref = em.getUnitOfWork().getById(prop.type, pk, options.schema);
+                    const ref = em.getUnitOfWork().getById(prop.targetMeta.class, pk, options.schema);
                     if (ref) {
                         return EntityAssigner.assign(ref, item, options);
                     }
@@ -207,7 +207,7 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
-        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.type, value, {
+        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
             convertCustomTypes: options.convertCustomTypes,
             newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
         });
@@ -221,13 +221,13 @@ export class EntityAssigner {
             return item;
         }
         if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
-            return em.getReference(prop.type, item, options);
+            return em.getReference(prop.targetMeta.class, item, options);
         }
         if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
-            return em.merge(prop.type, item, options);
+            return em.merge(prop.targetMeta.class, item, options);
         }
         if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
-            return em.create(prop.type, item, options);
+            return em.create(prop.targetMeta.class, item, options);
         }
         invalid.push(item);
         return item;

package/entity/EntityFactory.d.ts

@@ -16,6 +16,11 @@ export interface FactoryOptions {
     schema?: string;
     parentSchema?: string;
     normalizeAccessors?: boolean;
+    /**
+     * Property name to use for identity map lookup instead of the primary key.
+     * This is useful for creating references by unique non-PK properties.
+     */
+    key?: string;
 }
 export declare class EntityFactory {
     private readonly em;
@@ -29,7 +34,7 @@ export declare class EntityFactory {
     constructor(em: EntityManager);
     create<T extends object, P extends string = string>(entityName: EntityName<T>, data: EntityData<T>, options?: FactoryOptions): New<T, P>;
     mergeData<T extends object>(meta: EntityMetadata<T>, entity: T, data: EntityData<T>, options?: FactoryOptions): void;
-    createReference<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[] | Record<string, Primary<T>>, options?: Pick<FactoryOptions, 'merge' | 'convertCustomTypes' | 'schema'>): T;
+    createReference<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[] | Record<string, Primary<T>>, options?: Pick<FactoryOptions, 'merge' | 'convertCustomTypes' | 'schema' | 'key'>): T;
     createEmbeddable<T extends object>(entityName: EntityName<T>, data: EntityData<T>, options?: Pick<FactoryOptions, 'newEntity' | 'convertCustomTypes'>): T;
     getComparator(): EntityComparator;
     private createEntity;

package/entity/EntityFactory.js

@@ -30,7 +30,6 @@ export class EntityFactory {
         if (data.__entity) {
             return data;
         }
-        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
             data = { ...data };
@@ -84,7 +83,7 @@ export class EntityFactory {
         else {
             this.hydrate(entity, meta2, data, options);
         }
-        if (exists && meta.discriminatorColumn && !(entity instanceof meta2.class)) {
+        if (exists && meta.root.inheritanceType && !(entity instanceof meta2.class)) {
             Object.setPrototypeOf(entity, meta2.prototype);
         }
         if (options.merge && wrapped.hasPrimaryKey()) {
@@ -110,12 +109,12 @@ export class EntityFactory {
         data = QueryHelper.processParams(data);
         const existsData = this.comparator.prepareEntity(entity);
         const originalEntityData = helper(entity).__originalEntityData ?? {};
-        const diff = this.comparator.diffEntities(meta.className, originalEntityData, existsData);
+        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]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
-        const diff2 = this.comparator.diffEntities(meta.className, existsData, data, { includeInverseSides: true });
+        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 => {
@@ -152,20 +151,31 @@ export class EntityFactory {
                 // 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]
                     .filter(child => Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
-                    .forEach(child => this.create(prop.type, child, options)); // we can ignore the value, we just care about the `mergeData` call
+                    .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) {
-                this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
+                this.create(prop.targetMeta.class, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
         this.unitOfWork.normalizeEntityData(meta, originalEntityData);
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;
-        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const schema = this.driver.getSchemaName(meta, options);
+        // Handle alternate key lookup
+        if (options.key) {
+            const value = '' + (Array.isArray(id) ? id[0] : Utils.isPlainObject(id) ? id[options.key] : id);
+            const exists = this.unitOfWork.getByKey(entityName, options.key, value, schema, options.convertCustomTypes);
+            if (exists) {
+                return exists;
+            }
+            // Create entity stub - storeByKey will set the alternate key property and store in identity map
+            const entity = this.create(entityName, {}, { ...options, initialized: false });
+            this.unitOfWork.storeByKey(entity, options.key, value, schema, options.convertCustomTypes);
+            return entity;
+        }
         if (meta.simplePK) {
             const exists = this.unitOfWork.getById(entityName, id, schema);
             if (exists) {
@@ -188,7 +198,6 @@ export class EntityFactory {
         return this.create(entityName, id, { ...options, initialized: false });
     }
     createEmbeddable(entityName, data, options = {}) {
-        entityName = Utils.className(entityName);
         data = { ...data };
         const meta = this.metadata.get(entityName);
         const meta2 = this.processDiscriminatorColumn(meta, data);
@@ -200,7 +209,7 @@ export class EntityFactory {
     createEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
-            if (!meta.class) {
+            if (meta.polymorphs) {
                 throw new Error(`Cannot create entity ${meta.className}, class prototype is unknown`);
             }
             const params = this.extractConstructorParams(meta, data, options);
@@ -263,22 +272,31 @@ export class EntityFactory {
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
         if (meta.simplePK) {
-            return this.unitOfWork.getById(meta.className, data[meta.primaryKeys[0]], schema);
+            return this.unitOfWork.getById(meta.class, data[meta.primaryKeys[0]], schema);
         }
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
         const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
-        return this.unitOfWork.getById(meta.className, pks, schema);
+        return this.unitOfWork.getById(meta.class, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
-        if (!meta.root.discriminatorColumn) {
+        // Handle STI discriminator (persisted column)
+        if (meta.root.inheritanceType === 'sti') {
+            const prop = meta.properties[meta.root.discriminatorColumn];
+            const value = data[prop.name];
+            const type = meta.root.discriminatorMap[value];
+            meta = type ? this.metadata.get(type) : meta;
             return meta;
         }
-        const prop = meta.properties[meta.root.discriminatorColumn];
-        const value = data[prop.name];
-        const type = meta.root.discriminatorMap[value];
-        meta = type ? this.metadata.find(type) : meta;
+        // Handle TPT discriminator (computed at query time)
+        if (meta.root.inheritanceType === 'tpt' && meta.root.discriminatorMap) {
+            const value = data[meta.root.tptDiscriminatorColumn];
+            if (value) {
+                const type = meta.root.discriminatorMap[value];
+                meta = type ? this.metadata.get(type) : meta;
+            }
+        }
         return meta;
     }
     /**
@@ -307,7 +325,7 @@ export class EntityFactory {
             const value = data[k];
             if (prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && value) {
                 const pk = Reference.unwrapReference(value);
-                const entity = this.unitOfWork.getById(prop.type, pk, options.schema, true);
+                const entity = this.unitOfWork.getById(prop.targetMeta.class, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }
@@ -316,10 +334,10 @@ export class EntityFactory {
                 }
                 const nakedPk = Utils.extractPK(value, prop.targetMeta, true);
                 if (Utils.isObject(value) && !nakedPk) {
-                    return this.create(prop.type, value, options);
+                    return this.create(prop.targetMeta.class, value, options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                const target = this.createReference(prop.type, nakedPk, rest);
+                const target = this.createReference(prop.targetMeta.class, nakedPk, rest);
                 return Reference.wrapReference(target, prop);
             }
             if (prop?.kind === ReferenceKind.EMBEDDED && value) {
@@ -327,7 +345,7 @@ export class EntityFactory {
                 if (Utils.isEntity(value)) {
                     return value;
                 }
-                return this.createEmbeddable(prop.type, value, options);
+                return this.createEmbeddable(prop.targetMeta.class, value, options);
             }
             if (!prop) {
                 const tmp = { ...data };
@@ -335,8 +353,8 @@ 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], meta.properties[prop.name].targetMeta, true)) {
-                        tmp[prop.name] = Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
+                    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) {
                         tmp[prop.name] = prop.customType.convertToJSValue(tmp[prop.name], this.platform);

package/entity/EntityHelper.d.ts

@@ -6,9 +6,9 @@ import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typ
 export declare class EntityHelper {
     static decorate<T extends object>(meta: EntityMetadata<T>, em: EntityManager): void;
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     private static defineBaseProperties;

package/entity/EntityHelper.js

@@ -6,6 +6,7 @@ import { WrappedEntity } from './WrappedEntity.js';
 import { ReferenceKind } from '../enums.js';
 import { helper } from './wrap.js';
 import { inspect } from '../logging/inspect.js';
+import { getEnv } from '../utils/env-vars.js';
 /**
  * @internal
  */
@@ -32,14 +33,19 @@ export class EntityHelper {
         const prototype = meta.prototype;
         if (!prototype.toJSON) { // toJSON can be overridden
             prototype.toJSON = function (...args) {
+                // Guard against being called on the prototype itself (e.g. by serializers
+                // walking the object graph and calling toJSON on prototype objects)
+                if (this === prototype) {
+                    return {};
+                }
                 return EntityTransformer.toObject(this, ...args);
             };
         }
     }
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     static defineBaseProperties(meta, prototype, em) {
@@ -130,7 +136,7 @@ export class EntityHelper {
                 .forEach(prop => delete object[prop.name]);
             const ret = inspect(object, { depth });
             let name = this.constructor.name;
-            const showEM = ['true', 't', '1'].includes(process.env.MIKRO_ORM_LOG_EM_ID?.toString().toLowerCase() ?? '');
+            const showEM = ['true', 't', '1'].includes(getEnv('MIKRO_ORM_LOG_EM_ID')?.toLowerCase() ?? '');
             if (showEM) {
                 if (helper(this).__em) {
                     name += ` [managed by ${helper(this).__em.id}]`;
@@ -170,7 +176,19 @@ export class EntityHelper {
         });
     }
     static propagate(meta, entity, owner, prop, value, old) {
-        for (const prop2 of prop.targetMeta.bidirectionalRelations) {
+        // For polymorphic relations, get bidirectional relations from the actual entity's metadata
+        let bidirectionalRelations;
+        if (prop.polymorphic && prop.polymorphTargets?.length) {
+            // For polymorphic relations, we need to get the bidirectional relations from the actual value's metadata
+            if (!value) {
+                return; // No value means no propagation needed
+            }
+            bidirectionalRelations = helper(value).__meta.bidirectionalRelations;
+        }
+        else {
+            bidirectionalRelations = prop.targetMeta.bidirectionalRelations;
+        }
+        for (const prop2 of bidirectionalRelations) {
             if ((prop2.inversedBy || prop2.mappedBy) !== prop.name) {
                 continue;
             }
@@ -212,6 +230,11 @@ export class EntityHelper {
                 helper(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
             }
         }
+        // Skip setting the inverse side to null if it's a primary key - the entity will be removed via orphan removal
+        // Setting a primary key to null would corrupt the entity and cause validation errors
+        if (value == null && prop.orphanRemoval && prop2.primary) {
+            return;
+        }
         if (value == null) {
             entity[prop2.name] = value;
         }

package/entity/EntityLoader.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, ConnectionType, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
 import type { EntityField, FilterOptions } from '../drivers/IDatabaseDriver.js';
@@ -15,7 +15,7 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     convertCustomTypes?: boolean;
     ignoreLazyScalarProperties?: boolean;
     filters?: FilterOptions;
-    strategy?: LoadStrategy;
+    strategy?: LoadStrategy | `${LoadStrategy}`;
     lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>;
     schema?: string;
     connectionType?: ConnectionType;
@@ -30,8 +30,8 @@ export declare class EntityLoader {
      * Loads specified relations in batch.
      * This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: string, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
-    normalizePopulate<Entity>(entityName: string, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean): PopulateOptions<Entity>[];
+    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: EntityName<Entity>, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
+    normalizePopulate<Entity>(entityName: EntityName<Entity>, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean, exclude?: string[]): PopulateOptions<Entity>[];
     private setSerializationContext;
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from
@@ -43,6 +43,7 @@ export declare class EntityLoader {
      */
     private populateMany;
     private populateScalar;
+    private populatePolymorphic;
     private initializeCollections;
     private initializeOneToMany;
     private initializeManyToMany;