@mikro-orm/core 7.0.0-dev.21 → 7.0.0-dev.23

package/EntityManager.d.ts

@@ -33,6 +33,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     readonly name: string;
     protected readonly refLoader: DataLoader<[Reference<any>, (Omit<import("./entity/Reference.js").LoadReferenceOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [Reference<any>, (Omit<import("./entity/Reference.js").LoadReferenceOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
     protected readonly colLoader: DataLoader<[import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
+    protected readonly colLoaderMtoN: DataLoader<[import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
     private readonly validator;
     private readonly repositoryMap;
     private readonly entityLoader;
@@ -117,7 +118,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>;
@@ -487,7 +490,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
      */
@@ -547,11 +550,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

@@ -19,6 +19,8 @@ import { EventType, FlushMode, LoadStrategy, LockMode, PopulateHint, PopulatePat
 import { EventManager } from './events/EventManager.js';
 import { TransactionEventBroadcaster } from './events/TransactionEventBroadcaster.js';
 import { OptimisticLockError, ValidationError } from './errors.js';
+import { getLoadingStrategy } from './entity/utils.js';
+import { TransactionManager } from './utils/TransactionManager.js';
 /**
  * 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.
@@ -36,6 +38,7 @@ export class EntityManager {
     name;
     refLoader = new DataLoader(DataloaderUtils.getRefBatchLoadFn(this));
     colLoader = new DataLoader(DataloaderUtils.getColBatchLoadFn(this));
+    colLoaderMtoN = new DataLoader(DataloaderUtils.getManyToManyColBatchLoadFn(this));
     validator;
     repositoryMap = {};
     entityLoader;
@@ -137,7 +140,6 @@ export class EntityManager {
             await em.entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
                 ...em.getPopulateWhere(where, options),
-                convertCustomTypes: false,
                 ignoreLazyScalarProperties: true,
                 lookup: false,
             });
@@ -168,7 +170,6 @@ export class EntityManager {
         await em.entityLoader.populate(entityName, unique, populate, {
             ...options,
             ...em.getPopulateWhere(where, options),
-            convertCustomTypes: false,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
@@ -232,8 +233,8 @@ export 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;
     }
@@ -289,7 +290,8 @@ export 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')) === LoadStrategy.JOINED && prop.kind !== ReferenceKind.SCALAR;
+                const strategy = getLoadingStrategy(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
+                const joined = strategy === LoadStrategy.JOINED && prop.kind !== ReferenceKind.SCALAR;
                 if (!joined && !hint.filter) {
                     continue;
                 }
@@ -326,10 +328,19 @@ export class EntityManager {
             const cond = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', options);
             if (!Utils.isEmpty(cond)) {
                 const populated = options.populate.filter(({ field }) => field.split(':')[0] === prop.name);
+                let found = false;
                 if (populated.length > 0) {
-                    populated.forEach(hint => hint.filter = true);
+                    for (const hint of populated) {
+                        if (!hint.all) {
+                            hint.filter = true;
+                            found = true;
+                        }
+                        else if (hint.field === `${prop.name}:ref`) {
+                            found = true;
+                        }
+                    }
                 }
-                else {
+                if (!found) {
                     ret.push({ field: `${prop.name}:ref`, strategy: LoadStrategy.JOINED, filter: true });
                 }
             }
@@ -494,11 +505,17 @@ export class EntityManager {
             ...options,
             flushMode: FlushMode.COMMIT,
         });
+        const em = this.getContext();
         if (reloaded) {
-            this.config.getHydrator(this.metadata).hydrate(entity, helper(entity).__meta, helper(reloaded).toPOJO(), this.getEntityFactory(), 'full');
+            for (const e of fork.unitOfWork.getIdentityMap()) {
+                const ref = em.getReference(e.constructor.name, helper(e).getPrimaryKey());
+                const data = this.comparator.prepareEntity(e);
+                em.config.getHydrator(this.metadata).hydrate(ref, helper(ref).__meta, helper(e).serialize({ ignoreSerializers: true }), em.entityFactory, 'full', false, true);
+                helper(ref).__originalEntityData = data;
+            }
         }
         else {
-            this.getUnitOfWork().unsetIdentity(entity);
+            em.unitOfWork.unsetIdentity(entity);
         }
         return reloaded ? entity : reloaded;
     }
@@ -541,7 +558,6 @@ export class EntityManager {
                 await em.entityLoader.populate(entityName, [cached.data], options.populate, {
                     ...options,
                     ...em.getPopulateWhere(where, options),
-                    convertCustomTypes: false,
                     ignoreLazyScalarProperties: true,
                     lookup: false,
                 });
@@ -969,39 +985,8 @@ export class EntityManager {
         if (this.disableTransactions || em.disableTransactions) {
             return cb(em);
         }
-        const fork = em.fork({
-            clear: options.clear ?? false, // state will be merged once resolves
-            flushMode: options.flushMode,
-            cloneEventManager: true,
-            disableTransactions: options.ignoreNestedTransactions,
-            loggerContext: options.loggerContext,
-        });
-        options.ctx ??= em.transactionContext;
-        const propagateToUpperContext = !em.global || this.config.get('allowGlobalContext');
-        return TransactionContext.create(fork, async () => {
-            return fork.getConnection().transactional(async (trx) => {
-                fork.transactionContext = trx;
-                if (propagateToUpperContext) {
-                    fork.eventManager.registerSubscriber({
-                        afterFlush(args) {
-                            args.uow.getChangeSets()
-                                .filter(cs => [ChangeSetType.DELETE, ChangeSetType.DELETE_EARLY].includes(cs.type))
-                                .forEach(cs => em.unitOfWork.unsetIdentity(cs.entity));
-                        },
-                    });
-                }
-                const ret = await cb(fork);
-                await fork.flush();
-                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;
-                    }
-                }
-                return ret;
-            }, { ...options, eventBroadcaster: new TransactionEventBroadcaster(fork, { topLevelTransaction: !options.ctx }) });
-        });
+        const manager = new TransactionManager(this);
+        return manager.handle(cb, options);
     }
     /**
      * Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.
@@ -1181,10 +1166,10 @@ export 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.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.className(entityName);
         em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
@@ -1194,7 +1179,12 @@ export class EntityManager {
         }
         const meta = em.metadata.find(entityName);
         const childMeta = em.metadata.getByDiscriminatorColumn(meta, data);
-        entity = Utils.isEntity(data) ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
+        const dataIsEntity = Utils.isEntity(data);
+        if (options.keepIdentity && entity && dataIsEntity && entity !== data) {
+            em.entityFactory.mergeData(meta, entity, 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;
@@ -1259,10 +1249,8 @@ export 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.className(entityName);
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
@@ -1280,7 +1268,7 @@ export 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;
     }
@@ -1568,7 +1556,6 @@ export class EntityManager {
             ...options,
             ...this.getPopulateWhere(where, options),
             orderBy: options.populateOrderBy ?? options.orderBy,
-            convertCustomTypes: false,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
@@ -1691,7 +1678,7 @@ export class EntityManager {
             throw new ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
         }
         options.schema ??= this._schema;
-        options.logging = Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
+        options.logging = options.loggerContext = 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

@@ -45,15 +45,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

@@ -46,10 +46,10 @@ export 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,17 +2,32 @@ import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } fro
 import type { FindOptions } from '../drivers/IDatabaseDriver.js';
 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.js';
+import type { EntityClass, Dictionary, AutoPath, IndexCallback } from '../typings.js';
 import type { DeferMode } from '../enums.js';
 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/ManyToMany.d.ts

@@ -37,4 +37,6 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
 }

package/decorators/ManyToOne.d.ts

@@ -27,6 +27,8 @@ export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner,
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode?: DeferMode | `${DeferMode}`;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
     /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
     foreignKeyName?: string;
 }

package/decorators/OneToOne.d.ts

@@ -23,4 +23,6 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     deferMode?: DeferMode | `${DeferMode}`;
     /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
     foreignKeyName?: string;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
 }

package/decorators/Transactional.d.ts

@@ -2,6 +2,7 @@ import type { TransactionOptions } from '../enums.js';
 import type { ContextProvider } from '../typings.js';
 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

@@ -14,10 +14,10 @@ export 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 resolveContextProvider(this, context))
-                || TransactionContext.getEntityManager()
-                || RequestContext.getEntityManager();
+                || TransactionContext.getEntityManager(contextName)
+                || 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

@@ -9,6 +9,7 @@ export 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;
@@ -107,11 +108,12 @@ export 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);
@@ -274,6 +276,9 @@ export class ArrayCollection {
     isDirty() {
         return this.dirty;
     }
+    isPartial() {
+        return this.partial;
+    }
     isEmpty() {
         return this.count() === 0;
     }
@@ -390,7 +395,7 @@ export class ArrayCollection {
     /** @ignore */
     [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 = inspect(object, { depth });
         const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;

package/entity/Collection.js

@@ -221,8 +221,9 @@ export class Collection extends ArrayCollection {
             const order = [...this.items]; // copy order of references
             const orderBy = this.createOrderBy(options.orderBy);
             const customOrder = orderBy.length > 0;
-            // eslint-disable-next-line dot-notation
-            const items = await em['colLoader'].load([
+            const pivotTable = this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
+            const loader = pivotTable ? 'colLoaderMtoN' : 'colLoader';
+            const items = await em[loader].load([
                 this,
                 { ...options, orderBy },
             ]);

package/entity/EntityFactory.d.ts

@@ -4,6 +4,11 @@ import type { EntityComparator } from '../utils/EntityComparator.js';
 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

@@ -71,7 +71,7 @@ export class EntityFactory {
                             continue;
                         }
                         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.primaryKeys, true);
+                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                         }
                         data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
@@ -113,7 +113,7 @@ export class EntityFactory {
         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);
+        const diff2 = this.comparator.diffEntities(meta.className, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
         Utils.keys(diff).forEach(key => delete diff2[key]);
         Utils.keys(diff2).filter(key => {
@@ -171,8 +171,8 @@ export class EntityFactory {
         if (Array.isArray(id)) {
             id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
-        const exists = this.unitOfWork.getById(entityName, pks, schema);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform);
+        const exists = this.unitOfWork.getById(entityName, pks, schema, options.convertCustomTypes);
         if (exists) {
             return exists;
         }
@@ -231,6 +231,13 @@ export 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));
@@ -242,6 +249,10 @@ export class EntityFactory {
             helper(entity)?.__loadedProperties.add(key);
             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);
@@ -251,7 +262,7 @@ export class EntityFactory {
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
         return this.unitOfWork.getById(meta.className, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
@@ -285,7 +296,7 @@ export class EntityFactory {
         return meta.constructorParams.map(k => {
             if (meta.properties[k] && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
                 const pk = Reference.unwrapReference(data[k]);
-                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
+                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }

package/entity/EntityHelper.js

@@ -152,7 +152,7 @@ export class EntityHelper {
                 wrapped.__data[prop.name] = 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.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();
@@ -172,6 +172,9 @@ export class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (Utils.isCollection(inverse) && inverse.isPartial()) {
+                continue;
+            }
             if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
                 helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
@@ -210,6 +213,7 @@ export class EntityHelper {
         }
         if (old?.[prop2.name] != null) {
             delete helper(old).__data[prop2.name];
+            old[prop2.name] = null;
         }
     }
     static ensurePropagation(entity) {