@mikro-orm/core 7.0.0-rc.2 → 7.0.0

package/utils/EntityComparator.js

@@ -1,25 +1,25 @@
 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 { 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();
-    pkGetters = new Map();
-    pkGettersConverted = new Map();
-    pkSerializers = new Map();
-    tmpIndex = 0;
+    #comparators = new Map();
+    #mappers = new Map();
+    #snapshotGenerators = new Map();
+    #pkGetters = new Map();
+    #pkGettersConverted = new Map();
+    #pkSerializers = new Map();
+    #tmpIndex = 0;
+    #metadata;
+    #platform;
+    #config;
     constructor(metadata, platform, config) {
-        this.metadata = metadata;
-        this.platform = platform;
-        this.config = config;
+        this.#metadata = metadata;
+        this.#platform = platform;
+        this.#config = config;
     }
     /**
      * Computes difference between two entities.
@@ -51,7 +51,7 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
-        const exists = this.pkGetters.get(meta);
+        const exists = this.#pkGetters.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -91,18 +91,17 @@ export class EntityComparator {
             }
             lines.push(`  return entity${this.wrap(pk)};`);
         }
-        const code = `// compiled pk getter for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        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);
+        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);
+        const exists = this.#pkGettersConverted.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -142,25 +141,25 @@ 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 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);
+        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);
+        const exists = this.#pkSerializers.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
-        context.set('getCompositeKeyValue', (val) => Utils.flatten(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) : [`);
@@ -187,7 +186,7 @@ export class EntityComparator {
             }
             else if (prop.customType) {
                 const convertorKey = this.registerCustomType(meta.properties[pk], context);
-                const idx = this.tmpIndex++;
+                const idx = this.#tmpIndex++;
                 lines.push(`  const val_${idx} = convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)});`);
                 lines.push(`  return getPrimaryKeyHash(val_${idx});`);
             }
@@ -195,26 +194,25 @@ 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 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);
+        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 meta = this.metadata.find(entityName);
-        const exists = this.snapshotGenerators.get(meta);
+        const meta = this.#metadata.find(entityName);
+        const exists = this.#snapshotGenerators.get(meta);
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
         context.set('clone', clone);
-        context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
+        context.set('cloneEmbeddable', (o) => this.#platform.cloneEmbeddable(o)); // do not clone prototypes
         if (meta.root.inheritanceType === 'sti' && meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
         }
@@ -228,8 +226,8 @@ 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 fnKey = `snapshotGenerator-${meta.uniqueName}`;
-        const snapshotGenerator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
-        this.snapshotGenerators.set(meta, snapshotGenerator);
+        const snapshotGenerator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
     }
     /**
@@ -273,21 +271,21 @@ 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(meta) {
-        const exists = this.mappers.get(meta);
+        const exists = this.#mappers.get(meta);
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
         context.set('PolymorphicRef', PolymorphicRef);
-        const tz = this.platform.getTimezone();
+        const tz = this.#platform.getTimezone();
         const parseDate = (key, value, padding = '') => {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
             lines.push(`${padding}      ${key} = ${value};`);
@@ -347,19 +345,19 @@ export class EntityComparator {
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
-                else if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
+                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));
+                    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++;
+                    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.targetMeta)(row));
+                            return item.map(row => (row == null ? row : this.getResultMapper(prop.targetMeta)(row)));
                         }
                         return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
@@ -391,11 +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 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);
+        const resultMapper = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
+        this.#mappers.set(meta, resultMapper);
         return resultMapper;
     }
     getPropertyCondition(path) {
@@ -406,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)
@@ -421,7 +419,7 @@ export class EntityComparator {
         const entityKey = path.map(k => this.wrap(k)).join('');
         const ret = [];
         const padding = ' '.repeat(level * 2);
-        const idx = this.tmpIndex++;
+        const idx = this.#tmpIndex++;
         ret.push(`${padding}if (Array.isArray(entity${entityKey})) {`);
         ret.push(`${padding}  ret${dataKey} = [];`);
         ret.push(`${padding}  entity${entityKey}.forEach((_, idx_${idx}) => {`);
@@ -447,18 +445,22 @@ export 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'}`;
+        let ret = level === 1 ? '' : '\n';
         if (object) {
             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 +=
+                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`;
@@ -475,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}}`;
         }
@@ -509,7 +517,7 @@ export class EntityComparator {
             if (Raw.isKnownFragment(val)) {
                 return val;
             }
-            return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
+            return prop.customType.convertToDatabaseValue(val, this.#platform, { mode: 'serialization' });
         });
         return convertorKey;
     }
@@ -591,10 +599,10 @@ 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));
+            context.set('processDateProperty', this.#platform.processDateProperty.bind(this.#platform));
             return ret + `    ret${dataKey} = clone(processDateProperty(entity${entityKey}${unwrap}));\n  }\n`;
         }
         return ret + `    ret${dataKey} = clone(entity${entityKey}${unwrap});\n  }\n`;
@@ -603,8 +611,8 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getEntityComparator(entityName) {
-        const meta = this.metadata.find(entityName);
-        const exists = this.comparators.get(meta);
+        const meta = this.#metadata.find(entityName);
+        const exists = this.#comparators.get(meta);
         if (exists) {
             return exists;
         }
@@ -626,22 +634,22 @@ 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 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);
+        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();
@@ -661,7 +669,7 @@ export class EntityComparator {
         }
         if (prop.customType) {
             if (prop.customType.compareValues) {
-                const idx = this.tmpIndex++;
+                const idx = this.#tmpIndex++;
                 context.set(`compareValues_${idx}`, (a, b) => {
                     if (Raw.isKnownFragment(a) || Raw.isKnownFragment(b)) {
                         return Raw.getKnownFragment(a) === Raw.getKnownFragment(b);
@@ -700,10 +708,10 @@ 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, '_');

package/utils/QueryHelper.d.ts

@@ -25,8 +25,23 @@ export declare class QueryHelper {
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;
     private static processJsonCondition;
-    private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
+    /**
+     * Converts entity references for composite FK properties into flat arrays
+     * of correctly-ordered join column values, before processParams flattens them
+     * incorrectly due to shared FK columns.
+     */
+    private static convertCompositeEntityRefs;
+    /**
+     * Extracts values for a FK's join columns from an entity by traversing the FK chain.
+     * Handles shared FK columns (e.g., tenant_id referenced by multiple FKs) correctly.
+     */
+    private static extractJoinColumnValues;
+    /**
+     * Extracts the value for a specific column from an entity by finding which PK property
+     * owns that column and recursively traversing FK references.
+     */
+    private static extractColumnValue;
     /**
      * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
      * RawQueryFragment symbol keys are never deduped (each is unique).