@mikro-orm/core 6.4.17-dev.7 → 6.4.17-dev.71

package/EntityManager.d.ts

@@ -112,7 +112,9 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * Gets logger context for this entity manager.
      */
-    getLoggerContext<T extends Dictionary = Dictionary>(): T;
+    getLoggerContext<T extends Dictionary = Dictionary>(options?: {
+        disableContextResolution?: boolean;
+    }): T;
     setFlushMode(flushMode?: FlushMode): void;
     protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: string, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
@@ -482,7 +484,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * some additional lazy properties, if so, we reload and merge the data from database
      */
     protected shouldRefresh<T extends object, P extends string = never, F extends string = '*', E extends string = never>(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
-    protected prepareOptions(options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>): void;
+    protected prepareOptions(options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any>): void;
     /**
      * @internal
      */
@@ -542,11 +544,18 @@ export interface CreateOptions<Convert extends boolean> {
     partial?: boolean;
     /** convert raw database values based on mapped types (by default, already converted values are expected) */
     convertCustomTypes?: Convert;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly?: boolean;
 }
 export interface MergeOptions {
     refresh?: boolean;
     convertCustomTypes?: boolean;
     schema?: string;
+    disableContextResolution?: boolean;
+    keepIdentity?: boolean;
 }
 export interface ForkOptions {
     /** do we want a clear identity map? defaults to true */

package/EntityManager.js

@@ -12,6 +12,7 @@ const unit_of_work_1 = require("./unit-of-work");
 const enums_1 = require("./enums");
 const events_1 = require("./events");
 const errors_1 = require("./errors");
+const utils_2 = require("./entity/utils");
 /**
  * The EntityManager is the central access point to ORM functionality. It is a facade to all different ORM subsystems
  * such as UnitOfWork, Query Language, and Repository API.
@@ -131,7 +132,6 @@ class EntityManager {
             await em.entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
                 ...em.getPopulateWhere(where, options),
-                convertCustomTypes: false,
                 ignoreLazyScalarProperties: true,
                 lookup: false,
             });
@@ -162,7 +162,6 @@ class EntityManager {
         await em.entityLoader.populate(entityName, unique, populate, {
             ...options,
             ...em.getPopulateWhere(where, options),
-            convertCustomTypes: false,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
@@ -226,8 +225,8 @@ class EntityManager {
     /**
      * Gets logger context for this entity manager.
      */
-    getLoggerContext() {
-        const em = this.getContext();
+    getLoggerContext(options) {
+        const em = options?.disableContextResolution ? this : this.getContext();
         em.loggerContext ??= {};
         return em.loggerContext;
     }
@@ -283,7 +282,8 @@ class EntityManager {
             for (const hint of options.populate) {
                 const field = hint.field.split(':')[0];
                 const prop = meta.properties[field];
-                const joined = (prop.strategy || options.strategy || hint.strategy || this.config.get('loadStrategy')) === enums_1.LoadStrategy.JOINED && prop.kind !== enums_1.ReferenceKind.SCALAR;
+                const strategy = (0, utils_2.getLoadingStrategy)(prop.strategy || options.strategy || hint.strategy || this.config.get('loadStrategy'), prop.kind);
+                const joined = strategy === enums_1.LoadStrategy.JOINED && prop.kind !== enums_1.ReferenceKind.SCALAR;
                 if (!joined && !hint.filter) {
                     continue;
                 }
@@ -488,11 +488,17 @@ class EntityManager {
             ...options,
             flushMode: enums_1.FlushMode.COMMIT,
         });
+        const em = this.getContext();
         if (reloaded) {
-            this.config.getHydrator(this.metadata).hydrate(entity, (0, entity_1.helper)(entity).__meta, (0, entity_1.helper)(reloaded).toPOJO(), this.getEntityFactory(), 'full', false, true);
+            for (const e of fork.unitOfWork.getIdentityMap()) {
+                const ref = em.getReference(e.constructor.name, (0, entity_1.helper)(e).getPrimaryKey());
+                const data = this.comparator.prepareEntity(e);
+                em.config.getHydrator(this.metadata).hydrate(ref, (0, entity_1.helper)(ref).__meta, (0, entity_1.helper)(e).serialize({ ignoreSerializers: true }), em.entityFactory, 'full', false, true);
+                (0, entity_1.helper)(ref).__originalEntityData = data;
+            }
         }
         else {
-            this.getUnitOfWork().unsetIdentity(entity);
+            em.unitOfWork.unsetIdentity(entity);
         }
         return reloaded ? entity : reloaded;
     }
@@ -535,7 +541,6 @@ class EntityManager {
                 await em.entityLoader.populate(entityName, [cached.data], options.populate, {
                     ...options,
                     ...em.getPopulateWhere(where, options),
-                    convertCustomTypes: false,
                     ignoreLazyScalarProperties: true,
                     lookup: false,
                 });
@@ -982,8 +987,7 @@ class EntityManager {
                 if (propagateToUpperContext) {
                     // ensure all entities from inner context are merged to the upper one
                     for (const entity of fork.unitOfWork.getIdentityMap()) {
-                        em.unitOfWork.register(entity);
-                        entity.__helper.__em = em;
+                        em.merge(entity, { disableContextResolution: true, keepIdentity: true, refresh: true });
                     }
                 }
                 return ret;
@@ -1168,10 +1172,10 @@ class EntityManager {
      * via second parameter. By default, it will return already loaded entities without modifying them.
      */
     merge(entityName, data, options = {}) {
-        const em = this.getContext();
         if (utils_1.Utils.isEntity(entityName)) {
-            return em.merge(entityName.constructor.name, entityName, data);
+            return this.merge(entityName.constructor.name, entityName, data);
         }
+        const em = options.disableContextResolution ? this : this.getContext();
         options.schema ??= em._schema;
         entityName = utils_1.Utils.className(entityName);
         em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
@@ -1181,7 +1185,12 @@ class EntityManager {
         }
         const meta = em.metadata.find(entityName);
         const childMeta = em.metadata.getByDiscriminatorColumn(meta, data);
-        entity = utils_1.Utils.isEntity(data) ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
+        const dataIsEntity = utils_1.Utils.isEntity(data);
+        if (options.keepIdentity && entity && dataIsEntity && entity !== data) {
+            em.entityFactory.mergeData(meta, entity, (0, entity_1.helper)(data).__originalEntityData, { initialized: true, merge: true, ...options });
+            return entity;
+        }
+        entity = dataIsEntity ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
         em.validator.validate(entity, data, childMeta ?? meta);
         em.unitOfWork.merge(entity);
         return entity;
@@ -1246,10 +1255,8 @@ class EntityManager {
     async count(entityName, where = {}, options = {}) {
         const em = this.getContext(false);
         // Shallow copy options since the object will be modified when deleting orderBy
-        options = {
-            schema: em._schema,
-            ...options,
-        };
+        options = { ...options };
+        em.prepareOptions(options);
         entityName = utils_1.Utils.className(entityName);
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
@@ -1267,7 +1274,7 @@ class EntityManager {
         if (cached?.data !== undefined) {
             return cached.data;
         }
-        const count = await em.driver.count(entityName, where, { ctx: em.transactionContext, ...options });
+        const count = await em.driver.count(entityName, where, { ctx: em.transactionContext, em, ...options });
         await em.storeCache(options.cache, cached, () => +count);
         return +count;
     }
@@ -1547,7 +1554,6 @@ class EntityManager {
             ...options,
             ...this.getPopulateWhere(where, options),
             orderBy: options.populateOrderBy ?? options.orderBy,
-            convertCustomTypes: false,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
@@ -1670,7 +1676,7 @@ class EntityManager {
             throw new errors_1.ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
         }
         options.schema ??= this._schema;
-        options.logging = utils_1.Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
+        options.logging = options.loggerContext = utils_1.Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
     }
     /**
      * @internal

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)

package/connections/Connection.d.ts

@@ -49,15 +49,17 @@ export declare abstract class Connection {
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<Transaction>;
-    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
     getClientUrl(): string;

package/connections/Connection.js

@@ -49,10 +49,10 @@ class Connection {
     async begin(options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async commit(ctx, eventBroadcaster) {
+    async commit(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async rollback(ctx, eventBroadcaster) {
+    async rollback(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
     getConnectionOptions() {

package/decorators/Entity.d.ts

@@ -2,18 +2,32 @@ import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } fro
 import type { FindOptions } from '../drivers/IDatabaseDriver';
 export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
 export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
+    /** Override default collection/table name. Alias for `collection`. */
     tableName?: string;
+    /** Sets the schema name. */
     schema?: string;
+    /** Override default collection/table name. Alias for `tableName`. */
     collection?: string;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorMap?: Dictionary<string>;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorValue?: number | string;
+    /**	Enforce use of constructor when creating managed entity instances. */
     forceConstructor?: boolean;
+    /** Specify comment to table. (SQL only) */
     comment?: string;
+    /**	Marks entity as abstract, such entities are inlined during discovery. */
     abstract?: boolean;
+    /** Disables change tracking - such entities are ignored during flush. */
     readonly?: boolean;
+    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
     virtual?: boolean;
+    /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
     hasTriggers?: boolean;
+    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
     expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>) => object);
+    /** Set {@doclink repositories#custom-repository | custom repository class}. */
     repository?: () => Constructor;
 };

package/decorators/Indexed.d.ts

@@ -1,4 +1,4 @@
-import type { EntityClass, Dictionary, AutoPath } from '../typings';
+import type { EntityClass, Dictionary, AutoPath, IndexCallback } from '../typings';
 import type { DeferMode } from '../enums';
 export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
 export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
@@ -8,7 +8,7 @@ interface BaseOptions<T, H extends string> {
     name?: string;
     properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
-    expression?: string;
+    expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
 }
 export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;

package/decorators/Transactional.d.ts

@@ -2,6 +2,7 @@ import type { TransactionOptions } from '../enums';
 import type { ContextProvider } from '../typings';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
+    contextName?: string;
 };
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.

package/decorators/Transactional.js

@@ -17,10 +17,10 @@ function Transactional(options = {}) {
             throw new Error('@Transactional() should be use with async functions');
         }
         descriptor.value = async function (...args) {
-            const { context, ...txOptions } = options;
+            const { context, contextName, ...txOptions } = options;
             const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context)
-                || TransactionContext_1.TransactionContext.getEntityManager()
-                || RequestContext_1.RequestContext.getEntityManager();
+                || TransactionContext_1.TransactionContext.getEntityManager(contextName)
+                || RequestContext_1.RequestContext.getEntityManager(contextName);
             if (!em) {
                 throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }

package/drivers/IDatabaseDriver.d.ts

@@ -166,6 +166,7 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -200,6 +201,8 @@ export interface CountOptions<T extends object, P extends string = never> {
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
@@ -221,6 +224,7 @@ export interface LockOptions extends DriverMethodOptions {
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
+    loggerContext?: LogContext;
 }
 export interface GetReferenceOptions {
     wrapped?: boolean;

package/entity/ArrayCollection.d.ts

@@ -6,6 +6,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     protected readonly items: Set<T>;
     protected initialized: boolean;
     protected dirty: boolean;
+    protected partial: boolean;
     protected snapshot: T[] | undefined;
     protected _count?: number;
     private _property?;
@@ -25,7 +26,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     /**
      * @internal
      */
-    hydrate(items: T[], forcePropagate?: boolean): void;
+    hydrate(items: T[], forcePropagate?: boolean, partial?: boolean): void;
     /**
      * Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity,
      * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
@@ -83,6 +84,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     count(): number;
     isInitialized(fully?: boolean): boolean;
     isDirty(): boolean;
+    isPartial(): boolean;
     isEmpty(): boolean;
     setDirty(dirty?: boolean): void;
     get length(): number;

package/entity/ArrayCollection.js

@@ -12,6 +12,7 @@ class ArrayCollection {
     items = new Set();
     initialized = true;
     dirty = false;
+    partial = false; // mark partially loaded collections, propagation is disabled for those
     snapshot = []; // used to create a diff of the collection at commit time, undefined marks overridden values so we need to wipe when flushing
     _count;
     _property;
@@ -110,11 +111,12 @@ class ArrayCollection {
     /**
      * @internal
      */
-    hydrate(items, forcePropagate) {
+    hydrate(items, forcePropagate, partial) {
         for (let i = 0; i < this.items.size; i++) {
             delete this[i];
         }
         this.initialized = true;
+        this.partial = !!partial;
         this.items.clear();
         this._count = 0;
         this.add(items);
@@ -277,6 +279,9 @@ class ArrayCollection {
     isDirty() {
         return this.dirty;
     }
+    isPartial() {
+        return this.partial;
+    }
     isEmpty() {
         return this.count() === 0;
     }
@@ -393,7 +398,7 @@ class ArrayCollection {
     /** @ignore */
     [node_util_1.inspect.custom](depth = 2) {
         const object = { ...this };
-        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly'];
+        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly', 'partial'];
         hidden.forEach(k => delete object[k]);
         const ret = (0, node_util_1.inspect)(object, { depth });
         const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;

package/entity/EntityFactory.d.ts

@@ -4,6 +4,11 @@ import type { EntityComparator } from '../utils/EntityComparator';
 export interface FactoryOptions {
     initialized?: boolean;
     newEntity?: boolean;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly?: boolean;
     merge?: boolean;
     refresh?: boolean;
     convertCustomTypes?: boolean;
@@ -27,6 +32,7 @@ export declare class EntityFactory {
     createEmbeddable<T extends object>(entityName: EntityName<T>, data: EntityData<T>, options?: Pick<FactoryOptions, 'newEntity' | 'convertCustomTypes'>): T;
     getComparator(): EntityComparator;
     private createEntity;
+    private assignDefaultValues;
     private hydrate;
     private findEntity;
     private processDiscriminatorColumn;

package/entity/EntityFactory.js

@@ -74,7 +74,7 @@ class EntityFactory {
                             continue;
                         }
                         if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                         }
                         data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
@@ -234,6 +234,13 @@ class EntityFactory {
         }
         return entity;
     }
+    assignDefaultValues(entity, meta) {
+        for (const prop of meta.props) {
+            if (prop.onCreate) {
+                entity[prop.name] ??= prop.onCreate(entity, this.em);
+            }
+        }
+    }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
             this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
@@ -245,6 +252,10 @@ class EntityFactory {
             (0, wrap_1.helper)(entity)?.__loadedProperties.add(key);
             (0, wrap_1.helper)(entity)?.__serializationContext.fields?.add(key);
         });
+        const processOnCreateHooksEarly = options.processOnCreateHooksEarly ?? this.config.get('processOnCreateHooksEarly');
+        if (options.newEntity && processOnCreateHooksEarly) {
+            this.assignDefaultValues(entity, meta);
+        }
     }
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);

package/entity/EntityHelper.js

@@ -155,7 +155,7 @@ class EntityHelper {
                 wrapped.__data[prop.name] = Reference_1.Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();
@@ -175,6 +175,9 @@ class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (Utils_1.Utils.isCollection(inverse) && inverse.isPartial()) {
+                continue;
+            }
             if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && Utils_1.Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
                 (0, wrap_1.helper)(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);

package/entity/EntityLoader.js

@@ -143,18 +143,22 @@ class EntityLoader {
         const innerOrderBy = Utils_1.Utils.asArray(options.orderBy)
             .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils_1.Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
+        const where = await this.extractChildCondition(options, prop);
         if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
             const res = await this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
             return Utils_1.Utils.flatten(res);
         }
-        const where = await this.extractChildCondition(options, prop);
-        const data = await this.findChildren(entities, prop, populate, { ...options, where, orderBy: innerOrderBy }, !!(ref || prop.mapToPk));
-        this.initializeCollections(filtered, prop, field, data, innerOrderBy.length > 0);
-        return data;
+        const { items, partial } = await this.findChildren(options.filtered ?? entities, prop, populate, {
+            ...options,
+            where,
+            orderBy: innerOrderBy,
+        }, !!(ref || prop.mapToPk));
+        this.initializeCollections(filtered, prop, field, items, innerOrderBy.length > 0, partial);
+        return items;
     }
     async populateScalar(meta, filtered, options) {
         const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
-        const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
+        const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta, true)));
         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.className, where, {
@@ -163,15 +167,15 @@ class EntityLoader {
             populate: [],
         });
     }
-    initializeCollections(filtered, prop, field, children, customOrder) {
+    initializeCollections(filtered, prop, field, children, customOrder, partial) {
         if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
-            this.initializeOneToMany(filtered, children, prop, field);
+            this.initializeOneToMany(filtered, children, prop, field, partial);
         }
         if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && !this.driver.getPlatform().usesPivotTable()) {
-            this.initializeManyToMany(filtered, children, prop, field, customOrder);
+            this.initializeManyToMany(filtered, children, prop, field, customOrder, partial);
         }
     }
-    initializeOneToMany(filtered, children, prop, field) {
+    initializeOneToMany(filtered, children, prop, field, partial) {
         const mapToPk = prop.targetMeta.properties[prop.mappedBy].mapToPk;
         const map = {};
         for (const entity of filtered) {
@@ -187,14 +191,14 @@ class EntityLoader {
         }
         for (const entity of filtered) {
             const key = (0, wrap_1.helper)(entity).getSerializedPrimaryKey();
-            entity[field].hydrate(map[key]);
+            entity[field].hydrate(map[key], undefined, partial);
         }
     }
-    initializeManyToMany(filtered, children, prop, field, customOrder) {
+    initializeManyToMany(filtered, children, prop, field, customOrder, partial) {
         if (prop.mappedBy) {
             for (const entity of filtered) {
                 const items = children.filter(child => child[prop.mappedBy].contains(entity, false));
-                entity[field].hydrate(items, true);
+                entity[field].hydrate(items, true, partial);
             }
         }
         else { // owning side of M:N without pivot table needs to be reordered
@@ -204,7 +208,7 @@ class EntityLoader {
                 if (!customOrder) {
                     items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
                 }
-                entity[field].hydrate(items, true);
+                entity[field].hydrate(items, true, partial);
             }
         }
     }
@@ -213,6 +217,7 @@ class EntityLoader {
         const meta = prop.targetMeta;
         let fk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
         let schema = options.schema;
+        const partial = !Utils_1.Utils.isEmpty(prop.where) || !Utils_1.Utils.isEmpty(options.where);
         if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY || (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && !prop.owner)) {
             fk = meta.properties[prop.mappedBy].name;
         }
@@ -222,7 +227,7 @@ class EntityLoader {
             children.push(...this.filterByReferences(entities, prop.name, options.refresh));
         }
         if (children.length === 0) {
-            return [];
+            return { items: [], partial };
         }
         if (!schema && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             schema = children.find(e => e.__helper.__schema)?.__helper.__schema;
@@ -271,7 +276,7 @@ class EntityLoader {
                 this.em.getUnitOfWork()['loadedEntities'].delete(item);
             }
         }
-        return items;
+        return { items, partial };
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
         const cond1 = QueryHelper_1.QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.className, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
@@ -320,11 +325,12 @@ class EntityLoader {
         for (const entity of entities) {
             visited.delete(entity);
         }
-        const filtered = Utils_1.Utils.unique(children.filter(e => !visited.has(e)));
+        const unique = Utils_1.Utils.unique(children);
+        const filtered = unique.filter(e => !visited.has(e));
         for (const entity of entities) {
             visited.add(entity);
         }
-        await this.populate(prop.type, filtered, populate.children ?? populate.all, {
+        await this.populate(prop.type, unique, populate.children ?? populate.all, {
             where: await this.extractChildCondition(options, prop, false),
             orderBy: innerOrderBy,
             fields,
@@ -341,6 +347,8 @@ class EntityLoader {
             refresh: refresh && !filtered.every(item => options.visited.has(item)),
             // @ts-ignore not a public option, will be propagated to the populate call
             visited: options.visited,
+            // @ts-ignore not a public option
+            filtered,
         });
     }
     /** @internal */

package/entity/Reference.d.ts

@@ -56,6 +56,11 @@ export declare class ScalarReference<Value> {
      * Returns either the whole entity, or the requested property.
      */
     load(options?: Omit<LoadReferenceOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value | undefined>;
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    loadOrFail(options?: Omit<LoadReferenceOrFailOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value>;
     set(value: Value): void;
     bind<Entity extends object>(entity: Entity, property: EntityKey<Entity>): void;
     unwrap(): Value | undefined;

package/entity/Reference.js

@@ -7,6 +7,7 @@ const node_util_1 = require("node:util");
 const enums_1 = require("../enums");
 const wrap_1 = require("./wrap");
 const utils_1 = require("../utils");
+const errors_1 = require("../errors");
 class Reference {
     entity;
     constructor(entity) {
@@ -178,6 +179,21 @@ class ScalarReference {
         }
         return this.value;
     }
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    async loadOrFail(options = {}) {
+        const ret = await this.load(options);
+        if (!ret) {
+            const wrapped = (0, wrap_1.helper)(this.entity);
+            options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
+            const entityName = this.entity.constructor.name;
+            const where = wrapped.getPrimaryKey();
+            throw new errors_1.NotFoundError(`${entityName} (${where}) failed to load property '${this.property}'`);
+        }
+        return ret;
+    }
     set(value) {
         this.value = value;
         this.initialized = true;