@mikro-orm/core 7.0.0-dev.6 → 7.0.0-dev.60

package/decorators/Transactional.js

@@ -1,3 +1,4 @@
+import { TransactionPropagation } from '../enums.js';
 import { RequestContext } from '../utils/RequestContext.js';
 import { resolveContextProvider } from '../utils/resolveContextProvider.js';
 import { TransactionContext } from '../utils/TransactionContext.js';
@@ -6,6 +7,7 @@ import { TransactionContext } from '../utils/TransactionContext.js';
  * The difference is that you can specify the context in which the transaction begins by providing `context` option,
  * and if omitted, the transaction will begin in the current context implicitly.
  * It works on async functions and can be nested with `em.transactional()`.
+ * Unlike `em.transactional()`, this decorator uses `REQUIRED` propagation by default, which means it will join existing transactions.
  */
 export function Transactional(options = {}) {
     return function (target, propertyKey, descriptor) {
@@ -14,10 +16,11 @@ 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;
+            txOptions.propagation ??= TransactionPropagation.REQUIRED;
             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/decorators/index.d.ts

@@ -3,7 +3,7 @@ export * from './Entity.js';
 export * from './OneToOne.js';
 export * from './ManyToOne.js';
 export * from './ManyToMany.js';
-export { OneToMany, OneToManyOptions } from './OneToMany.js';
+export { OneToMany, type OneToManyOptions } from './OneToMany.js';
 export * from './Property.js';
 export * from './Check.js';
 export * from './Enum.js';

package/drivers/DatabaseDriver.d.ts

@@ -1,5 +1,5 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type StreamOptions } from './IDatabaseDriver.js';
+import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
@@ -30,20 +30,25 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
-    connect(): Promise<C>;
-    reconnect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     close(force?: boolean): Promise<void>;
     getPlatform(): Platform;
     setMetadata(metadata: MetadataStorage): void;
     getMetadata(): MetadataStorage;
     getDependencies(): string[];
+    protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;
@@ -55,6 +60,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected getPrimaryKeyFields(entityName: string): string[];
     protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    abstract stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     /**
      * @inheritDoc
      */

package/drivers/DatabaseDriver.js

@@ -65,14 +65,14 @@ export class DatabaseDriver {
         }
         return this.comparator.mapResult(meta.className, result);
     }
-    async connect() {
-        await this.connection.connect();
+    async connect(options) {
+        await this.connection.connect(options);
         await Promise.all(this.replicas.map(replica => replica.connect()));
         return this.connection;
     }
-    async reconnect() {
+    async reconnect(options) {
         await this.close(true);
-        await this.connect();
+        await this.connect(options);
         return this.connection;
     }
     getConnection(type = 'write') {
@@ -105,6 +105,15 @@ export class DatabaseDriver {
     getDependencies() {
         return this.dependencies;
     }
+    isPopulated(meta, prop, hint, name) {
+        if (hint.field === prop.name || hint.field === name || hint.all) {
+            return true;
+        }
+        if (prop.embedded && hint.children && meta.properties[prop.embedded[0]].name === hint.field) {
+            return hint.children.some(c => this.isPopulated(meta, prop, c, prop.embedded[1]));
+        }
+        return false;
+    }
     processCursorOptions(meta, options, orderBy) {
         const { first, last, before, after, overfetch } = options;
         const limit = first ?? last;

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings.js';
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -14,9 +14,13 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    connect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     close(force?: boolean): Promise<void>;
-    reconnect(): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     /**
      * Finds selection of entities
@@ -27,6 +31,7 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      */
     findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
@@ -68,6 +73,18 @@ export type OrderDefinition<T> = (QueryOrderMap<T> & {
 export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
+export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
+    /**
+     * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
+     * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
+     * the SQL result, but still mapped to entities, meaning that to-many collections will contain at most
+     * a single item, and you will get duplicate root entities when they have multiple items in the populated
+     * collection.
+     *
+     * @default true
+     */
+    mergeResults?: boolean;
+}
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
 export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
@@ -146,10 +163,13 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+    includeCount?: I;
 }
-export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }
@@ -163,6 +183,7 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -197,6 +218,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;
@@ -218,6 +241,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?;
@@ -14,8 +15,8 @@ export declare class ArrayCollection<T extends object, O extends object> {
     getItems(): T[];
     toArray<TT extends T>(): EntityDTO<TT>[];
     toJSON(): EntityDTO<T>[];
-    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string): U[];
-    add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
+    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
+    add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): number;
     /**
      * @internal
      */
@@ -25,14 +26,14 @@ 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()`
      * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
      * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
      */
-    remove(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
+    remove(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): number;
     /**
      * Remove all items from the collection. Note that removing items 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;
@@ -40,28 +41,38 @@ export class ArrayCollection {
     }
     getIdentifiers(field) {
         const items = this.getItems();
+        const targetMeta = this.property.targetMeta;
         if (items.length === 0) {
             return [];
         }
-        field ??= this.property.targetMeta.serializedPrimaryKey;
+        field ??= targetMeta.compositePK ? targetMeta.primaryKeys : (targetMeta.serializedPrimaryKey ?? targetMeta.primaryKeys[0]);
+        const cb = (i, f) => {
+            if (Utils.isEntity(i[f], true)) {
+                return wrap(i[f], true).getPrimaryKey();
+            }
+            return i[f];
+        };
         return items.map(i => {
-            if (Utils.isEntity(i[field], true)) {
-                return wrap(i[field], true).getPrimaryKey();
+            if (Array.isArray(field)) {
+                return field.map(f => cb(i, f));
             }
-            return i[field];
+            return cb(i, field);
         });
     }
     add(entity, ...entities) {
         entities = Utils.asArray(entity).concat(entities);
+        let added = 0;
         for (const item of entities) {
             const entity = Reference.unwrapReference(item);
             if (!this.contains(entity, false)) {
                 this.incrementCount(1);
                 this[this.items.size] = entity;
                 this.items.add(entity);
+                added++;
                 this.propagate(entity, 'add');
             }
         }
+        return added;
     }
     /**
      * @internal
@@ -100,11 +111,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);
@@ -118,7 +130,7 @@ export class ArrayCollection {
      */
     remove(entity, ...entities) {
         entities = Utils.asArray(entity).concat(entities);
-        let modified = false;
+        let removed = 0;
         for (const item of entities) {
             if (!item) {
                 continue;
@@ -128,12 +140,13 @@ export class ArrayCollection {
                 this.incrementCount(-1);
                 delete this[this.items.size]; // remove last item
                 this.propagate(entity, 'remove');
-                modified = true;
+                removed++;
             }
         }
-        if (modified) {
+        if (removed > 0) {
             Object.assign(this, [...this.items]); // reassign array access
         }
+        return removed;
     }
     /**
      * Remove all items from the collection. Note that removing items from collection does not necessarily imply deleting the target entity,
@@ -147,6 +160,7 @@ export class ArrayCollection {
             this.snapshot = undefined;
         }
         this.remove(this.items);
+        this.setDirty();
     }
     /**
      * @internal
@@ -267,6 +281,9 @@ export class ArrayCollection {
     isDirty() {
         return this.dirty;
     }
+    isPartial() {
+        return this.partial;
+    }
     isEmpty() {
         return this.count() === 0;
     }
@@ -383,7 +400,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/BaseEntity.d.ts

@@ -6,7 +6,6 @@ import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions } from '../drivers/IDatabaseDriver.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
-    isTouched(): boolean;
     populated(populated?: boolean): void;
     populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;

package/entity/BaseEntity.js

@@ -6,9 +6,6 @@ export class BaseEntity {
     isInitialized() {
         return helper(this).__initialized;
     }
-    isTouched() {
-        return helper(this).__touched;
-    }
     populated(populated = true) {
         helper(this).populated(populated);
     }

package/entity/Collection.d.ts

@@ -2,7 +2,7 @@ import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Popul
 import { ArrayCollection } from './ArrayCollection.js';
 import { Reference } from './Reference.js';
 import type { Transaction } from '../connections/Connection.js';
-import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver.js';
+import type { CountOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 export interface MatchingOptions<T extends object, P extends string = never> extends FindOptions<T, P> {
     where?: FilterQuery<T>;
@@ -12,7 +12,6 @@ export interface MatchingOptions<T extends object, P extends string = never> ext
 export declare class Collection<T extends object, O extends object = object> extends ArrayCollection<T, O> {
     private readonly?;
     private _populated?;
-    private _em?;
     private _snapshot?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**
@@ -40,11 +39,11 @@ export declare class Collection<T extends object, O extends object = object> ext
      */
     getItems(check?: boolean): T[];
     toJSON<TT extends T>(): EntityDTO<TT>[];
-    add<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): void;
+    add<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): number;
     /**
      * @inheritDoc
      */
-    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): void;
+    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): number;
     contains<TT extends T>(item: TT | Reference<TT>, check?: boolean): boolean;
     count(): number;
     isEmpty(): boolean;

package/entity/Collection.js

@@ -1,13 +1,13 @@
 import { ArrayCollection } from './ArrayCollection.js';
 import { Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
-import { ReferenceKind, DataloaderType } from '../enums.js';
+import { DataloaderType, ReferenceKind } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 export class Collection extends ArrayCollection {
     readonly;
     _populated;
-    _em;
     // this is for some reason needed for TS, otherwise it can fail with `Type instantiation is excessively deep and possibly infinite.`
     _snapshot;
     constructor(owner, items, initialized = true) {
@@ -33,6 +33,7 @@ export class Collection extends ArrayCollection {
     async load(options = {}) {
         if (this.isInitialized(true) && !options.refresh) {
             const em = this.getEntityManager(this.items, false);
+            options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
             await em?.populate(this.items, options.populate, options);
             this.setSerializationContext(options);
         }
@@ -116,30 +117,33 @@ export class Collection extends ArrayCollection {
         entities = Utils.asArray(entity).concat(entities);
         const unwrapped = entities.map(i => Reference.unwrapReference(i));
         unwrapped.forEach(entity => this.validateItemType(entity));
-        this.modify('add', unwrapped);
+        const added = this.modify('add', unwrapped);
         this.cancelOrphanRemoval(unwrapped);
+        return added;
     }
     /**
      * @inheritDoc
      */
     remove(entity, ...entities) {
         if (entity instanceof Function) {
+            let removed = 0;
             for (const item of this.items) {
                 if (entity(item)) {
-                    this.remove(item);
+                    removed += this.remove(item);
                 }
             }
-            return;
+            return removed;
         }
         entities = Utils.asArray(entity).concat(entities);
         const unwrapped = entities.map(i => Reference.unwrapReference(i));
-        this.modify('remove', unwrapped);
+        const removed = this.modify('remove', unwrapped);
         const em = this.getEntityManager(unwrapped, false);
         if (this.property.orphanRemoval && em) {
             for (const item of unwrapped) {
                 em.getUnitOfWork().scheduleOrphanRemoval(item);
             }
         }
+        return removed;
     }
     contains(item, check = true) {
         if (check) {
@@ -218,13 +222,21 @@ export class Collection extends ArrayCollection {
             return this;
         }
         const em = this.getEntityManager();
+        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 customOrder = !!options.orderBy;
-            // eslint-disable-next-line dot-notation
-            const items = await em['colLoader'].load([this, options]);
-            if (!customOrder) {
-                this.reorderItems(items, order);
+            const orderBy = this.createOrderBy(options.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');
+            const items = await loader.load([this, { ...options, orderBy }]);
+            if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
+                this.initialized = true;
+                this.dirty = false;
+                if (!customOrder) {
+                    this.reorderItems(items, order);
+                }
+                return this;
             }
             this.items.clear();
             let i = 0;
@@ -254,18 +266,17 @@ export class Collection extends ArrayCollection {
     }
     getEntityManager(items = [], required = true) {
         const wrapped = helper(this.owner);
-        let em = (this._em ?? wrapped.__em);
+        let em = wrapped.__em;
+        // console.log('wat 1', em, this.owner);
         if (!em) {
             for (const i of items) {
+                // console.log('wat 2', i, i && helper(i).__em);
                 if (i && helper(i).__em) {
                     em = helper(i).__em;
                     break;
                 }
             }
         }
-        if (em) {
-            Object.defineProperty(this, '_em', { value: em });
-        }
         if (!em && required) {
             throw ValidationError.entityNotManaged(this.owner);
         }
@@ -316,8 +327,14 @@ export class Collection extends ArrayCollection {
             this.checkInitialized();
         }
         this.validateModification(items);
-        super[method](items);
-        this.setDirty();
+        const modified = super[method](items);
+        if (modified > 0) {
+            this.setDirty();
+        }
+        if (this.property.kind === ReferenceKind.ONE_TO_MANY && (method === 'add' || !this.property.orphanRemoval)) {
+            this.getEntityManager(items, false)?.persist(items);
+        }
+        return modified;
     }
     checkInitialized() {
         if (!this.isInitialized()) {

package/entity/EntityAssigner.d.ts

@@ -36,7 +36,7 @@ export interface AssignOptions<Convert extends boolean> {
      */
     onlyProperties?: boolean;
     /**
-     * With `onlyOwnProperties` enabled, to-many relations are skipped, and payloads of to-one relations are converted
+     * With `onlyOwnProperties` enabled, inverse sides of to-many relations are skipped, and payloads of other relations are converted
      * to foreign keys. Defaults to `false`.
      */
     onlyOwnProperties?: boolean;

package/entity/EntityAssigner.js

@@ -42,9 +42,17 @@ export class EntityAssigner {
         }
         const prop = { ...props[propName], name: propName };
         if (prop && options.onlyOwnProperties) {
-            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 return;
             }
+            if ([ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                if (!prop.owner) {
+                    return;
+                }
+                else if (value?.map) {
+                    value = value.map((v) => Utils.extractPK(v, prop.targetMeta));
+                }
+            }
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 value = Utils.extractPK(value, prop.targetMeta);
             }

package/entity/EntityFactory.d.ts

@@ -4,12 +4,18 @@ 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;
     recomputeSnapshot?: boolean;
     schema?: string;
     parentSchema?: string;
+    normalizeAccessors?: boolean;
 }
 export declare class EntityFactory {
     private readonly em;
@@ -27,6 +33,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;