@mikro-orm/core 7.2.2-dev.27 → 7.2.2-dev.29

package/hydration/ObjectHydrator.js

@@ -407,7 +407,7 @@ export class ObjectHydrator extends Hydrator {
         const code = `// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n` +
             `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n` +
             `${lines.join('\n')}\n}`;
-        const fnKey = `hydrator-${meta.uniqueName}-${type}-${normalizeAccessors}`;
+        const fnKey = `hydrator-${meta.compiledName}-${type}-${normalizeAccessors}`;
         const hydrator = Utils.createFunction(context, code, this.config.get('compiledFunctions'), fnKey);
         this.#hydrators[key].set(meta.class, hydrator);
         return hydrator;

package/metadata/MetadataStorage.d.ts

@@ -32,6 +32,13 @@ export declare class MetadataStorage {
     getById<T>(id: number): EntityMetadata<T>;
     /** Returns metadata by class name, optionally throwing if not found. */
     getByClassName<T = any, V extends boolean = true>(className: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    /**
+     * Returns the first registered metadata with the given table name, in registration order (entities sharing
+     * a table, like STI children, resolve to the one registered first). The index is built on first use, as table
+     * names are only final once discovery has finished.
+     * @internal
+     */
+    getByTableName<T = any>(tableName: string): EntityMetadata<T> | undefined;
     /** Returns metadata by unique name, optionally throwing if not found. */
     getByUniqueName<T = any, V extends boolean = true>(uniqueName: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
     private validate;

package/metadata/MetadataStorage.js

@@ -18,6 +18,8 @@ export class MetadataStorage {
     #classNameMap;
     #uniqueNameMap;
     #ambiguousNames = new Set();
+    /** Built on first use by `getByTableName()`, dropped whenever an entity is registered or removed. */
+    #tableNameMap;
     constructor(metadata = {}) {
         this.#idMap = {};
         this.#uniqueNameMap = {};
@@ -102,6 +104,7 @@ export class MetadataStorage {
     /** Registers metadata for the given entity. */
     set(entityName, meta) {
         this.#metadataMap.set(entityName, meta);
+        this.#tableNameMap = undefined;
         this.#idMap[meta._id] = meta;
         this.#uniqueNameMap[meta.uniqueName] = meta;
         const className = Utils.className(entityName);
@@ -110,6 +113,12 @@ export class MetadataStorage {
         if (existing && existing !== meta && existing.class !== meta.class) {
             this.#ambiguousNames.add(className);
         }
+        // colliding names are numbered in storage order, which follows the discovery config, not module evaluation
+        const sameName = this.#ambiguousNames.has(className)
+            ? [...new Set(this.#metadataMap.values())].filter(m => m.className === meta.className)
+            : [meta];
+        const ordinal = sameName.indexOf(meta);
+        meta.compiledName = ordinal > 0 ? `${meta.className}#${ordinal}` : meta.className;
         this.#classNameMap[className] = meta;
         return meta;
     }
@@ -118,6 +127,7 @@ export class MetadataStorage {
         const meta = this.find(entityName);
         if (meta) {
             this.#metadataMap.delete(meta.class);
+            this.#tableNameMap = undefined;
             delete this.#idMap[meta._id];
             delete this.#uniqueNameMap[meta.uniqueName];
             delete this.#classNameMap[meta.className];
@@ -145,6 +155,23 @@ export class MetadataStorage {
     getByClassName(className, validate = true) {
         return this.validate(this.#classNameMap[className], className, validate);
     }
+    /**
+     * Returns the first registered metadata with the given table name, in registration order (entities sharing
+     * a table, like STI children, resolve to the one registered first). The index is built on first use, as table
+     * names are only final once discovery has finished.
+     * @internal
+     */
+    getByTableName(tableName) {
+        if (!this.#tableNameMap) {
+            this.#tableNameMap = new Map();
+            for (const meta of this.#metadataMap.values()) {
+                if (!this.#tableNameMap.has(meta.tableName)) {
+                    this.#tableNameMap.set(meta.tableName, meta);
+                }
+            }
+        }
+        return this.#tableNameMap.get(tableName);
+    }
     /** Returns metadata by unique name, optionally throwing if not found. */
     getByUniqueName(uniqueName, validate = true) {
         return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.2-dev.27",
+  "version": "7.2.2-dev.29",
   "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/typings.d.ts

@@ -1255,6 +1255,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
+    /** @internal name that does not depend on module evaluation order (unlike `_id`), used to key `compiledFunctions` */
+    compiledName?: string;
 }
 /** Options for `ISchemaGenerator.create()`. */
 export interface CreateSchemaOptions {

package/utils/EntityComparator.js

@@ -95,7 +95,7 @@ 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 fnKey = `pkGetter-${meta.uniqueName}`;
+        const fnKey = `pkGetter-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkGetters.set(meta, pkSerializer);
         return pkSerializer;
@@ -147,7 +147,7 @@ export 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 fnKey = `pkGetterConverted-${meta.uniqueName}`;
+        const fnKey = `pkGetterConverted-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
@@ -206,7 +206,7 @@ export class EntityComparator {
             }
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkSerializer-${meta.uniqueName}`;
+        const fnKey = `pkSerializer-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
@@ -236,7 +236,7 @@ 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 fnKey = `snapshotGenerator-${meta.compiledName}`;
         const snapshotGenerator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
@@ -420,7 +420,7 @@ export class EntityComparator {
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined${knownKeysGuard}) 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 fnKey = `resultMapper-${meta.uniqueName}`;
+        const fnKey = `resultMapper-${meta.compiledName}`;
         const resultMapper = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#mappers.set(meta, resultMapper);
         return resultMapper;
@@ -703,7 +703,7 @@ 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 fnKey = `comparator-${meta.uniqueName}`;
+        const fnKey = `comparator-${meta.compiledName}`;
         const comparator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#comparators.set(meta, comparator);
         return comparator;

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.2.2-dev.27';
+    static #ORM_VERSION = '7.2.2-dev.29';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;