@mikro-orm/core 7.0.10-dev.9 → 7.0.11-dev.0

package/EntityManager.d.ts

@@ -324,6 +324,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      */
     map<Entity extends object>(entityName: EntityName<Entity>, result: EntityDictionary<Entity>, options?: {
         schema?: string;
+        mapped?: boolean;
     }): Entity;
     /**
      * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities

package/EntityManager.js

@@ -1295,8 +1295,9 @@ export class EntityManager {
      * Maps raw database result to an entity and merges it to this EntityManager.
      */
     map(entityName, result, options = {}) {
+        const { mapped, ...rest } = options;
         const meta = this.metadata.get(entityName);
-        const data = this.driver.mapResult(result, meta);
+        const data = (mapped ? result : this.driver.mapResult(result, meta));
         for (const k of Object.keys(data)) {
             const prop = meta.properties[k];
             if (prop?.kind === ReferenceKind.SCALAR &&
@@ -1310,7 +1311,7 @@ export class EntityManager {
             convertCustomTypes: true,
             refresh: true,
             validate: false,
-            ...options,
+            ...rest,
         });
     }
     /**

package/entity/Collection.js

@@ -5,7 +5,9 @@ import { Reference } from './Reference.js';
 import { helper, wrap } from './wrap.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
 import { inspect } from '../logging/inspect.js';
-const collectionSymbol = Symbol('Collection');
+// Globally registered so the marker survives the CJS/ESM dual-package hazard
+// (see entitySymbol rationale in EntityHelper.ts and #7515/#7534).
+const collectionSymbol = Symbol.for('@mikro-orm/core/Collection');
 /** Represents a to-many relation (1:m or m:n) as an iterable, managed collection of entities. */
 export class Collection {
     owner;

package/entity/EntityLoader.js

@@ -489,6 +489,22 @@ export class EntityLoader {
             }
         }
         if (populated.length === 0 && !populate.children) {
+            // Populate child-specific relations for TPT entities already in the identity map (GH #7529).
+            // Pass a sentinel hint so the existing TPT child handling in `populate()` does the real work.
+            if (populate.all && prop.targetMeta?.inheritanceType === 'tpt') {
+                const visited = options.visited;
+                const pending = Utils.unique(children).filter(c => helper(c).__meta !== prop.targetMeta && !visited.has(c));
+                if (pending.length > 0) {
+                    const hint = [
+                        { field: prop.targetMeta.primaryKeys[0], strategy: LoadStrategy.SELECT_IN, all: true },
+                    ];
+                    await this.populate(prop.targetMeta.class, pending, hint, {
+                        ...options,
+                        lookup: false,
+                        validate: false,
+                    });
+                }
+            }
             return;
         }
         const fields = this.buildFields(options.fields, prop);

package/entity/Reference.js

@@ -4,8 +4,10 @@ import { Utils } from '../utils/Utils.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
 import { NotFoundError } from '../errors.js';
 import { inspect } from '../logging/inspect.js';
-const referenceSymbol = Symbol('Reference');
-const scalarReferenceSymbol = Symbol('ScalarReference');
+// Globally registered so the markers survive the CJS/ESM dual-package hazard
+// (see entitySymbol rationale in EntityHelper.ts and #7515/#7534).
+const referenceSymbol = Symbol.for('@mikro-orm/core/Reference');
+const scalarReferenceSymbol = Symbol.for('@mikro-orm/core/ScalarReference');
 /** Wrapper around an entity that provides lazy loading capabilities and identity-preserving reference semantics. */
 export class Reference {
     entity;

package/metadata/MetadataDiscovery.js

@@ -1493,7 +1493,12 @@ export class MetadataDiscovery {
             }
         }
         if (this.#platform.usesEnumCheckConstraints() && !meta.embeddable) {
-            for (const prop of meta.props) {
+            // Iterate `meta.properties` rather than `meta.props` — by this point in
+            // the discovery pipeline `initEmbeddables` has added flattened embedded
+            // properties to `meta.properties`, but `meta.sync()` has not yet been
+            // called, so `meta.props` is still the pre-flatten array and would miss
+            // enum properties that live inside embeddables.
+            for (const prop of Object.values(meta.properties)) {
                 if (prop.persist === false || prop.nativeEnumName || !prop.items?.every(item => typeof item === 'string')) {
                     continue;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.10-dev.9",
+  "version": "7.0.11-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/utils/QueryHelper.js

@@ -106,7 +106,10 @@ export class QueryHelper {
                 Object.keys(where).every(k => !Utils.isPlainObject(where[k]) ||
                     Object.keys(where[k]).every(v => {
                         if (Utils.isOperator(v, false)) {
-                            return true;
+                            // multi-value operators (e.g. `$in`/`$nin`) cannot be inlined into a composite
+                            // PK tuple — `getPrimaryKeyValues` would flatten the operator's array alongside
+                            // the sibling PK values, producing a malformed `(col1, col2) IN ((a, b))` clause
+                            return !meta.compositePK || !Array.isArray(where[k][v]);
                         }
                         if (meta.properties[k].primary &&
                             [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {

package/utils/RawQueryFragment.d.ts

@@ -4,6 +4,8 @@ declare const rawFragmentSymbolBrand: unique symbol;
 export type RawQueryFragmentSymbol = symbol & {
     readonly [rawFragmentSymbolBrand]: true;
 };
+/** Checks whether the given value is a `RawQueryFragment` instance. */
+export declare function isRaw(value: unknown): value is RawQueryFragment;
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export declare class RawQueryFragment<Alias extends string = string> {
     #private;
@@ -30,8 +32,6 @@ export declare class RawQueryFragment<Alias extends string = string> {
     static getKnownFragment(key: unknown): RawQueryFragment | undefined;
 }
 export { RawQueryFragment as Raw };
-/** Checks whether the given value is a `RawQueryFragment` instance. */
-export declare function isRaw(value: unknown): value is RawQueryFragment;
 /** @internal */
 export declare const ALIAS_REPLACEMENT = "[::alias::]";
 /** @internal */

package/utils/RawQueryFragment.js

@@ -1,21 +1,53 @@
 import { Utils } from './Utils.js';
-const rawSymbol = Symbol('RawQueryFragment');
+// Brand lives on the prototype so JSON payloads — whose proto is
+// `Object.prototype` — cannot forge it. String key, not a `Symbol.for(...)`,
+// so each CJS/ESM copy of this module independently installs it on its own
+// prototype without publishing a global key for the marker that controls raw
+// SQL assembly. The string is namespaced so it does not collide with property
+// names users might independently install on their own prototypes.
+const RAW_FRAGMENT_BRAND = '__mikroOrmRawFragment';
+// Back-references from a fragment's symbol key to the fragment itself, shared
+// across CJS/ESM module copies via globalThis: when one copy creates a fragment
+// via `raw('…')` and stores its symbol in a where-clause object key, the other
+// copy still needs to recover the original fragment to assemble SQL.
+const REGISTRY_KEY = Symbol.for('@mikro-orm/core/RawQueryFragment.references');
+const rawQueryReferences = (globalThis[REGISTRY_KEY] ??=
+    new WeakMap());
+/** Checks whether the given value is a `RawQueryFragment` instance. */
+export function isRaw(value) {
+    if (value == null || typeof value !== 'object') {
+        return false;
+    }
+    // Fast path: intra-module instances and their subclasses.
+    // eslint-disable-next-line no-use-before-define
+    if (value instanceof RawQueryFragment) {
+        return true;
+    }
+    // Walk the prototype chain starting from the *prototype* (not the value) so
+    // own-property spoofing from JSON payloads cannot forge the brand. Stop at
+    // `Object.prototype`, which is never branded — that bails plain objects,
+    // JSON payloads, and built-ins like `Date`/`Array`/`Map` at depth 1.
+    for (let p = Object.getPrototypeOf(value); p != null && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
+        if (Object.hasOwn(p, RAW_FRAGMENT_BRAND)) {
+            return true;
+        }
+    }
+    return false;
+}
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export class RawQueryFragment {
     sql;
     params;
-    static #rawQueryReferences = new WeakMap();
     #key;
     constructor(sql, params = []) {
         this.sql = sql;
         this.params = params;
-        Object.defineProperty(this, rawSymbol, { value: true, enumerable: false });
     }
     /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
     get key() {
         if (!this.#key) {
             this.#key = Symbol(this.toJSON());
-            RawQueryFragment.#rawQueryReferences.set(this.#key, this);
+            rawQueryReferences.set(this.#key, this);
         }
         return this.#key;
     }
@@ -42,7 +74,7 @@ export class RawQueryFragment {
     }
     /** Checks whether the given value is a symbol that maps to a known raw query fragment. */
     static isKnownFragmentSymbol(key) {
-        return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
+        return typeof key === 'symbol' && rawQueryReferences.has(key);
     }
     /** Checks whether an object has any symbol keys that are known raw query fragments. */
     static hasObjectFragments(object) {
@@ -51,20 +83,17 @@ export class RawQueryFragment {
     }
     /** Checks whether the given value is a RawQueryFragment instance or a known fragment symbol. */
     static isKnownFragment(key) {
-        if (key instanceof RawQueryFragment) {
-            return true;
-        }
-        return this.isKnownFragmentSymbol(key);
+        return isRaw(key) || this.isKnownFragmentSymbol(key);
     }
     /** Retrieves the RawQueryFragment associated with the given key (instance or symbol). */
     static getKnownFragment(key) {
-        if (key instanceof RawQueryFragment) {
+        if (isRaw(key)) {
             return key;
         }
         if (typeof key !== 'symbol') {
             return;
         }
-        return this.#rawQueryReferences.get(key);
+        return rawQueryReferences.get(key);
     }
     /** @ignore */
     /* v8 ignore next */
@@ -75,11 +104,19 @@ export class RawQueryFragment {
         return { sql: this.sql };
     }
 }
+// Non-enumerable so the brand is skipped by JSON/Object.keys/for-in, and locked
+// down (non-writable, non-configurable) so in-process code cannot delete or
+// overwrite it and thereby silently disable `isRaw` recognition for every
+// fragment in the process. Subclasses don't need mutability here — they inherit
+// the brand via the prototype chain, and sibling-copy classes install their own
+// brand on their own prototype (a different object), so lockdown only blocks
+// tampering with the canonical marker.
+Object.defineProperty(RawQueryFragment.prototype, RAW_FRAGMENT_BRAND, {
+    value: true,
+    writable: false,
+    configurable: false,
+});
 export { RawQueryFragment as Raw };
-/** Checks whether the given value is a `RawQueryFragment` instance. */
-export function isRaw(value) {
-    return typeof value === 'object' && value !== null && Object.hasOwn(value, rawSymbol);
-}
 /** @internal */
 export const ALIAS_REPLACEMENT = '[::alias::]';
 /** @internal */
@@ -140,7 +177,7 @@ export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * ```
  */
 export function raw(sql, params) {
-    if (sql instanceof RawQueryFragment) {
+    if (isRaw(sql)) {
         return sql;
     }
     if (sql instanceof Function) {

package/utils/TransactionManager.js

@@ -163,6 +163,10 @@ export class TransactionManager {
             const parentEntity = parentUoW.getById(meta.class, wrapped.getPrimaryKey(), parent.schema, true);
             if (parentEntity && parentEntity !== entity) {
                 const parentWrapped = helper(parentEntity);
+                // Don't overwrite a fully-loaded entity with an uninitialized reference
+                if (!wrapped.__initialized && parentWrapped.__initialized) {
+                    continue;
+                }
                 parentWrapped.__data = wrapped.__data;
                 parentWrapped.__originalEntityData = wrapped.__originalEntityData;
                 for (const prop of meta.hydrateProps) {

package/utils/Utils.js

@@ -22,13 +22,22 @@ export function compareObjects(a, b) {
     if (a === b || (a == null && b == null)) {
         return true;
     }
-    if (!a || !b || typeof a !== 'object' || typeof b !== 'object' || !compareConstructors(a, b)) {
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
         return false;
     }
+    // Raw fragments are compared by `sql` + `params` *before* the constructor
+    // check, so that two fragments carrying the same SQL but constructed by
+    // different CJS/ESM copies of this module (different classes, different
+    // prototypes) still compare as equal. Without this, the dual-package hazard
+    // would produce spurious change-set diffs when a raw fragment is used as a
+    // property value.
     if (isRaw(a) && isRaw(b)) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return a.sql === b.sql && compareArrays(a.params, b.params);
     }
+    if (!compareConstructors(a, b)) {
+        return false;
+    }
     if (a instanceof Date && b instanceof Date) {
         const timeA = a.getTime();
         const timeB = b.getTime();
@@ -132,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.10-dev.9';
+    static #ORM_VERSION = '7.0.11-dev.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */