@mikro-orm/core 7.0.0-dev.42 → 7.0.0-dev.44

package/EntityManager.d.ts

@@ -10,7 +10,7 @@ import { EntityLoader, type EntityLoaderOptions } from './entity/EntityLoader.js
 import { Reference } from './entity/Reference.js';
 import { UnitOfWork } from './unit-of-work/UnitOfWork.js';
 import type { CountOptions, DeleteOptions, FilterOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers/IDatabaseDriver.js';
-import type { AnyEntity, AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MaybePromise, MergeLoaded, MergeSelected, NoInfer, ObjectQuery, Primary, Ref, RequiredEntityData, UnboxArray } from './typings.js';
+import type { AnyEntity, AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MergeLoaded, MergeSelected, NoInfer, ObjectQuery, Primary, Ref, RequiredEntityData, UnboxArray } from './typings.js';
 import { FlushMode, LockMode, PopulatePath, type TransactionOptions } from './enums.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { Transaction } from './connections/Connection.js';
@@ -109,19 +109,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter<T1>(name: string, cond: FilterQuery<T1> | ((args: Dictionary) => MaybePromise<FilterQuery<T1>>), entityName?: EntityName<T1> | [EntityName<T1>], options?: boolean | Partial<FilterDef>): void;
-    /**
-     * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-     */
-    addFilter<T1, T2>(name: string, cond: FilterQuery<T1 | T2> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2>>), entityName?: [EntityName<T1>, EntityName<T2>], options?: boolean | Partial<FilterDef>): void;
-    /**
-     * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-     */
-    addFilter<T1, T2, T3>(name: string, cond: FilterQuery<T1 | T2 | T3> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2 | T3>>), entityName?: [EntityName<T1>, EntityName<T2>, EntityName<T3>], options?: boolean | Partial<FilterDef>): void;
-    /**
-     * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-     */
-    addFilter(name: string, cond: Dictionary | ((args: Dictionary) => MaybePromise<FilterQuery<AnyEntity>>), entityName?: EntityName<AnyEntity> | EntityName<AnyEntity>[], options?: boolean | Partial<FilterDef>): void;
+    addFilter<T extends object>(options: FilterDef<T>): void;
     /**
      * Sets filter parameter values globally inside context defined by this entity manager.
      * If you want to set shared value for all contexts, be sure to use the root entity manager.

package/EntityManager.js

@@ -256,15 +256,34 @@ export class EntityManager {
         }
         return { where: options.populateWhere };
     }
+    // /**
+    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
+    //  */
+    // addFilter<T1>(name: string, cond: FilterQuery<T1> | ((args: Dictionary) => MaybePromise<FilterQuery<T1>>), entityName?: EntityName<T1> | [EntityName<T1>], options?: boolean | Partial<FilterDef>): void;
+    //
+    // /**
+    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
+    //  */
+    // addFilter<T1, T2>(name: string, cond: FilterQuery<T1 | T2> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2>>), entityName?: [EntityName<T1>, EntityName<T2>], options?: boolean | Partial<FilterDef>): void;
+    //
+    // /**
+    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
+    //  */
+    // addFilter<T1, T2, T3>(name: string, cond: FilterQuery<T1 | T2 | T3> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2 | T3>>), entityName?: [EntityName<T1>, EntityName<T2>, EntityName<T3>], options?: boolean | Partial<FilterDef>): void;
+    //
+    // /**
+    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
+    //  */
+    // addFilter(name: string, cond: Dictionary | ((args: Dictionary) => MaybePromise<FilterQuery<AnyEntity>>), entityName?: EntityName<AnyEntity> | EntityName<AnyEntity>[], options?: boolean | Partial<FilterDef>): void;
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter(name, cond, entityName, options = true) {
-        options = typeof options === 'object' ? { name, cond, default: true, ...options } : { name, cond, default: options };
-        if (entityName) {
-            options.entity = Utils.asArray(entityName).map(n => Utils.className(n));
+    addFilter(options) {
+        if (options.entity) {
+            options.entity = Utils.asArray(options.entity).map(n => Utils.className(n));
         }
-        this.getContext(false).filters[name] = options;
+        options.default ??= true;
+        this.getContext(false).filters[options.name] = options;
     }
     /**
      * Sets filter parameter values globally inside context defined by this entity manager.

package/MikroORM.d.ts

@@ -21,7 +21,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options?: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
@@ -29,7 +29,6 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * - no support for folder based discovery
      * - no check for mismatched package versions
      */
-    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): MikroORM<D, EM, Entities>;
     constructor(options: Options<Driver, EM>);
     /**
      * Connects to the database.

package/MikroORM.js

@@ -23,22 +23,14 @@ export class MikroORM {
      * If you omit the `options` parameter, your CLI config will be used.
      */
     static async init(options) {
-        ConfigurationLoader.registerDotenv(options);
-        const coreVersion = ConfigurationLoader.checkPackageVersion();
-        const env = await ConfigurationLoader.loadEnvironmentVars();
+        /* v8 ignore next 3 */
         if (!options) {
-            const configPathFromArg = ConfigurationLoader.configPathsFromArg();
-            const config = (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPathFromArg ?? ConfigurationLoader.getConfigPaths()));
-            options = config.getAll();
-            if (configPathFromArg) {
-                config.getLogger().warn('deprecated', 'Path for config file was inferred from the command line arguments. Instead, you should set the MIKRO_ORM_CLI_CONFIG environment variable to specify the path, or if you really must use the command line arguments, import the config manually based on them, and pass it to init.', { label: 'D0001' });
-            }
-        }
-        options = Utils.mergeConfig(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
+            throw new Error(`options parameter is required`);
         }
-        const orm = new MikroORM(options);
+        const coreVersion = ConfigurationLoader.checkPackageVersion();
+        options.discovery ??= {};
+        options.discovery.skipSyncDiscovery ??= true;
+        const orm = new this(options);
         orm.logger.log('info', `MikroORM version: ${colors.green(coreVersion)}`);
         // we need to allow global context here as we are not in a scope of requests yet
         const allowGlobalContext = orm.config.get('allowGlobalContext');
@@ -46,15 +38,6 @@ export class MikroORM {
         await orm.discoverEntities();
         orm.config.set('allowGlobalContext', allowGlobalContext);
         orm.driver.getPlatform().init(orm);
-        if (orm.config.get('connect')) {
-            await orm.connect();
-        }
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        if (orm.config.get('connect') && orm.config.get('ensureIndexes')) {
-            await orm.getSchemaGenerator().ensureIndexes();
-        }
         return orm;
     }
     /**
@@ -64,26 +47,10 @@ export class MikroORM {
      * - no support for folder based discovery
      * - no check for mismatched package versions
      */
-    static initSync(options) {
+    constructor(options) {
         ConfigurationLoader.registerDotenv(options);
         const env = ConfigurationLoader.loadEnvironmentVarsSync();
         options = Utils.merge(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        orm.discoverEntitiesSync();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        return orm;
-    }
-    constructor(options) {
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
         if (discovery.disableDynamicFileAccess) {
@@ -94,25 +61,23 @@ export class MikroORM {
         this.driver = this.config.getDriver();
         this.logger = this.config.getLogger();
         this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        if (!discovery.skipSyncDiscovery) {
+            // we need to allow global context here as we are not in a scope of requests yet
+            const allowGlobalContext = this.config.get('allowGlobalContext');
+            this.config.set('allowGlobalContext', true);
+            this.discoverEntitiesSync();
+            this.config.set('allowGlobalContext', allowGlobalContext);
+            this.driver.getPlatform().init(this);
+        }
+        for (const extension of this.config.get('extensions')) {
+            extension.register(this);
+        }
     }
     /**
      * Connects to the database.
      */
     async connect() {
-        const connection = await this.driver.connect();
-        const clientUrl = connection.getClientUrl();
-        const dbName = this.config.get('dbName');
-        const db = dbName + (clientUrl ? ' on ' + clientUrl : '');
-        if (this.config.get('ensureDatabase')) {
-            const options = this.config.get('ensureDatabase');
-            await this.schema.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
-        }
-        if (await this.isConnected()) {
-            this.logger.log('info', `MikroORM successfully connected to database ${colors.green(db)}`);
-        }
-        else {
-            this.logger.error('info', `MikroORM failed to connect to database ${db}`);
-        }
+        await this.driver.connect();
         return this.driver;
     }
     /**
@@ -141,9 +106,7 @@ export class MikroORM {
      * Closes the database connection.
      */
     async close(force = false) {
-        if (await this.isConnected()) {
-            await this.driver.close(force);
-        }
+        await this.driver.close(force);
         if (this.config.getMetadataCacheAdapter()?.close) {
             await this.config.getMetadataCacheAdapter().close();
         }
@@ -166,7 +129,7 @@ export class MikroORM {
         this.createEntityManager();
     }
     discoverEntitiesSync() {
-        this.metadata = this.discovery.discoverSync(this.config.get('preferTs'));
+        this.metadata = this.discovery.discoverSync();
         this.createEntityManager();
     }
     createEntityManager() {

package/connections/Connection.d.ts

@@ -17,7 +17,9 @@ export declare abstract class Connection {
     /**
      * Establishes connection to database
      */
-    abstract connect(): void | Promise<void>;
+    abstract connect(options?: {
+        skipOnConnect?: boolean;
+    }): void | Promise<void>;
     /**
      * Are we connected to the database
      */
@@ -37,9 +39,10 @@ export declare abstract class Connection {
      */
     close(force?: boolean): Promise<void>;
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     ensureConnection(): Promise<void>;
+    protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
@@ -58,7 +61,6 @@ export declare abstract class Connection {
     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;
     setMetadata(metadata: MetadataStorage): void;
     setPlatform(platform: Platform): void;
     getPlatform(): Platform;

package/connections/Connection.js

@@ -33,13 +33,25 @@ export class Connection {
             .forEach(k => delete this.options[k]);
     }
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     async ensureConnection() {
         if (!this.connected) {
             await this.connect();
         }
     }
+    async onConnect() {
+        const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        if (this.type === 'write' && schemaGenerator) {
+            if (this.config.get('ensureDatabase')) {
+                const options = this.config.get('ensureDatabase');
+                await schemaGenerator.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+            }
+            if (this.config.get('ensureIndexes')) {
+                await schemaGenerator.ensureIndexes();
+            }
+        }
+    }
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
@@ -67,7 +79,7 @@ export class Connection {
             }
         }
         else {
-            const url = new URL(this.config.getClientUrl());
+            const url = new URL(this.config.get('clientUrl'));
             this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
             this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
             this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
@@ -76,15 +88,6 @@ export class Connection {
         }
         return ret;
     }
-    getClientUrl() {
-        const options = this.getConnectionOptions();
-        const url = new URL(this.config.getClientUrl(true));
-        const password = options.password ? ':*****' : '';
-        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
-            ? `?schema=${options.schema}`
-            : '';
-        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
-    }
     setMetadata(metadata) {
         this.metadata = metadata;
     }

package/decorators/Property.d.ts

@@ -113,12 +113,6 @@ export interface PropertyOptions<Owner> {
      * Enable `ScalarReference` wrapper for lazy values. Use this in combination with `lazy: true` to have a type-safe accessor object in place of the value.
      */
     ref?: boolean;
-    /**
-     * Set false to disable change tracking on a property level.
-     *
-     * @see https://mikro-orm.io/docs/unit-of-work#change-tracking-and-performance-considerations
-     */
-    trackChanges?: boolean;
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */

package/drivers/DatabaseDriver.d.ts

@@ -36,8 +36,12 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     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;

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

package/drivers/IDatabaseDriver.d.ts

@@ -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

package/entity/ArrayCollection.d.ts

@@ -16,7 +16,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     toArray<TT extends T>(): EntityDTO<TT>[];
     toJSON(): EntityDTO<T>[];
     getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
-    add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
+    add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): number;
     /**
      * @internal
      */
@@ -33,7 +33,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
      * 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()`

package/entity/ArrayCollection.js

@@ -61,15 +61,18 @@ export class ArrayCollection {
     }
     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
@@ -127,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;
@@ -137,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,
@@ -156,6 +160,7 @@ export class ArrayCollection {
             this.snapshot = undefined;
         }
         this.remove(this.items);
+        this.setDirty();
     }
     /**
      * @internal

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

@@ -39,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,7 +1,7 @@
 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';
@@ -117,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) {
@@ -267,8 +270,10 @@ export class Collection extends ArrayCollection {
     getEntityManager(items = [], required = true) {
         const wrapped = helper(this.owner);
         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;
@@ -325,8 +330,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/EntityFactory.js

@@ -84,7 +84,6 @@ export class EntityFactory {
         else {
             this.hydrate(entity, meta2, data, options);
         }
-        wrapped.__touched = false;
         if (exists && meta.discriminatorColumn && !(entity instanceof meta2.class)) {
             Object.setPrototypeOf(entity, meta2.prototype);
         }
@@ -161,7 +160,6 @@ export class EntityFactory {
             }
         });
         this.unitOfWork.normalizeEntityData(meta, originalEntityData);
-        helper(entity).__touched = false;
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;

package/entity/EntityHelper.js

@@ -87,7 +87,7 @@ export class EntityHelper {
                 });
                 return;
             }
-            if (prop.inherited || prop.primary || prop.accessor || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
+            if (prop.inherited || prop.primary || prop.accessor || prop.persist === false || prop.embedded || isCollection) {
                 return;
             }
             Object.defineProperty(meta.prototype, prop.name, {
@@ -98,13 +98,11 @@ export class EntityHelper {
                         },
                         set(val) {
                             this.__helper.__data[prop.name] = val;
-                            this.__helper.__touched = !this.__helper.hydrator.isRunning();
                         },
                         enumerable: true,
                         configurable: true,
                     });
                     this.__helper.__data[prop.name] = val;
-                    this.__helper.__touched = !this.__helper.hydrator.isRunning();
                 },
                 configurable: true,
             });
@@ -114,7 +112,7 @@ export class EntityHelper {
         // @ts-ignore
         meta.prototype[inspect.custom] ??= function (depth = 2) {
             const object = {};
-            const keys = new Set(Utils.keys(this)); // .sort((a, b) => (meta.propertyOrder.get(a) ?? 0) - (meta.propertyOrder.get(b) ?? 0));
+            const keys = new Set(Utils.keys(this));
             for (const prop of meta.props) {
                 if (keys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
                     object[prop.name] = this[prop.name];
@@ -165,9 +163,6 @@ export class EntityHelper {
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
                     wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
-                else {
-                    wrapped.__touched = !hydrator.isRunning();
-                }
                 EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
             },
             enumerable: true,

package/entity/WrappedEntity.d.ts

@@ -11,7 +11,6 @@ import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver.js';
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
-    __touched: boolean;
     __populated?: boolean;
     __managed?: boolean;
     __onLoadFired?: boolean;
@@ -41,7 +40,6 @@ export declare class WrappedEntity<Entity extends object> {
     private readonly pkGetterConverted?;
     constructor(entity: Entity, hydrator: IHydrator, pkGetter?: (e: Entity) => Primary<Entity>, pkSerializer?: (e: Entity) => string, pkGetterConverted?: (e: Entity) => Primary<Entity>);
     isInitialized(): boolean;
-    isTouched(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean | undefined): void;
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;

package/entity/WrappedEntity.js

@@ -15,7 +15,6 @@ export class WrappedEntity {
         this.pkSerializer = pkSerializer;
         this.pkGetterConverted = pkGetterConverted;
         this.__initialized = true;
-        this.__touched = false;
         this.__serializationContext = {};
         this.__loadedProperties = new Set();
         this.__data = {};
@@ -24,9 +23,6 @@ export class WrappedEntity {
     isInitialized() {
         return this.__initialized;
     }
-    isTouched() {
-        return this.__touched;
-    }
     isManaged() {
         return !!this.__managed;
     }