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

package/typings.js

@@ -45,12 +45,29 @@ export class EntityMetadata {
             this.sync();
         }
     }
-    getPrimaryProps() {
-        return this.primaryKeys.map(pk => this.properties[pk]);
+    getPrimaryProps(flatten = false) {
+        const pks = this.primaryKeys.map(pk => this.properties[pk]);
+        if (flatten) {
+            return pks.flatMap(pk => {
+                if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(pk.kind)) {
+                    return pk.targetMeta.getPrimaryProps(true);
+                }
+                return [pk];
+            });
+        }
+        return pks;
     }
     getPrimaryProp() {
         return this.properties[this.primaryKeys[0]];
     }
+    createColumnMappingObject() {
+        return Object.values(this.properties).reduce((o, prop) => {
+            if (prop.fieldNames) {
+                o[prop.name] = prop.fieldNames[0];
+            }
+            return o;
+        }, {});
+    }
     get tableName() {
         return this.collection;
     }
@@ -70,7 +87,7 @@ export class EntityMetadata {
             // `prop.userDefined` is either `undefined` or `false`
             const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;
             // even if we don't have a setter, do not ignore value from database!
-            const onlyGetter = prop.getter && !prop.setter;
+            const onlyGetter = prop.getter && !prop.setter && prop.persist === false;
             return !prop.inherited && prop.hydrate !== false && !discriminator && !prop.embedded && !onlyGetter;
         });
         this.trackingProps = this.hydrateProps
