@mikro-orm/core 7.0.0-dev.32 → 7.0.0-dev.321

package/utils/EntityComparator.d.ts

@@ -1,5 +1,6 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
+import type { Configuration } from './Configuration.js';
 type Comparator<T> = (a: T, b: T, options?: {
     includeInverseSides?: boolean;
 }) => EntityData<T>;
@@ -9,6 +10,7 @@ type CompositeKeyPart = string | CompositeKeyPart[];
 export declare class EntityComparator {
     private readonly metadata;
     private readonly platform;
+    private readonly config?;
     private readonly comparators;
     private readonly mappers;
     private readonly snapshotGenerators;
@@ -16,23 +18,23 @@ export declare class EntityComparator {
     private readonly pkGettersConverted;
     private readonly pkSerializers;
     private tmpIndex;
-    constructor(metadata: IMetadataStorage, platform: Platform);
+    constructor(metadata: IMetadataStorage, platform: Platform, config?: Configuration | undefined);
     /**
      * Computes difference between two entities.
      */
-    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>, options?: {
+    diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
         includeInverseSides?: boolean;
     }): EntityData<T>;
-    matching<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): boolean;
+    matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
      * References will be mapped to primary keys, collections to arrays of primary keys.
      */
-    prepareEntity<T>(entity: T): EntityData<T>;
+    prepareEntity<T extends object>(entity: T): EntityData<T>;
     /**
      * Maps database columns to properties.
      */
-    mapResult<T>(entityName: string, result: EntityDictionary<T>): EntityData<T>;
+    mapResult<T>(meta: EntityMetadata<T>, result: EntityDictionary<T>): EntityData<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
@@ -48,7 +50,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getSnapshotGenerator<T>(entityName: string): SnapshotGenerator<T>;
+    getSnapshotGenerator<T>(entityName: EntityName<T>): SnapshotGenerator<T>;
     /**
      * @internal
      */
@@ -64,7 +66,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getResultMapper<T>(entityName: string): ResultMapper<T>;
+    getResultMapper<T>(meta: EntityMetadata<T>): ResultMapper<T>;
     private getPropertyCondition;
     private getEmbeddedArrayPropertySnapshot;
     /**
@@ -78,11 +80,16 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityComparator<T extends object>(entityName: string): Comparator<T>;
+    getEntityComparator<T extends object>(entityName: EntityName<T>): Comparator<T>;
     private getGenericComparator;
     private getPropertyComparator;
     private wrap;
     private safeKey;
+    /**
+     * Sets the toArray helper in the context if not already set.
+     * Used for converting composite PKs to arrays.
+     */
+    private setToArrayHelper;
     /**
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */

package/utils/EntityComparator.js

@@ -1,11 +1,14 @@
 import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
-import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
+import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils, } from './Utils.js';
 import { JsonType } from '../types/JsonType.js';
