@mikro-orm/core 7.1.14 → 7.1.15-dev.0

package/EntityManager.js

@@ -260,7 +260,7 @@ export class EntityManager {
     addFilter(options) {
         options = { ...options };
         if (options.entity) {
-            options.entity = Utils.asArray(options.entity).map(n => Utils.className(n));
+            options.entity = Utils.asArray(options.entity).map(n => Utils.classOrName(n));
         }
         options.default ??= true;
         this.getContext(false).#filters[options.name] = options;
@@ -2116,7 +2116,11 @@ export class EntityManager {
         ]) {
             delete opts[k];
         }
-        return [Utils.className(entityName), method, opts, where];
+        // the table name (plus discriminator value for STI) is stable across builds and processes,
+        // unlike class names, which minifiers can mangle to the same short name for two entities
+        const meta = this.metadata.find(entityName);
+        const key = meta?.tableName ? [meta.schema, meta.tableName, meta.discriminatorValue] : Utils.className(entityName);
+        return [key, method, opts, where];
     }
     /**
      * @internal

package/entity/EntityRepository.js

@@ -223,7 +223,11 @@ export class EntityRepository {
         }
         const entityName = entities[0].constructor.name;
         const repoType = Utils.className(this.entityName);
-        if (entityName && repoType !== entityName) {
+        // compare class identity where possible, as minifiers can mangle two classes to the same name
+        const entityMeta = entities[0].__meta;
+        const repoMeta = this.getEntityManager().getMetadata?.().find(this.entityName);
+        const mismatch = entityMeta && repoMeta ? entityMeta.class !== repoMeta.class : entityName && repoType !== entityName;
+        if (mismatch) {
             throw ValidationError.fromWrongRepositoryType(entityName, repoType, method);
         }
     }

package/errors.d.ts

@@ -60,6 +60,7 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
+    static ambiguousEntityName(className: string): MetadataError;
     static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError;
     static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError;
     static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError;

package/errors.js

@@ -195,6 +195,9 @@ export class MetadataError extends ValidationError {
     static missingMetadata(entity) {
         return new MetadataError(`Metadata for entity ${entity} not found`);
     }
+    static ambiguousEntityName(className) {
+        return new MetadataError(`Entity name '${className}' is ambiguous, multiple discovered entity classes share it (possibly due to a minifier mangling class names). Use a class reference instead of a string name.`);
+    }
     static invalidPrimaryKey(meta, prop, requiredName) {
         return this.fromMessage(meta, prop, `has wrong field name, '${requiredName}' is required in current driver`);
     }

package/events/EventManager.js

@@ -43,7 +43,10 @@ export class EventManager {
         }));
         for (const listener of this.#listeners[event] ?? new Set()) {
             const entities = this.#entities.get(listener);
-            if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
+            if (entities.size === 0 ||
+                !entity ||
+                entities.has(entity.constructor) ||
+                entities.has(entity.constructor.name)) {
                 listeners.push(listener[event].bind(listener));
             }
         }
@@ -68,7 +71,7 @@ export class EventManager {
         }
         for (const listener of this.#listeners[event] ?? new Set()) {
             const entities = this.#entities.get(listener);
-            if (entities.size === 0 || entities.has(meta.className)) {
+            if (entities.size === 0 || entities.has(meta.class) || entities.has(meta.className)) {
                 this.#cache.set(cacheKey, true);
                 return true;
             }
@@ -84,6 +87,6 @@ export class EventManager {
         if (!listener.getSubscribedEntities) {
             return new Set();
         }
-        return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
+        return new Set(listener.getSubscribedEntities().map(name => Utils.classOrName(name)));
     }
 }

package/metadata/MetadataDiscovery.js

@@ -2138,7 +2138,7 @@ export class MetadataDiscovery {
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.#config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {
-            return forceConstructor.some(cls => Utils.className(cls) === meta.className);
+            return forceConstructor.some(cls => Utils.matchesEntity(cls, meta));
         }
         return forceConstructor;
     }

package/metadata/MetadataStorage.js

@@ -17,6 +17,7 @@ export class MetadataStorage {
     #idMap;
     #classNameMap;
     #uniqueNameMap;
+    #ambiguousNames = new Set();
     constructor(metadata = {}) {
         this.#idMap = {};
         this.#uniqueNameMap = {};
@@ -64,6 +65,10 @@ export class MetadataStorage {
     }
     /** Returns metadata for the given entity, optionally initializing it if not found. */
     get(entityName, init = false) {
+        // string lookups cannot be resolved when several classes were minified to the same name
+        if (typeof entityName === 'string' && this.#ambiguousNames.has(entityName)) {
+            throw MetadataError.ambiguousEntityName(entityName);
+        }
         const exists = this.find(entityName);
         if (exists) {
             return exists;
@@ -99,7 +104,13 @@ export class MetadataStorage {
         this.#metadataMap.set(entityName, meta);
         this.#idMap[meta._id] = meta;
         this.#uniqueNameMap[meta.uniqueName] = meta;
-        this.#classNameMap[Utils.className(entityName)] = meta;
+        const className = Utils.className(entityName);
+        const existing = this.#classNameMap[className];
+        // track name collisions caused by minifiers mangling two classes to the same name
+        if (existing && existing !== meta && existing.class !== meta.class) {
+            this.#ambiguousNames.add(className);
+        }
+        this.#classNameMap[className] = meta;
         return meta;
     }
     /** Removes metadata for the given entity from all internal maps. */
@@ -110,6 +121,11 @@ export class MetadataStorage {
             delete this.#idMap[meta._id];
             delete this.#uniqueNameMap[meta.uniqueName];
             delete this.#classNameMap[meta.className];
+            // the name may still be ambiguous among the remaining metas
+            const remaining = new Set([...this.#metadataMap.values()].filter(m => m.className === meta.className).map(m => m.class));
+            if (remaining.size <= 1) {
+                this.#ambiguousNames.delete(meta.className);
+            }
         }
     }
     /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.14",
+  "version": "7.1.15-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/types/Type.js

@@ -55,11 +55,11 @@ export class Type {
         return prop.columnTypes?.[0] ?? platform.getTextTypeDeclarationSQL(prop);
     }
     static getType(cls) {
-        const key = cls.name;
-        if (!Type.types.has(key)) {
-            Type.types.set(key, new cls());
+        // keyed by class reference, as minifiers can mangle two classes to the same name
+        if (!Type.types.has(cls)) {
+            Type.types.set(cls, new cls());
         }
-        return Type.types.get(key);
+        return Type.types.get(cls);
     }
     /**
      * Checks whether the argument is instance of `Type`.

package/utils/QueryHelper.js

@@ -305,7 +305,7 @@ export class QueryHelper {
         return Utils.mergeConfig({}, propFilters, options);
     }
     static isFilterActive(meta, filterName, filter, options) {
-        if (filter.entity && !filter.entity.includes(meta.className)) {
+        if (filter.entity && !Utils.asArray(filter.entity).some(e => Utils.matchesEntity(e, meta))) {
             return false;
         }
         if (options[filterName] === false) {

package/utils/Utils.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledFunctions, Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
+import type { CompiledFunctions, Dictionary, EntityCtor, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 import { ScalarReference } from '../entity/Reference.js';
 import { Collection } from '../entity/Collection.js';
@@ -129,6 +129,16 @@ export declare class Utils {
      * Gets string name of given class.
      */
     static className<T>(classOrName: string | EntityName<T>): string;
+    /**
+     * Normalizes an entity reference for identity-safe matching: keeps class references
+     * (minifiers can mangle two classes to the same name) and falls back to the class name otherwise.
+     */
+    static classOrName<T>(classOrName: string | EntityName<T>): EntityCtor<T> | string;
+    /**
+     * Checks whether the given entity reference points at the given metadata,
+     * comparing classes by identity and strings by class name.
+     */
+    static matchesEntity<T>(classOrName: string | EntityName<T>, meta: EntityMetadata<any>): boolean;
     static extractChildElements(items: readonly string[], prefix: string, allSymbol?: string): string[];
     /**
      * Tries to detect TypeScript support.

package/utils/Utils.js

@@ -153,7 +153,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.1.14';
+    static #ORM_VERSION = '7.1.15-dev.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -565,6 +565,21 @@ export class Utils {
         }
         return classOrName.name;
     }
+    /**
+     * Normalizes an entity reference for identity-safe matching: keeps class references
+     * (minifiers can mangle two classes to the same name) and falls back to the class name otherwise.
+     */
+    static classOrName(classOrName) {
+        return typeof classOrName === 'function' ? classOrName : Utils.className(classOrName);
+    }
+    /**
+     * Checks whether the given entity reference points at the given metadata,
+     * comparing classes by identity and strings by class name.
+     */
+    static matchesEntity(classOrName, meta) {
+        const ref = Utils.classOrName(classOrName);
+        return typeof ref === 'function' ? ref === meta.class : ref === meta.className;
+    }
     static extractChildElements(items, prefix, allSymbol) {
         return items
             .filter(field => field === allSymbol || field.startsWith(`${prefix}.`))