@mikro-orm/core 7.0.0-dev.43 → 7.0.0-dev.45

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/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/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;
     }

package/entity/defineEntity.d.ts

@@ -178,12 +178,6 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     ref<T extends boolean = true>(ref?: T): UniversalPropertyOptionsBuilder<Value, Omit<Options, 'ref'> & {
         ref: T;
     }, IncludeKeys>;
-    /**
-     * 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(trackChanges?: boolean): UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>;
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */

package/entity/defineEntity.js

@@ -170,14 +170,6 @@ export class UniversalPropertyOptionsBuilder {
     ref(ref = true) {
         return this.assignOptions({ ref });
     }
-    /**
-     * 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(trackChanges = true) {
-        return this.assignOptions({ trackChanges });
-    }
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */

package/metadata/MetadataDiscovery.js

@@ -100,7 +100,6 @@ export class MetadataDiscovery {
                 this.initFieldName(prop);
                 prop.serializedName ??= prop.accessor;
                 prop.name = name;
-                prop.trackChanges = false;
             }
         }
     }
@@ -132,10 +131,6 @@ export class MetadataDiscovery {
                 this.initDefaultValue(prop);
                 this.inferTypeFromDefault(prop);
                 this.initColumnType(prop);
-                // change tracking on scalars is used only for "auto" flushMode
-                if (this.config.get('flushMode') !== 'auto' && [ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind)) {
-                    prop.trackChanges = false;
-                }
             }
         }
         filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initIndexes(meta, prop)));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.43",
+  "version": "7.0.0-dev.45",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -54,7 +54,7 @@
     "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.43",
+    "mikro-orm": "7.0.0-dev.45",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/serialization/EntitySerializer.js

@@ -41,13 +41,31 @@ export class EntitySerializer {
         }
         const root = wrapped.__serializationContext.root;
         const ret = {};
-        const keys = new Set(meta.primaryKeys);
-        Utils.keys(entity).forEach(prop => keys.add(prop));
+        const props = new Set();
+        if (meta.serializedPrimaryKey && !meta.compositePK) {
+            props.add(meta.serializedPrimaryKey);
+        }
+        else {
+            meta.primaryKeys.forEach(pk => props.add(pk));
+        }
+        if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
+            const entityKeys = new Set(Object.keys(entity));
+            for (const prop of meta.props) {
+                if (entityKeys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    props.add(prop.name);
+                }
+            }
+            for (const key of entityKeys) {
+                if (!meta.properties[key]) {
+                    props.add(key);
+                }
+            }
+        }
         const visited = root.visited.has(entity);
         if (!visited) {
             root.visited.add(entity);
         }
-        for (const prop of keys) {
+        for (const prop of props) {
             if (!isVisible(meta, prop, options)) {
                 continue;
             }

package/serialization/EntityTransformer.js

@@ -27,22 +27,32 @@ export class EntityTransformer {
         const root = wrapped.__serializationContext.root;
         const meta = wrapped.__meta;
         const ret = {};
-        const keys = new Set();
+        const props = new Set();
         if (meta.serializedPrimaryKey && !meta.compositePK) {
-            keys.add(meta.serializedPrimaryKey);
+            props.add(meta.serializedPrimaryKey);
         }
         else {
-            meta.primaryKeys.forEach(pk => keys.add(pk));
+            meta.primaryKeys.forEach(pk => props.add(pk));
         }
         if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
-            Utils.keys(entity).forEach(prop => keys.add(prop));
+            const entityKeys = new Set(Object.keys(entity));
+            for (const prop of meta.props) {
+                if (entityKeys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    props.add(prop.name);
+                }
+            }
+            for (const key of entityKeys) {
+                if (!meta.properties[key]) {
+                    props.add(key);
+                }
+            }
         }
         const visited = root.visited.has(entity);
         const includePrimaryKeys = wrapped.__config.get('serialization').includePrimaryKeys;
         if (!visited) {
             root.visited.add(entity);
         }
-        for (const prop of keys) {
+        for (const prop of props) {
             const visible = raw ? meta.properties[prop] : isVisible(meta, prop, ignoreFields);
             if (!visible) {
                 continue;

package/typings.d.ts

@@ -160,7 +160,6 @@ export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T
 export type QBFilterQuery<T = any> = ObjectQuery<T> | Dictionary;
 export interface IWrappedEntity<Entity extends object> {
     isInitialized(): boolean;
-    isTouched(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean): void;
     populate<Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
@@ -191,7 +190,6 @@ export interface IWrappedEntityInternal<Entity extends object> extends IWrappedE
     __factory: EntityFactory;
     __hydrator: IHydrator;
     __initialized: boolean;
-    __touched: boolean;
     __originalEntityData?: EntityData<Entity>;
     __loadedProperties: Set<string>;
     __identifier?: EntityIdentifier | EntityIdentifier[];
@@ -378,7 +376,6 @@ export interface EntityProperty<Owner = any, Target = any> {
     mapToPk?: boolean;
     persist?: boolean;
     hydrate?: boolean;
-    trackChanges?: boolean;
     hidden?: boolean;
     enum?: boolean;
     items?: (number | string)[];
@@ -607,8 +604,6 @@ export interface GenerateOptions {
     coreImportsPrefix?: string;
     onInitialMetadata?: MetadataProcessor;
     onProcessedMetadata?: MetadataProcessor;
-    /** @deprecated use `entityDefinition: 'entitySchema'` instead */
-    entitySchema?: boolean;
 }
 export interface IEntityGenerator {
     generate(options?: GenerateOptions): Promise<string[]>;
@@ -722,11 +717,11 @@ export interface MigrationObject {
     name: string;
     class: Constructor<Migration>;
 }
-export type FilterDef = {
+export type FilterDef<T extends object = any> = {
     name: string;
-    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: EntityName<any>) => Dictionary | Promise<Dictionary>);
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, entityName?: EntityName<T>) => MaybePromise<Dictionary>);
     default?: boolean;
-    entity?: string[];
+    entity?: EntityName<T> | EntityName<T>[];
     args?: boolean;
     strict?: boolean;
 };

package/typings.js

@@ -90,11 +90,12 @@ export class EntityMetadata {
             const onlyGetter = prop.getter && !prop.setter && prop.persist === false;
             return !prop.inherited && prop.hydrate !== false && !discriminator && !prop.embedded && !onlyGetter;
         });
-        this.trackingProps = this.hydrateProps
-            .filter(prop => !prop.getter && !prop.setter && prop.trackChanges !== false)
-            .filter(prop => ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind))
-            .filter(prop => !prop.serializedPrimaryKey);
-        this.selfReferencing = this.relations.some(prop => [this.className, this.root.className].includes(prop.targetMeta?.root.className ?? prop.type));
+        this.trackingProps = this.hydrateProps.filter(prop => {
+            return !prop.getter && !prop.setter && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
+        });
+        this.selfReferencing = this.relations.some(prop => {
+            return [this.className, this.root.className].includes(prop.targetMeta?.root.className ?? prop.type);
+        });
         this.hasUniqueProps = this.uniques.length + this.uniqueProps.length > 0;
         this.virtual = !!this.expression;
         if (config) {
@@ -126,8 +127,7 @@ export class EntityMetadata {
             this.props.forEach(prop => this.initIndexes(prop));
         }
         this.definedProperties = this.trackingProps.reduce((o, prop) => {
-            const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
-            const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
+            const isReference = (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const meta = this;
@@ -148,32 +148,12 @@ export class EntityMetadata {
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
                             wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
                         }
-                        else {
-                            wrapped.__touched = !hydrator.isRunning();
-                        }
                         EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
                     },
                     enumerable: true,
                     configurable: true,
                 };
             }
-            if (prop.inherited || prop.primary || isCollection || prop.persist === false || prop.trackChanges === false || isReference || prop.embedded) {
-                return o;
-            }
-            o[prop.name] = {
-                get() {
-                    return this.__helper.__data[prop.name];
-                },
-                set(val) {
-                    if (typeof val === 'object' && !!val && '__raw' in val) {
-                        val.assign();
-                    }
-                    this.__helper.__data[prop.name] = val;
-                    this.__helper.__touched = !this.__helper.hydrator.isRunning();
-                },
-                enumerable: true,
-                configurable: true,
-            };
             return o;
         }, { __gettersDefined: { value: true, enumerable: false } });
     }

package/unit-of-work/ChangeSetComputer.js

@@ -34,8 +34,11 @@ export class ChangeSetComputer {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
         }
-        if (type === ChangeSetType.UPDATE && !wrapped.__initialized && !wrapped.isTouched()) {
-            return null;
+        if (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
+            const data = this.comparator.prepareEntity(entity);
+            if (Utils.equals(data, wrapped.__originalEntityData)) {
+                return null;
+            }
         }
         const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
         changeSet.originalEntity = wrapped.__originalEntityData;

package/unit-of-work/UnitOfWork.js

@@ -61,7 +61,6 @@ export class UnitOfWork {
         // as there can be some entity with already changed state that is not yet flushed
         if (wrapped.__initialized && (!visited || !wrapped.__originalEntityData)) {
             wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-            wrapped.__touched = false;
         }
         this.cascade(entity, Cascade.MERGE, visited ?? new Set());
     }
@@ -124,7 +123,6 @@ export class UnitOfWork {
                 }
             }
             wrapped.__originalEntityData = data;
-            wrapped.__touched = false;
         }
         return entity;
     }
@@ -215,11 +213,6 @@ export class UnitOfWork {
         if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.queuedActions.has(v))) {
             return true;
         }
-        for (const entity of this.identityMap.getStore(meta).values()) {
-            if (helper(entity).__initialized && helper(entity).isTouched()) {
-                return true;
-            }
-        }
         return false;
     }
     clearActionsQueue() {
@@ -239,7 +232,6 @@ export class UnitOfWork {
         this.changeSets.set(entity, cs);
         this.persistStack.delete(entity);
         wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-        wrapped.__touched = false;
     }
     recomputeSingleChangeSet(entity) {
         const changeSet = this.changeSets.get(entity);
@@ -250,7 +242,6 @@ export class UnitOfWork {
         if (cs && !this.checkUniqueProps(cs)) {
             Object.assign(changeSet.payload, cs.payload);
             helper(entity).__originalEntityData = this.comparator.prepareEntity(entity);
-            helper(entity).__touched = false;
         }
     }
     persist(entity, visited, options = {}) {
@@ -402,7 +393,6 @@ export class UnitOfWork {
         }
         delete wrapped.__identifier;
         delete wrapped.__originalEntityData;
-        wrapped.__touched = false;
         wrapped.__managed = false;
     }
     computeChangeSets() {
@@ -412,14 +402,14 @@ export class UnitOfWork {
             this.cascade(entity, Cascade.REMOVE, visited);
         }
         visited.clear();
-        for (const entity of this.persistStack) {
-            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
-        }
         for (const entity of this.identityMap) {
             if (!this.removeStack.has(entity) && !this.persistStack.has(entity) && !this.orphanRemoveStack.has(entity)) {
                 this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
             }
         }
+        for (const entity of this.persistStack) {
+            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
+        }
         visited.clear();
         for (const entity of this.persistStack) {
             this.findNewEntities(entity, visited);
@@ -876,7 +866,6 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             const wrapped = helper(changeSet.entity);
             wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
-            wrapped.__touched = false;
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
                     if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {

package/utils/Configuration.d.ts

@@ -114,12 +114,12 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         entityGenerator: {
             forceUndefined: true;
             undefinedDefaults: false;
-            bidirectionalRelations: false;
-            identifiedReferences: false;
             scalarTypeInDecorator: false;
+            bidirectionalRelations: true;
+            identifiedReferences: true;
             scalarPropertiesForRelations: "never";
-            entityDefinition: "decorators";
-            enumMode: "ts-enum";
+            entityDefinition: "defineEntity";
+            enumMode: "dictionary";
             fileName: (className: string) => string;
             onlyPurePivotTables: false;
             outputPurePivotTables: false;

package/utils/Configuration.js

@@ -104,12 +104,12 @@ export class Configuration {
         entityGenerator: {
             forceUndefined: true,
             undefinedDefaults: false,
-            bidirectionalRelations: false,
-            identifiedReferences: false,
             scalarTypeInDecorator: false,
+            bidirectionalRelations: true,
+            identifiedReferences: true,
             scalarPropertiesForRelations: 'never',
-            entityDefinition: 'decorators',
-            enumMode: 'ts-enum',
+            entityDefinition: 'defineEntity',
+            enumMode: 'dictionary',
             fileName: (className) => className,
             onlyPurePivotTables: false,
             outputPurePivotTables: false,
@@ -150,7 +150,6 @@ export class Configuration {
         }
         this.options = Utils.mergeConfig({}, Configuration.DEFAULTS, options);
         this.options.baseDir = Utils.absolutePath(this.options.baseDir);
-        this.options.preferTs ??= options.preferTs;
         if (validate) {
             this.validateOptions();
         }
@@ -348,10 +347,6 @@ export class Configuration {
     }
     sync() {
         process.env.MIKRO_ORM_COLORS = '' + this.options.colors;
-        // FIXME remove `entityGenerator.entitySchema` option
-        if (this.options.entityGenerator.entitySchema) {
-            this.options.entityGenerator.entityDefinition = 'entitySchema';
-        }
         this.logger.setDebugMode(this.options.debug);
     }
     /**

package/utils/ConfigurationLoader.d.ts

@@ -19,7 +19,12 @@ export declare class ConfigurationLoader {
     static getSettings(): Settings;
     static getConfigPaths(): string[];
     static isESM(): boolean;
-    static registerTypeScriptSupport(configPath?: string): Promise<boolean>;
+    /**
+     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
+     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * This method is used only in CLI context.
+     */
+    static registerTypeScriptSupport(configPath?: string, tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto'): Promise<boolean>;
     static registerDotenv<D extends IDatabaseDriver>(options: Options<D>): void;
     static loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
     static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
@@ -31,6 +36,7 @@ export interface Settings {
     alwaysAllowTs?: boolean;
     verbose?: boolean;
     preferTs?: boolean;
+    tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
     tsConfigPath?: string;
     configPaths?: string[];
 }

package/utils/ConfigurationLoader.js

@@ -110,6 +110,7 @@ export class ConfigurationLoader {
         const settings = { ...config['mikro-orm'] };
         const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
         settings.preferTs = process.env.MIKRO_ORM_CLI_PREFER_TS != null ? bool(process.env.MIKRO_ORM_CLI_PREFER_TS) : settings.preferTs;
+        settings.tsLoader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? settings.tsLoader;
         settings.tsConfigPath = process.env.MIKRO_ORM_CLI_TS_CONFIG_PATH ?? settings.tsConfigPath;
         settings.alwaysAllowTs = process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS != null ? bool(process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS) : settings.alwaysAllowTs;
         settings.verbose = process.env.MIKRO_ORM_CLI_VERBOSE != null ? bool(process.env.MIKRO_ORM_CLI_VERBOSE) : settings.verbose;
@@ -145,22 +146,46 @@ export class ConfigurationLoader {
         const type = config?.type ?? '';
         return type === 'module';
     }
-    static async registerTypeScriptSupport(configPath = 'tsconfig.json') {
+    /**
+     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
+     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * This method is used only in CLI context.
+     */
+    static async registerTypeScriptSupport(configPath = 'tsconfig.json', tsLoader) {
         /* v8 ignore next 3 */
         if (process.versions.bun) {
             return true;
         }
         process.env.SWC_NODE_PROJECT ??= configPath;
+        process.env.TSIMP_PROJECT ??= configPath;
         process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS ??= '1';
-        const esm = this.isESM();
-        /* v8 ignore next 2 */
-        const importMethod = esm ? 'tryImport' : 'tryRequire';
-        const module = esm ? '@swc-node/register/esm-register' : '@swc-node/register';
-        const supported = await Utils[importMethod]({
-            module,
-            warning: '@swc-node/register and @swc/core are not installed, support for working with TypeScript files might not work',
-        });
-        return !!supported;
+        const isEsm = this.isESM();
+        /* v8 ignore next */
+        const importMethod = isEsm ? 'tryImport' : 'tryRequire';
+        const explicitLoader = tsLoader ?? process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
+        const loaders = {
+            swc: { esm: '@swc-node/register/esm-register', cjs: '@swc-node/register' },
+            tsx: { esm: 'tsx/esm/api', cjs: 'tsx/cjs/api', cb: (tsx) => tsx.register({ tsconfig: configPath }) },
+            jiti: { esm: 'jiti/register', cjs: 'jiti/register', cb: () => Utils.setDynamicImportProvider(id => import(id).then(mod => mod?.default ?? mod)) },
+            tsimp: { esm: 'tsimp/import', cjs: 'tsimp/import' },
+        };
+        for (const loader of Utils.keys(loaders)) {
+            if (explicitLoader !== 'auto' && loader !== explicitLoader) {
+                continue;
+            }
+            const { esm, cjs, cb } = loaders[loader];
+            /* v8 ignore next */
+            const module = isEsm ? esm : cjs;
+            const mod = await Utils[importMethod]({ module });
+            if (mod) {
+                cb?.(mod);
+                process.env.MIKRO_ORM_CLI_TS_LOADER = loader;
+                return true;
+            }
+        }
+        // eslint-disable-next-line no-console
+        console.warn('Neither `swc`, `tsx`, `jiti` nor `tsimp` found in the project dependencies, support for working with TypeScript files might not work. To use `swc`, you need to install both `@swc-node/register` and `@swc/core`.');
+        return false;
     }
     static registerDotenv(options) {
         const path = process.env.MIKRO_ORM_ENV ?? ((options.baseDir ?? process.cwd()) + '/.env');

package/utils/RawQueryFragment.d.ts

@@ -10,8 +10,6 @@ export declare class RawQueryFragment {
     valueOf(): string;
     toJSON(): string;
     toString(): string;
-    /** @internal */
-    assign(): void;
     clone(): RawQueryFragment;
     static run<T>(cb: (...args: any[]) => Promise<T>): Promise<T>;
     /**

package/utils/RawQueryFragment.js

@@ -8,7 +8,6 @@ export class RawQueryFragment {
     static #storage = new AsyncLocalStorage();
     static #index = 0n;
     static cloneRegistry;
-    #assigned = false;
     #used = 0;
     #key;
     constructor(sql, params = []) {
@@ -17,11 +16,6 @@ export class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        // TODO: to be removed in v7
-        /* v8 ignore next 3 */
-        if (alias.startsWith('`') || alias.startsWith('"')) {
-            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
-        }
         return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
@@ -35,13 +29,6 @@ export class RawQueryFragment {
         this.#used++;
         return this.#key;
     }
-    /** @internal */
-    assign() {
-        if (this.#assigned) {
-            throw new Error(`Cannot reassign already used RawQueryFragment: '${this.sql}'`);
-        }
-        this.#assigned = true;
-    }
     clone() {
         RawQueryFragment.cloneRegistry?.add(this.#key);
         return new RawQueryFragment(this.sql, this.params);

package/utils/TransactionManager.js

@@ -1,4 +1,4 @@
-import { TransactionPropagation } from '../enums.js';
+import { ReferenceKind, TransactionPropagation } from '../enums.js';
 import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
 import { TransactionContext } from '../utils/TransactionContext.js';
 import { ChangeSetType } from '../unit-of-work/ChangeSet.js';
@@ -164,8 +164,13 @@ export class TransactionManager {
             const parentEntity = parentUoW.getById(meta.className, wrapped.getPrimaryKey(), parent['_schema'], true);
             if (parentEntity && parentEntity !== entity) {
                 const parentWrapped = helper(parentEntity);
-                parentWrapped.__data = helper(entity).__data;
-                parentWrapped.__originalEntityData = helper(entity).__originalEntityData;
+                parentWrapped.__data = wrapped.__data;
+                parentWrapped.__originalEntityData = wrapped.__originalEntityData;
+                for (const prop of meta.hydrateProps) {
+                    if (prop.kind === ReferenceKind.SCALAR) {
+                        parentEntity[prop.name] = entity[prop.name];
+                    }
+                }
             }
             else {
                 parentUoW.merge(entity, new Set([entity]));

package/utils/Utils.d.ts

@@ -252,13 +252,13 @@ export declare class Utils {
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
     static tryRequire<T extends Dictionary = any>({ module, from, allowError, warning }: {
         module: string;
-        warning: string;
+        warning?: string;
         from?: string;
         allowError?: string;
     }): T | undefined;
     static tryImport<T extends Dictionary = any>({ module, warning }: {
         module: string;
-        warning: string;
+        warning?: string;
     }): Promise<T | undefined>;
     static stripRelativePath(str: string): string;
     static xor(a: boolean, b: boolean): boolean;

package/utils/Utils.js

@@ -1075,8 +1075,10 @@ export class Utils {
         }
         catch (err) {
             if (err.message.includes(allowError)) {
-                // eslint-disable-next-line no-console
-                console.warn(warning);
+                if (warning) {
+                    // eslint-disable-next-line no-console
+                    console.warn(warning);
+                }
                 return undefined;
             }
             throw err;
@@ -1088,8 +1090,10 @@ export class Utils {
         }
         catch (err) {
             if (err.code === 'ERR_MODULE_NOT_FOUND') {
-                // eslint-disable-next-line no-console
-                console.warn(warning);
+                if (warning) {
+                    // eslint-disable-next-line no-console
+                    console.warn(warning);
+                }
                 return undefined;
             }
             throw err;