@mikro-orm/core 7.3.0-dev.4 → 7.3.0-dev.6

package/hydration/ObjectHydrator.js

@@ -404,7 +404,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/MetadataDiscovery.js

@@ -1461,7 +1461,8 @@ export class MetadataDiscovery {
                     }
                 }
                 rootProp.stiFieldNameMap[meta.discriminatorValue] = prop.fieldNames[0];
-                rootProp.stiFieldNames.push(...prop.fieldNames);
+                // subtypes that only differ in type share the column
+                rootProp.stiFieldNames = Utils.unique([...rootProp.stiFieldNames, ...prop.fieldNames]);
                 newProp.nullable = true;
                 newProp.name = name;
                 newProp.hydrate = false;

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.3.0-dev.4",
+  "version": "7.3.0-dev.6",
   "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

@@ -1259,6 +1259,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;
@@ -350,14 +350,27 @@ export class EntityComparator {
                 if (prop.embedded && (meta.embeddable || meta.properties[prop.embedded[0]].object)) {
                     continue;
                 }
+                let defined = `typeof ${this.propName(prop.fieldNames[0])} !== 'undefined'`;
+                // STI subtypes with conflicting columns share the property, so another subtype's null column must not override it
+                if (prop.renamedFrom) {
+                    lines.push(`${padding}  ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    defined = `${this.propName(prop.fieldNames[0])} != null`;
+                    // a column shared with a differently typed subtype is left for each subtype's hydrator to convert
+                    if (meta.props.some(p => p !== prop && p.name === prop.name && p.fieldNames?.[0] === prop.fieldNames[0])) {
+                        lines.push(`${padding}  if (${defined}) {`);
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
+                        lines.push(`${padding}  }`);
+                        continue;
+                    }
+                }
                 if (prop.runtimeType === 'boolean') {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     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') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     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;`);
@@ -372,13 +385,13 @@ export class EntityComparator {
                         }
                         return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     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}  if (${defined}) {`);
                     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}  }`);
@@ -420,7 +433,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 +716,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/QueryHelper.d.ts

@@ -46,6 +46,8 @@ export declare class QueryHelper {
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     /** @internal Splits a polymorphic target key like `imageable[Article]` into the property and target class names. */
     static splitPolymorphicKey(key: string): [string, string?];
+    /** @internal Resolves the targets of a polymorphic target key like `imageable[Article]` or `imageable[Product,Article]`. */
+    static findTargetMetas(prop: EntityProperty | null | undefined, key: string): EntityMetadata[];
     /** @internal Resolves the target entity of a condition key, including polymorphic target keys like `imageable[Article]`. */
     static findTargetMeta(prop: EntityProperty | null | undefined, key: string): EntityMetadata | undefined;
     /**
@@ -54,6 +56,12 @@ export declare class QueryHelper {
      * when more targets match. The first target alone keeps the regular relation join.
      */
     private static splitPolymorphicConditions;
+    /**
+     * Routes ordering by properties of polymorphic to-one relations to the targets that define them, e.g.
+     * `{ imageable: { name: 'asc' } }` becomes `{ 'imageable[Product,Article]': { name: 'asc' } }`, ordered by
+     * the first non-null value. Nested relations and formulas are ordered via the first target defining them.
+     */
+    private static splitPolymorphicOrderBy;
     /** Property names used in a condition, including those nested in group operators. */
     private static collectConditionKeys;
     static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];

package/utils/QueryHelper.js

@@ -262,8 +262,10 @@ export class QueryHelper {
         if (!Utils.isPlainObject(where)) {
             return where;
         }
-        if (meta && options.type !== 'orderBy') {
-            where = QueryHelper.splitPolymorphicConditions(meta, where);
+        if (meta) {
+            where = (options.type === 'orderBy'
+                ? QueryHelper.splitPolymorphicOrderBy(meta, where)
+                : QueryHelper.splitPolymorphicConditions(meta, where));
         }
         return Utils.getObjectQueryKeys(where).reduce((o, key) => {
             let value = where[key];
@@ -328,13 +330,18 @@ export class QueryHelper {
     }
     /** @internal Splits a polymorphic target key like `imageable[Article]` into the property and target class names. */
     static splitPolymorphicKey(key) {
-        const match = /^(\w+)\[(\w+)]$/.exec(key);
+        const match = /^(\w+)\[([\w,]+)]$/.exec(key);
         return match ? [match[1], match[2]] : [key];
     }
+    /** @internal Resolves the targets of a polymorphic target key like `imageable[Article]` or `imageable[Product,Article]`. */
+    static findTargetMetas(prop, key) {
+        const [, targetNames] = QueryHelper.splitPolymorphicKey(key);
+        const targets = targetNames?.split(',').map(name => prop?.polymorphTargets?.find(t => t.className === name));
+        return targets?.every(Boolean) ? targets : [];
+    }
     /** @internal Resolves the target entity of a condition key, including polymorphic target keys like `imageable[Article]`. */
     static findTargetMeta(prop, key) {
-        const [, targetName] = QueryHelper.splitPolymorphicKey(key);
-        return targetName ? prop?.polymorphTargets?.find(t => t.className === targetName) : prop?.targetMeta;
+        return QueryHelper.splitPolymorphicKey(key)[1] ? QueryHelper.findTargetMetas(prop, key)[0] : prop?.targetMeta;
     }
     /**
      * Routes conditions on polymorphic to-one relations to the targets that define all the queried properties,
@@ -373,6 +380,34 @@ export class QueryHelper {
         }
         return ret;
     }
+    /**
+     * Routes ordering by properties of polymorphic to-one relations to the targets that define them, e.g.
+     * `{ imageable: { name: 'asc' } }` becomes `{ 'imageable[Product,Article]': { name: 'asc' } }`, ordered by
+     * the first non-null value. Nested relations and formulas are ordered via the first target defining them.
+     */
+    static splitPolymorphicOrderBy(meta, orderBy) {
+        const ret = {};
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
+            const prop = meta.properties[key];
+            const value = orderBy[key];
+            if (!prop?.polymorphTargets ||
+                ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) ||
+                !Utils.isPlainObject(value)) {
+                ret[key] = value;
+                continue;
+            }
+            for (const field of Utils.getObjectQueryKeys(value)) {
+                const found = prop.polymorphTargets.filter(target => field in target.properties);
+                const sharedPK = found.length === prop.polymorphTargets.length && found.every(target => target.primaryKeys.includes(field));
+                const single = Utils.isPlainObject(value[field]) || found.some(target => target.properties[field].formula);
+                const targets = found.length === 0 ? [prop.targetMeta] : single ? [found[0]] : found;
+                // shared PKs are ordered by the FK column without a join
+                const targetKey = sharedPK ? key : `${key}[${targets.map(target => target.className).join(',')}]`;
+                ret[targetKey] = { ...ret[targetKey], [field]: value[field] };
+            }
+        }
+        return ret;
+    }
     /** Property names used in a condition, including those nested in group operators. */
     static collectConditionKeys(payload) {
         return Object.keys(payload).flatMap(k => {

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