@@ -129,7 +146,7 @@ export class EntityMetadata {
                         wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                         // when propagation from inside hydration, we set the FK to the entity data immediately
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                            wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
+                            wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
                         }
                         else {
                             wrapped.__touched = !hydrator.isRunning();

package/unit-of-work/ChangeSetComputer.js

@@ -141,7 +141,9 @@ export class ChangeSetComputer {
         if (!target.isDirty() && changeSet.type !== ChangeSetType.CREATE) {
             return;
         }
-        this.collectionUpdates.add(target);
+        if (target.isDirty()) {
+            this.collectionUpdates.add(target);
+        }
         if (prop.owner && !this.platform.usesPivotTable()) {
             changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
         }

package/unit-of-work/ChangeSetPersister.d.ts

@@ -5,6 +5,7 @@ import { type EntityValidator } from '../entity/EntityValidator.js';
 import { type ChangeSet } from './ChangeSet.js';
 import { type Configuration } from '../utils/Configuration.js';
 import type { DriverMethodOptions, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetPersister {
     private readonly driver;
     private readonly metadata;
@@ -12,10 +13,11 @@ export declare class ChangeSetPersister {
     private readonly factory;
     private readonly validator;
     private readonly config;
+    private readonly em;
     private readonly platform;
     private readonly comparator;
     private readonly usesReturningStatement;
-    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration);
+    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration, em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
@@ -23,7 +25,7 @@ export declare class ChangeSetPersister {
     private processProperties;
     private persistNewEntity;
     private persistNewEntities;
-    private propagateSchemaFromMetadata;
+    private prepareOptions;
     private persistNewEntitiesBatch;
     private persistManagedEntity;
     private persistManagedEntities;

package/unit-of-work/ChangeSetPersister.js

@@ -12,16 +12,18 @@ export class ChangeSetPersister {
     factory;
     validator;
     config;
+    em;
     platform;
     comparator;
     usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, validator, config) {
+    constructor(driver, metadata, hydrator, factory, validator, config, em) {
         this.driver = driver;
         this.metadata = metadata;
         this.hydrator = hydrator;
         this.factory = factory;
         this.validator = validator;
         this.config = config;
+        this.em = em;
         this.platform = this.driver.getPlatform();
         this.comparator = this.config.getComparator(this.metadata);
         this.usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
@@ -62,7 +64,7 @@ export class ChangeSetPersister {
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
-            options = this.propagateSchemaFromMetadata(meta, options);
+            options = this.prepareOptions(meta, options);
             await this.driver.nativeDelete(meta.root.className, { [pk]: { $in: pks } }, options);
         }
     }
@@ -90,7 +92,7 @@ export class ChangeSetPersister {
     }
     async persistNewEntity(meta, changeSet, options) {
         const wrapped = helper(changeSet.entity);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
@@ -116,15 +118,17 @@ export class ChangeSetPersister {
             }
         }
     }
-    propagateSchemaFromMetadata(meta, options, additionalOptions) {
+    prepareOptions(meta, options, additionalOptions) {
+        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
         return {
             ...options,
             ...additionalOptions,
             schema: options?.schema ?? meta.schema,
+            loggerContext,
         };
     }
     async persistNewEntitiesBatch(meta, changeSets, options) {
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -175,7 +179,7 @@ export class ChangeSetPersister {
     }
     async persistManagedEntitiesBatch(meta, changeSets, options) {
         await this.checkOptimisticLocks(meta, changeSets, options);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -235,7 +239,7 @@ export class ChangeSetPersister {
     }
     async updateEntity(meta, changeSet, options) {
         const cond = changeSet.getPrimaryKey(true);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
@@ -262,7 +266,7 @@ export class ChangeSetPersister {
             return cond;
         });
         const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
         const res = await this.driver.find(meta.root.className, { $or }, options);
@@ -321,12 +325,12 @@ export class ChangeSetPersister {
             }
             return val;
         });
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
         const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);

package/unit-of-work/UnitOfWork.d.ts

@@ -39,7 +39,7 @@ export declare class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string): T | undefined;
+    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
     tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.
@@ -103,6 +103,7 @@ export declare class UnitOfWork {
     private commitDeleteChangeSets;
     private commitExtraUpdates;
     private commitCollectionUpdates;
+    private filterCollectionUpdates;
     /**
      * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
      */

package/unit-of-work/UnitOfWork.js

@@ -43,7 +43,7 @@ export class UnitOfWork {
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
         this.changeSetComputer = new ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config);
+        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config, this.em);
     }
     merge(entity, visited) {
         const wrapped = helper(entity);
@@ -89,7 +89,7 @@ export class UnitOfWork {
                 }
                 wrapped.__loadedProperties.add(key);
                 if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
                     for (const p of prop.targetMeta.props) {
@@ -97,7 +97,7 @@ export class UnitOfWork {
                         const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
                         data[prefix + p.name] = data[prop.name][p.name];
                     }
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 if (forceUndefined) {
                     if (data[key] === null) {
@@ -125,7 +125,7 @@ export class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById(entityName, id, schema) {
+    getById(entityName, id, schema, convertCustomTypes) {
         if (id == null || (Array.isArray(id) && id.length === 0)) {
             return undefined;
         }
@@ -135,7 +135,16 @@ export class UnitOfWork {
             hash = '' + id;
         }
         else {
-            const keys = Array.isArray(id) ? Utils.flatten(id) : [id];
+            let keys = Array.isArray(id) ? Utils.flatten(id) : [id];
+            keys = meta.getPrimaryProps(true).map((p, i) => {
+                if (!convertCustomTypes && p.customType) {
+                    return p.customType.convertToDatabaseValue(keys[i], this.platform, {
+                        key: p.name,
+                        mode: 'hydration',
+                    });
+                }
+                return keys[i];
+            });
             hash = Utils.getPrimaryKeyHash(keys);
         }
         schema ??= meta.schema ?? this.em.config.getSchema();
@@ -303,6 +312,7 @@ export class UnitOfWork {
                 cs.entity.__helper.__processing = true;
             }
             await this.eventManager.dispatchEvent(EventType.onFlush, { em: this.em, uow: this });
+            this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
                 return void (await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this }));
@@ -311,9 +321,11 @@ export class UnitOfWork {
             const platform = this.em.getPlatform();
             const runInTransaction = !this.em.isInTransaction() && platform.supportsTransactions() && this.em.config.get('implicitTransactions');
             if (runInTransaction) {
+                const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
                 await this.em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
                     ctx: oldTx,
                     eventBroadcaster: new TransactionEventBroadcaster(this.em),
+                    loggerContext,
                 });
             }
             else {
@@ -886,23 +898,34 @@ export class UnitOfWork {
         }
     }
     async commitCollectionUpdates(ctx) {
-        const collectionUpdates = [];
+        this.filterCollectionUpdates();
+        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
+        await this.em.getDriver().syncCollections(this.collectionUpdates, {
+            ctx,
+            schema: this.em.schema,
+            loggerContext,
+        });
+        for (const coll of this.collectionUpdates) {
+            coll.takeSnapshot();
+        }
+    }
+    filterCollectionUpdates() {
         for (const coll of this.collectionUpdates) {
+            let skip = true;
             if (coll.property.owner || coll.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
                 if (this.platform.usesPivotTable()) {
-                    collectionUpdates.push(coll);
+                    skip = false;
                 }
             }
             else if (coll.property.kind === ReferenceKind.ONE_TO_MANY && coll.getSnapshot() === undefined) {
-                collectionUpdates.push(coll);
+                skip = false;
             }
             else if (coll.property.kind === ReferenceKind.MANY_TO_MANY && !coll.property.owner) {
-                collectionUpdates.push(coll);
+                skip = false;
+            }
+            if (skip) {
+                this.collectionUpdates.delete(coll);
             }
-        }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx, schema: this.em.schema });
-        for (const coll of this.collectionUpdates) {
-            coll.takeSnapshot();
         }
     }
     /**

package/utils/Configuration.d.ts

@@ -78,6 +78,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         upsertManaged: true;
         forceEntityConstructor: false;
         forceUndefined: false;
+        processOnCreateHooksEarly: false;
         ensureDatabase: true;
         ensureIndexes: false;
         batchSize: number;
@@ -332,6 +333,11 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     upsertManaged: boolean;
     forceEntityConstructor: boolean | (Constructor<AnyEntity> | string)[];
     forceUndefined: boolean;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly: boolean;
     forceUtcTimezone?: boolean;
     timezone?: string;
     ensureDatabase: boolean | EnsureDatabaseOptions;
@@ -340,7 +346,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     useBatchUpdates?: boolean;
     batchSize: number;
     hydrator: HydratorConstructor;
-    loadStrategy: LoadStrategy | 'select-in' | 'joined';
+    loadStrategy: LoadStrategy | `${LoadStrategy}`;
     dataloader: DataloaderType | boolean;
     populateWhere?: PopulateHint | `${PopulateHint}`;
     flushMode: FlushMode | 'commit' | 'auto' | 'always';

package/utils/Configuration.js

@@ -68,6 +68,7 @@ export class Configuration {
         upsertManaged: true,
         forceEntityConstructor: false,
         forceUndefined: false,
+        processOnCreateHooksEarly: false,
         ensureDatabase: true,
         ensureIndexes: false,
         batchSize: 300,

package/utils/ConfigurationLoader.js

@@ -192,7 +192,7 @@ export class ConfigurationLoader {
     static registerDotenv(options) {
         const path = process.env.MIKRO_ORM_ENV ?? ((options?.baseDir ?? process.cwd()) + '/.env');
         const env = {};
-        dotenv.config({ path, processEnv: env });
+        dotenv.config({ path, processEnv: env, quiet: true });
         // only propagate known env vars
         for (const key of Object.keys(env)) {
             if (key.startsWith('MIKRO_ORM_')) {
@@ -332,7 +332,7 @@ export class ConfigurationLoader {
     // inspired by https://github.com/facebook/docusaurus/pull/3386
     static checkPackageVersion() {
         const coreVersion = Utils.getORMVersion();
-        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH) {
+        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === 'N/A') {
             return coreVersion;
         }
         const deps = this.getORMPackages();

package/utils/Cursor.js

@@ -107,6 +107,9 @@ export class Cursor {
             if (Utils.isEntity(value, true)) {
                 value = helper(value).getPrimaryKey();
             }
+            if (Utils.isScalarReference(value)) {
+                value = value.unwrap();
+            }
             if (object) {
                 return ({ [prop]: value });
             }

package/utils/DataloaderUtils.d.ts

@@ -34,8 +34,13 @@ export declare class DataloaderUtils {
      */
     static getColFilter<T, S extends T>(collection: Collection<any>): (result: T) => result is S;
     /**
-     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    /**
+     * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponding result.
+     */
+    static getManyToManyColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
 }

package/utils/DataloaderUtils.js

@@ -1,6 +1,5 @@
 import { Collection } from '../entity/Collection.js';
 import { helper } from '../entity/wrap.js';
-import { ReferenceKind } from '../enums.js';
 import { Reference } from '../entity/Reference.js';
 import { Utils } from './Utils.js';
 export class DataloaderUtils {
@@ -153,29 +152,11 @@ export class DataloaderUtils {
         };
     }
     /**
-     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getColBatchLoadFn(em) {
         return async (collsWithOpts) => {
-            const prop = collsWithOpts[0][0].property;
-            if (prop.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
-                const options = {};
-                const wrap = (cond) => ({ [prop.name]: cond });
-                const orderBy = Utils.asArray(collsWithOpts[0][1]?.orderBy).map(o => wrap(o));
-                const populate = wrap(collsWithOpts[0][1]?.populate);
-                const owners = collsWithOpts.map(c => c[0].owner);
-                const $or = [];
-                // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
-                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
-                const fk = `${alias}.${Utils.getPrimaryKeyHash(prop.joinColumns)}`;
-                for (const c of collsWithOpts) {
-                    $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
-                    options.refresh ??= c[1]?.refresh;
-                }
-                options.where = wrap({ $or });
-                return em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, collsWithOpts[0][1]?.ref);
-            }
             const entitiesAndOptsMap = DataloaderUtils.groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts);
             const promises = DataloaderUtils.entitiesAndOptsMapToQueries(entitiesAndOptsMap, em);
             const resultsMap = new Map(await Promise.all(promises));
@@ -193,4 +174,40 @@ export class DataloaderUtils {
             });
         };
     }
+    /**
+     * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponding result.
+     */
+    static getManyToManyColBatchLoadFn(em) {
+        return async (collsWithOpts) => {
+            const groups = new Map();
+            for (const [col, opts] of collsWithOpts) {
+                const key = `${col.property.targetMeta.className}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const value = groups.get(key) ?? [];
+                value.push([col, opts ?? {}]);
+                groups.set(key, value);
+            }
+            const ret = [];
+            for (const group of groups.values()) {
+                const prop = group[0][0].property;
+                const options = {};
+                const wrap = (cond) => ({ [prop.name]: cond });
+                const orderBy = Utils.asArray(group[0][1]?.orderBy).map(o => wrap(o));
+                const populate = wrap(group[0][1]?.populate);
+                const owners = group.map(c => c[0].owner);
+                const $or = [];
+                // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
+                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
+                const fk = `${alias}.${Utils.getPrimaryKeyHash(prop.joinColumns)}`;
+                for (const c of group) {
+                    $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
+                    options.refresh ??= c[1]?.refresh;
+                }
+                options.where = wrap({ $or });
+                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                ret.push(...r);
+            }
+            return ret;
+        };
+    }
 }

package/utils/EntityComparator.d.ts

@@ -1,6 +1,8 @@
 import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
-type Comparator<T> = (a: T, b: T) => EntityData<T>;
+type Comparator<T> = (a: T, b: T, options?: {
+    includeInverseSides?: boolean;
+}) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
 type CompositeKeyPart = string | CompositeKeyPart[];
@@ -18,7 +20,9 @@ export declare class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): EntityData<T>;
+    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>, options?: {
+        includeInverseSides?: boolean;
+    }): EntityData<T>;
     matching<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): boolean;
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.

package/utils/EntityComparator.js

@@ -20,9 +20,9 @@ export class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities(entityName, a, b) {
+    diffEntities(entityName, a, b, options) {
         const comparator = this.getEntityComparator(entityName);
-        return Utils.callCompiledFunction(comparator, a, b);
+        return Utils.callCompiledFunction(comparator, a, b, options);
     }
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);
@@ -155,6 +155,7 @@ export class EntityComparator {
         const lines = [];
         const context = new Map();
         context.set('getCompositeKeyValue', (val) => Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.platform)));
+        context.set('getPrimaryKeyHash', (val) => Utils.getPrimaryKeyHash(Utils.asArray(val)));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const pks = entity.__helper.__pk ? getCompositeKeyValue(entity.__helper.__pk) : [`);
             meta.primaryKeys.forEach(pk => {
@@ -170,14 +171,23 @@ export class EntityComparator {
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
+            const prop = meta.properties[pk];
+            if (prop.kind !== ReferenceKind.SCALAR) {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey();`);
             }
             const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
             if (serializedPrimaryKey) {
                 lines.push(`  return '' + entity.${serializedPrimaryKey.name};`);
             }
-            lines.push(`  return '' + entity.${meta.primaryKeys[0]};`);
+            else if (prop.customType) {
+                const convertorKey = this.registerCustomType(meta.properties[pk], context);
+                const idx = this.tmpIndex++;
+                lines.push(`  const val_${idx} = convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)});`);
+                lines.push(`  return getPrimaryKeyHash(val_${idx});`);
+            }
+            else {
+                lines.push(`  return '' + entity${this.wrap(pk)};`);
+            }
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
@@ -531,11 +541,22 @@ export class EntityComparator {
         context.set('compareBuffers', compareBuffers);
         context.set('compareObjects', compareObjects);
         context.set('equals', equals);
-        meta.comparableProps.forEach(prop => {
-            lines.push(this.getPropertyComparator(prop, context));
-        });
+        for (const prop of meta.comparableProps) {
+            // skip properties that are not hydrated
+            if (prop.hydrate !== false) {
+                lines.push(this.getPropertyComparator(prop, context));
+            }
+        }
+        // also compare 1:1 inverse sides, important for `factory.mergeData`
+        lines.push(`if (options?.includeInverseSides) {`);
+        for (const prop of meta.bidirectionalRelations) {
+            if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && prop.hydrate !== false) {
+                lines.push(this.getPropertyComparator(prop, context));
+            }
+        }
+        lines.push(`}`);
         const code = `// compiled comparator for entity ${meta.className}\n`
-            + `return function(last, current) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
+            + `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
         const comparator = Utils.createFunction(context, code);
         this.comparators.set(entityName, comparator);
         return comparator;

package/utils/QueryHelper.d.ts

@@ -1,10 +1,16 @@
 import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+/** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
     static processParams(params: unknown): any;
     static processObjectParams<T extends object>(params?: T): T;
+    /**
+     * converts `{ account: { $or: [ [Object], [Object] ] } }`
+     * to `{ $or: [ { account: [Object] }, { account: [Object] } ] }`
+     */
+    static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     static getActiveFilters(entityName: string, options: Dictionary<boolean | Dictionary> | string[] | boolean, filters: Dictionary<FilterDef>): FilterDef[];