-import { RawQueryFragment } from './RawQueryFragment.js';
+import { Raw } from './RawQueryFragment.js';
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 export class EntityComparator {
     metadata;
     platform;
+    config;
     comparators = new Map();
     mappers = new Map();
     snapshotGenerators = new Map();
@@ -13,9 +16,10 @@ export class EntityComparator {
     pkGettersConverted = new Map();
     pkSerializers = new Map();
     tmpIndex = 0;
-    constructor(metadata, platform) {
+    constructor(metadata, platform, config) {
         this.metadata = metadata;
         this.platform = platform;
+        this.config = config;
     }
     /**
      * Computes difference between two entities.
@@ -33,22 +37,22 @@ export class EntityComparator {
      * References will be mapped to primary keys, collections to arrays of primary keys.
      */
     prepareEntity(entity) {
-        const generator = this.getSnapshotGenerator(entity.constructor.name);
+        const generator = this.getSnapshotGenerator(entity.constructor);
         return Utils.callCompiledFunction(generator, entity);
     }
     /**
      * Maps database columns to properties.
      */
-    mapResult(entityName, result) {
-        const mapper = this.getResultMapper(entityName);
+    mapResult(meta, result) {
+        const mapper = this.getResultMapper(meta);
         return Utils.callCompiledFunction(mapper, result);
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
-        const exists = this.pkGetters.get(meta.className);
-        /* v8 ignore next 3 */
+        const exists = this.pkGetters.get(meta);
+        /* v8 ignore next */
         if (exists) {
             return exists;
         }
@@ -87,18 +91,18 @@ export class EntityComparator {
             }
             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}`;
-        const pkSerializer = Utils.createFunction(context, code);
-        this.pkGetters.set(meta.className, pkSerializer);
+        const code = `// compiled pk getter for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
+        const fnKey = `pkGetter-${meta.uniqueName}`;
+        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.pkGetters.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetterConverted(meta) {
-        const exists = this.pkGettersConverted.get(meta.className);
-        /* v8 ignore next 3 */
+        const exists = this.pkGettersConverted.get(meta);
+        /* v8 ignore next */
         if (exists) {
             return exists;
         }
@@ -137,18 +141,19 @@ export class EntityComparator {
                 lines.push(`  return entity${this.wrap(pk)};`);
             }
         }
-        const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils.createFunction(context, code);
-        this.pkGettersConverted.set(meta.className, pkSerializer);
+        const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n` +
+            `return function(entity) {\n${lines.join('\n')}\n}`;
+        const fnKey = `pkGetterConverted-${meta.uniqueName}`;
+        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkSerializer(meta) {
-        const exists = this.pkSerializers.get(meta.className);
-        /* v8 ignore next 3 */
+        const exists = this.pkSerializers.get(meta);
+        /* v8 ignore next */
         if (exists) {
             return exists;
         }
@@ -189,26 +194,26 @@ export class EntityComparator {
                 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}`;
-        const pkSerializer = Utils.createFunction(context, code);
-        this.pkSerializers.set(meta.className, pkSerializer);
+        const code = `// compiled pk serializer for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
+        const fnKey = `pkSerializer-${meta.uniqueName}`;
+        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator(entityName) {
-        const exists = this.snapshotGenerators.get(entityName);
+        const meta = this.metadata.find(entityName);
+        const exists = this.snapshotGenerators.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
         context.set('clone', clone);
         context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
-        if (meta.discriminatorValue) {
+        if (meta.root.inheritanceType === 'sti' && meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
@@ -220,8 +225,9 @@ export class EntityComparator {
         })
             .forEach(prop => lines.push(this.getPropertySnapshot(meta, prop, context, this.wrap(prop.name), this.wrap(prop.name), [prop.name])));
         const code = `return function(entity) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const snapshotGenerator = Utils.createFunction(context, code);
-        this.snapshotGenerators.set(entityName, snapshotGenerator);
+        const fnKey = `snapshotGenerator-${meta.uniqueName}`;
+        const snapshotGenerator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
     }
     /**
@@ -265,29 +271,33 @@ export class EntityComparator {
         if (part.length === 1) {
             return this.formatCompositeKeyPart(part[0]);
         }
-        const formatted = part.map(this.formatCompositeKeyPart).join(', ');
+        const formatted = part.map(p => this.formatCompositeKeyPart(p)).join(', ');
         return `[${formatted}]`;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
-    getResultMapper(entityName) {
-        const exists = this.mappers.get(entityName);
+    getResultMapper(meta) {
+        const exists = this.mappers.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.get(entityName);
         const lines = [];
         const context = new Map();
+        context.set('PolymorphicRef', PolymorphicRef);
         const tz = this.platform.getTimezone();
         const parseDate = (key, value, padding = '') => {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
             lines.push(`${padding}      ${key} = ${value};`);
             if (!tz || tz === 'local') {
+                lines.push(`${padding}    } else if (typeof ${value} === 'bigint') {`);
+                lines.push(`${padding}      ${key} = parseDate(Number(${value}));`);
                 lines.push(`${padding}    } else {`);
                 lines.push(`${padding}      ${key} = parseDate(${value});`);
             }
             else {
+                lines.push(`${padding}    } else if (typeof ${value} === 'bigint') {`);
+                lines.push(`${padding}      ${key} = parseDate(Number(${value}));`);
                 lines.push(`${padding}    } else if (typeof ${value} === 'number' || ${value}.includes('+') || ${value}.lastIndexOf('-') > 10 || ${value}.endsWith('Z')) {`);
                 lines.push(`${padding}      ${key} = parseDate(${value});`);
                 lines.push(`${padding}    } else {`);
@@ -301,12 +311,28 @@ export class EntityComparator {
                 if (!prop.fieldNames) {
                     continue;
                 }
+                if (prop.polymorphic && prop.fieldNames.length >= 2) {
+                    const discriminatorField = prop.fieldNames[0];
+                    const idFields = prop.fieldNames.slice(1);
+                    lines.push(`${padding}  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
+                    if (idFields.length === 1) {
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = new PolymorphicRef(${this.propName(discriminatorField)}, ${this.propName(idFields[0])});`);
+                    }
+                    else {
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = new PolymorphicRef(${this.propName(discriminatorField)}, [${idFields.map(f => this.propName(f)).join(', ')}]);`);
+                    }
+                    lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`));
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n${padding}    ret${this.wrap(prop.name)} = null;`);
+                    lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
+                    continue;
+                }
                 if (prop.targetMeta && prop.fieldNames.length > 1) {
                     lines.push(`${padding}  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
                     lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.createCompositeKeyArray(prop)};`);
                     lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`));
-                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n    ret${this.wrap(prop.name)} = null;`);
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n${padding}    ret${this.wrap(prop.name)} = null;`);
                     lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
                     continue;
                 }
@@ -331,9 +357,9 @@ export class EntityComparator {
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
                         const item = parseJsonSafe(data);
                         if (Array.isArray(item)) {
-                            return item.map(row => row == null ? row : this.getResultMapper(prop.type)(row));
+                            return item.map(row => (row == null ? row : this.getResultMapper(prop.targetMeta)(row)));
                         }
-                        return item == null ? item : this.getResultMapper(prop.type)(item);
+                        return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
                     lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${this.propName(prop.fieldNames[0])});`);
@@ -363,10 +389,11 @@ export class EntityComparator {
             mapEntityProperties(meta);
         }
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined) ret[k] = result[k]; }`);
-        const code = `// compiled mapper for entity ${meta.className}\n`
-            + `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const resultMapper = Utils.createFunction(context, code);
-        this.mappers.set(entityName, resultMapper);
+        const code = `// compiled mapper for entity ${meta.className}\n` +
+            `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
+        const fnKey = `resultMapper-${meta.uniqueName}`;
+        const resultMapper = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.mappers.set(meta, resultMapper);
         return resultMapper;
     }
     getPropertyCondition(path) {
@@ -377,12 +404,12 @@ export class EntityComparator {
         let tail = '';
         return parts
             .map(k => {
-            if (k.match(/^\[idx_\d+]$/)) {
+            if (/^\[idx_\d+]$/.exec(k)) {
                 tail += k;
                 return '';
             }
             const mapped = `typeof entity${tail ? '.' + tail : ''}${this.wrap(k)} !== 'undefined'`;
-            tail += tail ? ('.' + k) : k;
+            tail += tail ? '.' + k : k;
             return mapped;
         })
             .filter(k => k)
@@ -417,11 +444,25 @@ export class EntityComparator {
     }
     getEmbeddedPropertySnapshot(meta, prop, context, level, path, dataKey, object = prop.object) {
         const padding = ' '.repeat(level * 2);
-        let ret = `${level === 1 ? '' : '\n'}`;
+        const nullCond = `entity${path.map(k => this.wrap(k)).join('')} === null`;
+        let ret = level === 1 ? '' : '\n';
         if (object) {
-            const nullCond = `entity${path.map(k => this.wrap(k)).join('')} === null`;
             ret += `${padding}if (${nullCond}) ret${dataKey} = null;\n`;
         }
+        else {
+            ret += `${padding}if (${nullCond}) {\n`;
+            ret +=
+                meta.props
+                    .filter(p => p.embedded?.[0] === prop.name &&
+                    // object for JSON embeddable
+                    (p.object || p.persist !== false))
+                    .map(childProp => {
+                    const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    return `${padding}  ret${childDataKey} = null;`;
+                })
+                    .join('\n') + `\n`;
+            ret += `${padding}}\n`;
+        }
         const cond = `entity${path.map(k => this.wrap(k)).join('')} != null`;
         ret += `${padding}if (${cond}) {\n`;
         if (object) {
@@ -436,28 +477,34 @@ export class EntityComparator {
             }
             return true;
         }
-        ret += meta.props.filter(p => p.embedded?.[0] === prop.name
-            // object for JSON embeddable
-            && (p.object || (p.persist !== false))).map(childProp => {
-            const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-            const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
-            const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
-            if (childProp.kind === ReferenceKind.EMBEDDED) {
-                return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
-            }
-            if (childProp.kind !== ReferenceKind.SCALAR) {
-                return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
-                    .split('\n').map(l => padding + l).join('\n');
-            }
-            if (shouldProcessCustomType(childProp)) {
-                const convertorKey = this.registerCustomType(childProp, context);
-                if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
-                    return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
+        ret +=
+            meta.props
+                .filter(p => p.embedded?.[0] === prop.name &&
+                // object for JSON embeddable
+                (p.object || p.persist !== false))
+                .map(childProp => {
+                const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
+                const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
+                if (childProp.kind === ReferenceKind.EMBEDDED) {
+                    return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
                 }
-                return `${padding}  if (${childCond}) ret${childDataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${childEntityKey}));`;
-            }
-            return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
-        }).join('\n') + `\n`;
+                if (childProp.kind !== ReferenceKind.SCALAR) {
+                    return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
+                        .split('\n')
+                        .map(l => padding + l)
+                        .join('\n');
+                }
+                if (shouldProcessCustomType(childProp)) {
+                    const convertorKey = this.registerCustomType(childProp, context);
+                    if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
+                        return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
+                    }
+                    return `${padding}  if (${childCond}) ret${childDataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${childEntityKey}));`;
+                }
+                return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
+            })
+                .join('\n') + `\n`;
         if (this.shouldSerialize(prop, dataKey)) {
             return `${ret + padding}  ret${dataKey} = cloneEmbeddable(ret${dataKey});\n${padding}}`;
         }
@@ -466,8 +513,8 @@ export class EntityComparator {
     registerCustomType(prop, context) {
         const convertorKey = this.safeKey(prop.name);
         context.set(`convertToDatabaseValue_${convertorKey}`, (val) => {
-            /* v8 ignore next 3 */
-            if (RawQueryFragment.isKnownFragment(val)) {
+            /* v8 ignore next */
+            if (Raw.isKnownFragment(val)) {
                 return val;
             }
             return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
@@ -496,16 +543,51 @@ export class EntityComparator {
                     ret += `    ret${dataKey} = entity${entityKey};\n`;
                 }
             }
+            else if (prop.polymorphic) {
+                const discriminatorMapKey = `discriminatorMapReverse_${prop.name}`;
+                const reverseMap = new Map();
+                for (const [key, value] of Object.entries(prop.discriminatorMap)) {
+                    reverseMap.set(value, key);
+                }
+                context.set(discriminatorMapKey, reverseMap);
+                this.setToArrayHelper(context);
+                context.set('EntityIdentifier', EntityIdentifier);
+                context.set('PolymorphicRef', PolymorphicRef);
+                ret += `    if (entity${entityKey} === null) {\n`;
+                ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
+                ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
+                ret += `      const discriminator = ${discriminatorMapKey}.get(val${level}?.constructor);\n`;
+                ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
+                ret += `        ? val${level}.__helper.__identifier\n`;
+                ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;
+                ret += `      ret${dataKey} = new PolymorphicRef(discriminator, pk);\n`;
+                ret += `    }\n`;
+            }
+            else if (prop.targetKey) {
+                // When targetKey is set, extract that property value instead of the PK
+                const targetProp = prop.targetMeta?.properties[prop.targetKey];
+                ret += `    if (entity${entityKey} === null) {\n`;
+                ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
+                ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
+                if (targetProp?.customType) {
+                    // If targetKey property has a custom type, convert to database value
+                    const convertorKey = this.registerCustomType(targetProp, context);
+                    ret += `      ret${dataKey} = convertToDatabaseValue_${convertorKey}(val${level}?.${prop.targetKey});\n`;
+                }
+                else {
+                    ret += `      ret${dataKey} = val${level}?.${prop.targetKey};\n`;
+                }
+                ret += `    }\n`;
+            }
             else {
-                const toArray = (val) => {
-                    if (Utils.isPlainObject(val)) {
-                        return Object.values(val).map(v => toArray(v));
-                    }
-                    return val;
-                };
-                context.set('toArray', toArray);
+                this.setToArrayHelper(context);
+                context.set('EntityIdentifier', EntityIdentifier);
                 ret += `    if (entity${entityKey} === null) {\n`;
                 ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (entity${entityKey}?.__helper.__identifier && !entity${entityKey}.__helper.hasPrimaryKey()) {\n`;
+                ret += `      ret${dataKey} = entity${entityKey}?.__helper.__identifier;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      ret${dataKey} = toArray(entity${entityKey}.__helper.getPrimaryKey(true));\n`;
                 ret += `    }\n`;
@@ -517,7 +599,7 @@ export class EntityComparator {
             if (['number', 'string', 'boolean', 'bigint'].includes(prop.customType.compareAsType().toLowerCase())) {
                 return ret + `    ret${dataKey} = convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap});\n  }\n`;
             }
-            return ret + `    ret${dataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap}));\n  }\n`;
+            return (ret + `    ret${dataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap}));\n  }\n`);
         }
         if (prop.runtimeType === 'Date') {
             context.set('processDateProperty', this.platform.processDateProperty.bind(this.platform));
@@ -529,11 +611,11 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getEntityComparator(entityName) {
-        const exists = this.comparators.get(entityName);
+        const meta = this.metadata.find(entityName);
+        const exists = this.comparators.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
         context.set('compareArrays', compareArrays);
@@ -542,10 +624,7 @@ export class EntityComparator {
         context.set('compareObjects', compareObjects);
         context.set('equals', equals);
         for (const prop of meta.comparableProps) {
-            // skip properties that are not hydrated
-            if (prop.hydrate !== false) {
-                lines.push(this.getPropertyComparator(prop, context));
-            }
+            lines.push(this.getPropertyComparator(prop, context));
         }
         // also compare 1:1 inverse sides, important for `factory.mergeData`
         lines.push(`if (options?.includeInverseSides) {`);
@@ -555,37 +634,48 @@ export class EntityComparator {
             }
         }
         lines.push(`}`);
-        const code = `// compiled comparator for entity ${meta.className}\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);
+        const code = `// compiled comparator for entity ${meta.className}\n` +
+            `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
+        const fnKey = `comparator-${meta.uniqueName}`;
+        const comparator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.comparators.set(meta, comparator);
         return comparator;
     }
     getGenericComparator(prop, cond) {
-        return `  if (current${prop} === null && last${prop} === undefined) {\n` +
+        return (`  if (current${prop} === null && last${prop} === undefined) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (current${prop} == null && last${prop} == null) {\n\n` +
             `  } else if ((current${prop} != null && last${prop} == null) || (current${prop} == null && last${prop} != null)) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (${cond}) {\n` +
             `    diff${prop} = current${prop};\n` +
-            `  }\n`;
+            `  }\n`);
     }
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();
         if (prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED) {
-            const meta2 = this.metadata.find(prop.type);
-            if (meta2.primaryKeys.length > 1) {
-                type = 'array';
+            if (prop.polymorphic) {
+                type = 'object';
             }
             else {
-                type = meta2.properties[meta2.primaryKeys[0]].type.toLowerCase();
+                const meta2 = prop.targetMeta;
+                if (meta2.primaryKeys.length > 1) {
+                    type = 'array';
+                }
+                else {
+                    type = meta2.getPrimaryProp().type.toLowerCase();
+                }
             }
         }
         if (prop.customType) {
             if (prop.customType.compareValues) {
                 const idx = this.tmpIndex++;
-                context.set(`compareValues_${idx}`, (a, b) => prop.customType.compareValues(a, b));
+                context.set(`compareValues_${idx}`, (a, b) => {
+                    if (Raw.isKnownFragment(a) || Raw.isKnownFragment(b)) {
+                        return Raw.getKnownFragment(a) === Raw.getKnownFragment(b);
+                    }
+                    return prop.customType.compareValues(a, b);
+                });
                 return this.getGenericComparator(this.wrap(prop.name), `!compareValues_${idx}(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
             }
             type = prop.customType.compareAsType().toLowerCase();
