@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/utils/EntityComparator.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityComparator = void 0;
-const clone_1 = require("./clone");
-const enums_1 = require("../enums");
-const Utils_1 = require("./Utils");
-const JsonType_1 = require("../types/JsonType");
-const RawQueryFragment_1 = require("./RawQueryFragment");
-class EntityComparator {
+import { clone } from './clone.js';
+import { ReferenceKind } from '../enums.js';
+import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
+import { JsonType } from '../types/JsonType.js';
+import { RawQueryFragment } from './RawQueryFragment.js';
+export class EntityComparator {
     metadata;
     platform;
     comparators = new Map();
@@ -23,13 +20,13 @@ class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities(entityName, a, b) {
+    diffEntities(entityName, a, b, options) {
         const comparator = this.getEntityComparator(entityName);
-        return Utils_1.Utils.callCompiledFunction(comparator, a, b);
+        return Utils.callCompiledFunction(comparator, a, b, options);
     }
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);
-        return Utils_1.Utils.getObjectKeysSize(diff) === 0;
+        return Utils.getObjectKeysSize(diff) === 0;
     }
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
@@ -37,21 +34,21 @@ class EntityComparator {
      */
     prepareEntity(entity) {
         const generator = this.getSnapshotGenerator(entity.constructor.name);
-        return Utils_1.Utils.callCompiledFunction(generator, entity);
+        return Utils.callCompiledFunction(generator, entity);
     }
     /**
      * Maps database columns to properties.
      */
     mapResult(entityName, result) {
         const mapper = this.getResultMapper(entityName);
-        return Utils_1.Utils.callCompiledFunction(mapper, result);
+        return Utils.callCompiledFunction(mapper, result);
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
         const exists = this.pkGetters.get(meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (exists) {
             return exists;
         }
@@ -60,7 +57,7 @@ class EntityComparator {
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const cond = {`);
             meta.primaryKeys.forEach(pk => {
-                if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+                if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getPrimaryKey() : entity${this.wrap(pk)},`);
                 }
                 else {
@@ -73,11 +70,11 @@ class EntityComparator {
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+            if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
                 lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
                 if (meta.properties[pk].targetMeta.compositePK) {
-                    lines.push(`    if (typeof pk === 'object') {`);
+                    lines.push(`    if (typeof pk === 'object' && pk != null) {`);
                     lines.push(`      return [`);
                     for (const childPK of meta.properties[pk].targetMeta.primaryKeys) {
                         lines.push(`        pk${this.wrap(childPK)},`);
@@ -92,7 +89,7 @@ class EntityComparator {
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils_1.Utils.createFunction(context, code);
+        const pkSerializer = Utils.createFunction(context, code);
         this.pkGetters.set(meta.className, pkSerializer);
         return pkSerializer;
     }
@@ -101,7 +98,7 @@ class EntityComparator {
      */
     getPkGetterConverted(meta) {
         const exists = this.pkGettersConverted.get(meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (exists) {
             return exists;
         }
@@ -110,7 +107,7 @@ class EntityComparator {
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const cond = {`);
             meta.primaryKeys.forEach(pk => {
-                if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+                if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getPrimaryKey(true) : entity${this.wrap(pk)},`);
                 }
                 else {
@@ -129,7 +126,7 @@ class EntityComparator {
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+            if (meta.properties[pk].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.getPrimaryKey(true);`);
             }
             if (meta.properties[pk].customType) {
@@ -142,7 +139,7 @@ class EntityComparator {
         }
         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_1.Utils.createFunction(context, code);
+        const pkSerializer = Utils.createFunction(context, code);
         this.pkGettersConverted.set(meta.className, pkSerializer);
         return pkSerializer;
     }
@@ -151,17 +148,18 @@ class EntityComparator {
      */
     getPkSerializer(meta) {
         const exists = this.pkSerializers.get(meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
-        context.set('getCompositeKeyValue', (val) => Utils_1.Utils.flatten(Utils_1.Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.platform)));
+        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 => {
-                if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+                if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey() : entity${this.wrap(pk)},`);
                 }
                 else {
@@ -169,22 +167,31 @@ class EntityComparator {
                 }
             });
             lines.push(`  ];`);
-            lines.push(`  return pks.join('${Utils_1.Utils.PK_SEPARATOR}');`);
+            lines.push(`  return pks.join('${Utils.PK_SEPARATOR}');`);
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.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}`;
-        const pkSerializer = Utils_1.Utils.createFunction(context, code);
+        const pkSerializer = Utils.createFunction(context, code);
         this.pkSerializers.set(meta.className, pkSerializer);
         return pkSerializer;
     }
@@ -192,6 +199,7 @@ class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator(entityName) {
+        entityName = Utils.className(entityName);
         const exists = this.snapshotGenerators.get(entityName);
         if (exists) {
             return exists;
@@ -199,7 +207,7 @@ class EntityComparator {
         const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
-        context.set('clone', clone_1.clone);
+        context.set('clone', clone);
         context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
         if (meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
@@ -209,11 +217,11 @@ class EntityComparator {
         meta.comparableProps
             .filter(prop => {
             const root = getRootProperty(prop);
-            return prop === root || root.kind !== enums_1.ReferenceKind.EMBEDDED;
+            return prop === root || root.kind !== ReferenceKind.EMBEDDED;
         })
             .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_1.Utils.createFunction(context, code);
+        const snapshotGenerator = Utils.createFunction(context, code);
         this.snapshotGenerators.set(entityName, snapshotGenerator);
         return snapshotGenerator;
     }
@@ -277,10 +285,14 @@ class EntityComparator {
             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 {`);
@@ -289,60 +301,76 @@ class EntityComparator {
             lines.push(`${padding}    }`);
         };
         lines.push(`  const mapped = {};`);
-        meta.props.forEach(prop => {
-            if (!prop.fieldNames) {
-                return;
-            }
-            if (prop.targetMeta && prop.fieldNames.length > 1) {
-                lines.push(`  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
-                lines.push(`  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${this.createCompositeKeyArray(prop)};`);
-                lines.push(...prop.fieldNames.map(field => `    ${this.propName(field, 'mapped')} = true;`));
-                lines.push(`  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n    ret${this.wrap(prop.name)} = null;`);
-                lines.push(...prop.fieldNames.map(field => `    ${this.propName(field, 'mapped')} = true;`), '  }');
-                return;
-            }
-            if (prop.embedded && (meta.embeddable || meta.properties[prop.embedded[0]].object)) {
-                return;
-            }
-            if (prop.runtimeType === 'boolean') {
-                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : !!${this.propName(prop.fieldNames[0])};`);
-                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
-                lines.push(`  }`);
-            }
-            else if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
-                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
-                context.set('parseDate', (value) => this.platform.parseDate(value));
-                parseDate('ret' + this.wrap(prop.name), this.propName(prop.fieldNames[0]));
-                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
-                lines.push(`  }`);
-            }
-            else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
-                const idx = this.tmpIndex++;
-                context.set(`mapEmbeddedResult_${idx}`, (data) => {
-                    const item = (0, Utils_1.parseJsonSafe)(data);
-                    if (Array.isArray(item)) {
-                        return item.map(row => row == null ? row : this.getResultMapper(prop.type)(row));
-                    }
-                    return item == null ? item : this.getResultMapper(prop.type)(item);
-                });
-                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${this.propName(prop.fieldNames[0])});`);
-                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
-                lines.push(`  }`);
+        const mapEntityProperties = (meta, padding = '') => {
+            for (const prop of meta.props) {
+                if (!prop.fieldNames) {
+                    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(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
+                    continue;
+                }
+                if (prop.embedded && (meta.embeddable || meta.properties[prop.embedded[0]].object)) {
+                    continue;
+                }
+                if (prop.runtimeType === 'boolean') {
+                    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])} : !!${this.propName(prop.fieldNames[0])};`);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
+                else if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
+                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    context.set('parseDate', (value) => this.platform.parseDate(value));
+                    parseDate('ret' + this.wrap(prop.name), this.propName(prop.fieldNames[0]), padding);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
+                else if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
+                    const idx = this.tmpIndex++;
+                    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 == null ? item : this.getResultMapper(prop.type)(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])});`);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
+                else if (prop.kind !== ReferenceKind.EMBEDDED) {
+                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
             }
-            else if (prop.kind !== enums_1.ReferenceKind.EMBEDDED) {
-                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
-                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+        };
+        if (meta.polymorphs && meta.discriminatorColumn) {
+            for (const polymorph of meta.polymorphs) {
+                const first = polymorph === meta.polymorphs[0];
+                lines.push(`  ${first ? '' : 'else '}if (${this.propName(meta.discriminatorColumn)} == '${polymorph.discriminatorValue}') {`);
+                mapEntityProperties(polymorph, '  ');
                 lines.push(`  }`);
             }
-        });
-        lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k]) ret[k] = result[k]; }`);
+            lines.push(`  else {`);
+            mapEntityProperties(meta, '  ');
+            lines.push(`  }`);
+        }
+        else {
+            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_1.Utils.createFunction(context, code);
+        const resultMapper = Utils.createFunction(context, code);
         this.mappers.set(entityName, resultMapper);
         return resultMapper;
     }
@@ -394,11 +422,21 @@ class EntityComparator {
     }
     getEmbeddedPropertySnapshot(meta, prop, context, level, path, dataKey, object = prop.object) {
         const padding = ' '.repeat(level * 2);
+        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) {
@@ -408,7 +446,7 @@ class EntityComparator {
             if (!childProp.customType) {
                 return false;
             }
-            if (childProp.customType instanceof JsonType_1.JsonType) {
+            if (childProp.customType instanceof JsonType) {
                 return !prop.object;
             }
             return true;
@@ -419,10 +457,10 @@ class EntityComparator {
             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 === enums_1.ReferenceKind.EMBEDDED) {
+            if (childProp.kind === ReferenceKind.EMBEDDED) {
                 return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
             }
-            if (childProp.kind !== enums_1.ReferenceKind.SCALAR) {
+            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');
             }
@@ -443,8 +481,8 @@ class EntityComparator {
     registerCustomType(prop, context) {
         const convertorKey = this.safeKey(prop.name);
         context.set(`convertToDatabaseValue_${convertorKey}`, (val) => {
-            /* istanbul ignore if */
-            if (RawQueryFragment_1.RawQueryFragment.isKnownFragment(val)) {
+            /* v8 ignore next */
+            if (RawQueryFragment.isKnownFragment(val)) {
                 return val;
             }
             return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
@@ -457,13 +495,13 @@ class EntityComparator {
         if (['number', 'string', 'boolean'].includes(prop.type.toLowerCase())) {
             return ret + `    ret${dataKey} = entity${entityKey}${unwrap};\n  }\n`;
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind === ReferenceKind.EMBEDDED) {
             if (prop.array) {
                 return this.getEmbeddedArrayPropertySnapshot(meta, prop, context, level, path, dataKey) + '\n';
             }
             return this.getEmbeddedPropertySnapshot(meta, prop, context, level, path, dataKey, object) + '\n';
         }
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE) {
+        if (prop.kind === ReferenceKind.ONE_TO_ONE || prop.kind === ReferenceKind.MANY_TO_ONE) {
             if (prop.mapToPk) {
                 if (prop.customType) {
                     const convertorKey = this.registerCustomType(prop, context);
@@ -475,7 +513,7 @@ class EntityComparator {
             }
             else {
                 const toArray = (val) => {
-                    if (Utils_1.Utils.isPlainObject(val)) {
+                    if (Utils.isPlainObject(val)) {
                         return Object.values(val).map(v => toArray(v));
                     }
                     return val;
@@ -513,22 +551,32 @@ class EntityComparator {
         const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
-        context.set('compareArrays', Utils_1.compareArrays);
-        context.set('compareBooleans', Utils_1.compareBooleans);
-        context.set('compareBuffers', Utils_1.compareBuffers);
-        context.set('compareObjects', Utils_1.compareObjects);
-        context.set('equals', Utils_1.equals);
-        meta.comparableProps.forEach(prop => {
+        context.set('compareArrays', compareArrays);
+        context.set('compareBooleans', compareBooleans);
+        context.set('compareBuffers', compareBuffers);
+        context.set('compareObjects', compareObjects);
+        context.set('equals', equals);
+        for (const prop of meta.comparableProps) {
             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}`;
-        const comparator = Utils_1.Utils.createFunction(context, code);
+            + `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;
     }
     getGenericComparator(prop, cond) {
-        return `  if (current${prop} == null && last${prop} == null) {\n\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` +
@@ -537,7 +585,7 @@ class EntityComparator {
     }
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();
-        if (prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED) {
             const meta2 = this.metadata.find(prop.type);
             if (meta2.primaryKeys.length > 1) {
                 type = 'array';
@@ -569,10 +617,10 @@ 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).
@@ -594,11 +642,10 @@ class EntityComparator {
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */
     static isComparable(prop, root) {
-        const virtual = prop.persist === false || prop.generated;
-        const inverse = prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
+        const virtual = prop.persist === false || (prop.generated && !prop.primary);
+        const inverse = prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
         const discriminator = prop.name === root.discriminatorColumn;
-        const collection = prop.kind === enums_1.ReferenceKind.ONE_TO_MANY || prop.kind === enums_1.ReferenceKind.MANY_TO_MANY;
+        const collection = prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY;
         return !virtual && !collection && !inverse && !discriminator && !prop.version;
     }
 }
-exports.EntityComparator = EntityComparator;

package/utils/NullHighlighter.d.ts

@@ -1,4 +1,4 @@
-import type { Highlighter } from '../typings';
+import type { Highlighter } from '../typings.js';
 export declare class NullHighlighter implements Highlighter {
     highlight(text: string): string;
 }

package/utils/NullHighlighter.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NullHighlighter = void 0;
-class NullHighlighter {
+export class NullHighlighter {
     highlight(text) {
         return text;
     }
 }
-exports.NullHighlighter = NullHighlighter;

package/utils/QueryHelper.d.ts

@@ -1,13 +1,21 @@
-import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings';
-import type { Platform } from '../platforms';
-import type { MetadataStorage } from '../metadata/MetadataStorage';
+import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { FilterOptions } from '../drivers/IDatabaseDriver.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[];
+    static getActiveFilters(entityName: string, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
+    static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
     static isFilterActive(entityName: string, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;