@@ -605,10 +695,10 @@ export class EntityComparator {
         if (['buffer', 'uint8array'].includes(type)) {
             return this.getGenericComparator(this.wrap(prop.name), `!compareBuffers(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
         }
-        if (['date'].includes(type)) {
+        if (type === 'date') {
             return this.getGenericComparator(this.wrap(prop.name), `last${this.wrap(prop.name)}.valueOf() !== current${this.wrap(prop.name)}.valueOf()`);
         }
-        if (['objectid'].includes(type)) {
+        if (type === 'objectid') {
             // We might be comparing PK to object, in case we compare with cached data of populated entity
             // in such case we just ignore the comparison and fallback to `equals()` (which will still mark
             // it as not equal as we compare PK to plain object).
@@ -618,14 +708,30 @@ export class EntityComparator {
         return this.getGenericComparator(this.wrap(prop.name), `!equals(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
     }
     wrap(key) {
-        if (key.match(/^\[.*]$/)) {
+        if (/^\[.*]$/.exec(key)) {
             return key;
         }
-        return key.match(/^\w+$/) ? `.${key}` : `['${key}']`;
+        return /^\w+$/.exec(key) ? `.${key}` : `['${key}']`;
     }
     safeKey(key) {
         return key.replace(/\W/g, '_');
     }
+    /**
+     * Sets the toArray helper in the context if not already set.
+     * Used for converting composite PKs to arrays.
+     */
+    setToArrayHelper(context) {
+        if (context.has('toArray')) {
+            return;
+        }
+        const toArray = (val) => {
+            if (Utils.isPlainObject(val)) {
+                return Object.values(val).map(v => toArray(v));
+            }
+            return val;
+        };
+        context.set('toArray', toArray);
+    }
     /**
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */