@mikro-orm/core 7.0.0-dev.114 → 7.0.0-dev.116

package/utils/DataloaderUtils.js

@@ -11,7 +11,7 @@ export class DataloaderUtils {
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
         const map = new Map();
         for (const [ref, opts] of refsWithOpts) {
-            /* The key is a combination of the className and a stringified version if the load options because we want
+            /* The key is a combination of the uniqueName (a unique table name based identifier) and a stringified version if the load options because we want
                to map each combination of entities/options into separate find queries in order to return accurate results.
                This could be further optimized finding the "lowest common denominator" among the different options
                for each Entity and firing a single query for each Entity instead of Entity+options combination.
@@ -24,7 +24,7 @@ export class DataloaderUtils {
                Thus such approach should probably be configurable, if not opt-in.
                NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
                to implement this but not necessarily faster.  */
-            const key = `${helper(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
@@ -42,9 +42,10 @@ export class DataloaderUtils {
         return async (refsWithOpts) => {
             const groupedIdsMap = DataloaderUtils.groupPrimaryKeysByEntityAndOpts(refsWithOpts);
             const promises = Array.from(groupedIdsMap).map(([key, idsSet]) => {
-                const className = key.substring(0, key.indexOf('|'));
+                const uniqueName = key.substring(0, key.indexOf('|'));
                 const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-                return em.find(className, Array.from(idsSet), opts);
+                const meta = em.getMetadata().getByUniqueName(uniqueName);
+                return em.find(meta.class, Array.from(idsSet), opts);
             });
             await Promise.all(promises);
             /* Instead of assigning each find result to the original reference we use a shortcut
@@ -70,7 +71,7 @@ export class DataloaderUtils {
             The value is another Map which we can use to filter the find query to get results pertaining to the collections that have been dataloaded:
             its keys are the props we are going to filter to and its values are the corresponding PKs.
             */
-            const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let filterMap = entitiesMap.get(key); // We are going to use this map to filter the entities pertaining to the collections that have been dataloaded.
             if (filterMap == null) {
                 filterMap = new Map();
@@ -97,9 +98,10 @@ export class DataloaderUtils {
      */
     static entitiesAndOptsMapToQueries(entitiesAndOptsMap, em) {
         return Array.from(entitiesAndOptsMap, async ([key, filterMap]) => {
-            const className = key.substring(0, key.indexOf('|'));
+            const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-            const res = await em.find(className, opts?.where != null && Object.keys(opts.where).length > 0 ?
+            const meta = em.getMetadata().getByUniqueName(uniqueName);
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0 ?
                 {
                     $and: [
                         {
@@ -121,7 +123,7 @@ export class DataloaderUtils {
                     ...(opts.populate === false ? [] : opts.populate ?? []),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
-                    prop => em.getMetadata(className).properties[prop]?.ref !== true),
+                    prop => meta.properties[prop]?.ref !== true),
                 ],
             });
             return [key, res];
@@ -164,7 +166,7 @@ export class DataloaderUtils {
             // We need to filter the results in order to map each input collection
             // to a subset of each query matching the collection items.
             return collsWithOpts.map(([col, opts]) => {
-                const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
@@ -183,7 +185,7 @@ export class DataloaderUtils {
         return async (collsWithOpts) => {
             const groups = new Map();
             for (const [col, opts] of collsWithOpts) {
-                const key = `${col.property.targetMeta.className}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
                 const value = groups.get(key) ?? [];
                 value.push([col, opts ?? {}]);
                 groups.set(key, value);
@@ -198,7 +200,7 @@ export class DataloaderUtils {
                 const owners = group.map(c => c[0].owner);
                 const $or = [];
                 // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
-                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
+                const alias = em.config.getNamingStrategy().aliasName(Utils.className(prop.pivotEntity), 0);
                 const fk = `${alias}.${Utils.getPrimaryKeyHash(prop.joinColumns)}`;
                 for (const c of group) {
                     $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });

package/utils/EntityComparator.d.ts

@@ -20,19 +20,19 @@ export declare class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>, options?: {
+    diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
         includeInverseSides?: boolean;
     }): EntityData<T>;
-    matching<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): boolean;
+    matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
      * References will be mapped to primary keys, collections to arrays of primary keys.
      */
-    prepareEntity<T>(entity: T): EntityData<T>;
+    prepareEntity<T extends object>(entity: T): EntityData<T>;
     /**
      * Maps database columns to properties.
      */
-    mapResult<T>(entityName: string, result: EntityDictionary<T>): EntityData<T>;
+    mapResult<T>(meta: EntityMetadata<T>, result: EntityDictionary<T>): EntityData<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
@@ -64,7 +64,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getResultMapper<T>(entityName: string): ResultMapper<T>;
+    getResultMapper<T>(meta: EntityMetadata<T>): ResultMapper<T>;
     private getPropertyCondition;
     private getEmbeddedArrayPropertySnapshot;
     /**
@@ -78,7 +78,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityComparator<T extends object>(entityName: string): Comparator<T>;
+    getEntityComparator<T extends object>(entityName: EntityName<T>): Comparator<T>;
     private getGenericComparator;
     private getPropertyComparator;
     private wrap;

package/utils/EntityComparator.js

@@ -3,6 +3,7 @@ import { ReferenceKind } from '../enums.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';
 export class EntityComparator {
     metadata;
     platform;
@@ -33,21 +34,21 @@ export class EntityComparator {
      * References will be mapped to primary keys, collections to arrays of primary keys.
      */
     prepareEntity(entity) {
-        const generator = this.getSnapshotGenerator(entity.constructor.name);
+        const generator = this.getSnapshotGenerator(entity.constructor);
         return Utils.callCompiledFunction(generator, entity);
     }
     /**
      * Maps database columns to properties.
      */
-    mapResult(entityName, result) {
-        const mapper = this.getResultMapper(entityName);
+    mapResult(meta, result) {
+        const mapper = this.getResultMapper(meta);
         return Utils.callCompiledFunction(mapper, result);
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
-        const exists = this.pkGetters.get(meta.className);
+        const exists = this.pkGetters.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -90,14 +91,14 @@ export class EntityComparator {
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
         const pkSerializer = Utils.createFunction(context, code);
-        this.pkGetters.set(meta.className, pkSerializer);
+        this.pkGetters.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetterConverted(meta) {
-        const exists = this.pkGettersConverted.get(meta.className);
+        const exists = this.pkGettersConverted.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -140,14 +141,14 @@ 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 pkSerializer = Utils.createFunction(context, code);
-        this.pkGettersConverted.set(meta.className, pkSerializer);
+        this.pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkSerializer(meta) {
-        const exists = this.pkSerializers.get(meta.className);
+        const exists = this.pkSerializers.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -192,19 +193,18 @@ export class EntityComparator {
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
         const pkSerializer = Utils.createFunction(context, code);
-        this.pkSerializers.set(meta.className, pkSerializer);
+        this.pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator(entityName) {
-        entityName = Utils.className(entityName);
-        const exists = this.snapshotGenerators.get(entityName);
+        const meta = this.metadata.find(entityName);
+        const exists = this.snapshotGenerators.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
         context.set('clone', clone);
@@ -222,7 +222,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 snapshotGenerator = Utils.createFunction(context, code);
-        this.snapshotGenerators.set(entityName, snapshotGenerator);
+        this.snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
     }
     /**
@@ -272,12 +272,11 @@ export class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getResultMapper(entityName) {
-        const exists = this.mappers.get(entityName);
+    getResultMapper(meta) {
+        const exists = this.mappers.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.get(entityName);
         const lines = [];
         const context = new Map();
         const tz = this.platform.getTimezone();
@@ -336,9 +335,9 @@ export class EntityComparator {
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
                         const item = parseJsonSafe(data);
                         if (Array.isArray(item)) {
-                            return item.map(row => row == null ? row : this.getResultMapper(prop.type)(row));
+                            return item.map(row => row == null ? row : this.getResultMapper(prop.targetMeta)(row));
                         }
-                        return item == null ? item : this.getResultMapper(prop.type)(item);
+                        return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
                     lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
                     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])});`);
@@ -371,7 +370,7 @@ export class EntityComparator {
         const code = `// compiled mapper for entity ${meta.className}\n`
             + `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
         const resultMapper = Utils.createFunction(context, code);
-        this.mappers.set(entityName, resultMapper);
+        this.mappers.set(meta, resultMapper);
         return resultMapper;
     }
     getPropertyCondition(path) {
@@ -519,8 +518,11 @@ export class EntityComparator {
                     return val;
                 };
                 context.set('toArray', toArray);
+                context.set('EntityIdentifier', EntityIdentifier);
                 ret += `    if (entity${entityKey} === null) {\n`;
                 ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (entity${entityKey}?.__helper.__identifier && !entity${entityKey}.__helper.hasPrimaryKey()) {\n`;
+                ret += `      ret${dataKey} = entity${entityKey}?.__helper.__identifier;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      ret${dataKey} = toArray(entity${entityKey}.__helper.getPrimaryKey(true));\n`;
                 ret += `    }\n`;
@@ -544,11 +546,11 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getEntityComparator(entityName) {
-        const exists = this.comparators.get(entityName);
+        const meta = this.metadata.find(entityName);
+        const exists = this.comparators.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
         context.set('compareArrays', compareArrays);
@@ -570,7 +572,7 @@ export class EntityComparator {
         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 comparator = Utils.createFunction(context, code);
-        this.comparators.set(entityName, comparator);
+        this.comparators.set(meta, comparator);
         return comparator;
     }
     getGenericComparator(prop, cond) {
@@ -586,12 +588,12 @@ export class EntityComparator {
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();
         if (prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED) {
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             if (meta2.primaryKeys.length > 1) {
                 type = 'array';
             }
             else {
-                type = meta2.properties[meta2.primaryKeys[0]].type.toLowerCase();
+                type = meta2.getPrimaryProp().type.toLowerCase();
             }
         }
         if (prop.customType) {

package/utils/QueryHelper.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
+import type { Dictionary, EntityMetadata, EntityName, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
@@ -14,9 +14,9 @@ export declare class QueryHelper {
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
-    static getActiveFilters(entityName: string, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
+    static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
     static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
-    static isFilterActive(entityName: string, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
+    static isFilterActive<T>(meta: EntityMetadata<T>, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     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;
@@ -25,11 +25,11 @@ export declare class QueryHelper {
 }
 interface ProcessWhereOptions<T> {
     where: FilterQuery<T>;
-    entityName: string;
+    entityName: EntityName<T>;
     metadata: MetadataStorage;
     platform: Platform;
     aliased?: boolean;
-    aliasMap?: Dictionary<string>;
+    aliasMap?: Dictionary<EntityName>;
     convertCustomTypes?: boolean;
     root?: boolean;
     type?: 'where' | 'orderBy';

package/utils/QueryHelper.js

@@ -98,7 +98,7 @@ export class QueryHelper {
             }));
         }
         Object.keys(where).forEach(k => {
-            const meta2 = metadata.find(meta.properties[k]?.type) || meta;
+            const meta2 = metadata.find(meta.properties[k]?.targetMeta?.class) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
                 where[k] = Utils.getPrimaryKeyValues(where[k], meta2, true);
             }
@@ -126,7 +126,7 @@ export class QueryHelper {
             where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         if (Array.isArray(where) && root) {
-            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
+            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : Utils.className(entityName);
             let cond = { [rootPrimaryKey]: { $in: where } };
             // @ts-ignore
             // detect tuple comparison, use `$or` in case the number of constituents don't match
@@ -175,7 +175,7 @@ export class QueryHelper {
                 o[key] = QueryHelper.processWhere({
                     ...options,
                     where: value,
-                    entityName: prop?.type ?? entityName,
+                    entityName: prop?.targetMeta?.class ?? entityName,
                     root: false,
                 });
             }
@@ -185,7 +185,7 @@ export class QueryHelper {
             return o;
         }, {});
     }
-    static getActiveFilters(entityName, options, filters) {
+    static getActiveFilters(meta, options, filters) {
         if (options === false) {
             return [];
         }
@@ -197,7 +197,7 @@ export class QueryHelper {
             Object.keys(options).forEach(filter => opts[filter] = options[filter]);
         }
         return Object.keys(filters)
-            .filter(f => QueryHelper.isFilterActive(entityName, f, filters[f], opts))
+            .filter(f => QueryHelper.isFilterActive(meta, f, filters[f], opts))
             .map(f => {
             filters[f].name = f;
             return filters[f];
@@ -221,8 +221,8 @@ export class QueryHelper {
         }
         return Utils.mergeConfig({}, propFilters, options);
     }
-    static isFilterActive(entityName, filterName, filter, options) {
-        if (filter.entity && !filter.entity.includes(entityName)) {
+    static isFilterActive(meta, filterName, filter, options) {
+        if (filter.entity && !filter.entity.includes(meta.className)) {
             return false;
         }
         if (options[filterName] === false) {

package/utils/TransactionManager.js

@@ -161,7 +161,7 @@ export class TransactionManager {
             const wrapped = helper(entity);
             const meta = wrapped.__meta;
             // eslint-disable-next-line dot-notation
-            const parentEntity = parentUoW.getById(meta.className, wrapped.getPrimaryKey(), parent['_schema'], true);
+            const parentEntity = parentUoW.getById(meta.class, wrapped.getPrimaryKey(), parent['_schema'], true);
             if (parentEntity && parentEntity !== entity) {
                 const parentWrapped = helper(parentEntity);
                 parentWrapped.__data = wrapped.__data;

package/utils/Utils.d.ts

@@ -110,7 +110,7 @@ export declare class Utils {
     /**
      * Gets string name of given class.
      */
-    static className<T>(classOrName: EntityName<T>): string;
+    static className<T>(classOrName: string | EntityName<T>): string;
     static extractChildElements(items: string[], prefix: string, allSymbol?: string): string[];
     /**
      * Tries to detect TypeScript support.

package/utils/Utils.js

@@ -35,7 +35,6 @@ export function compareObjects(a, b) {
     }
     /* v8 ignore next */
     if ((typeof a === 'function' && typeof b === 'function') ||
-        (typeof a === 'object' && a.client && ['Ref', 'Raw'].includes(a.constructor.name) && typeof b === 'object' && b.client && ['Ref', 'Raw'].includes(b.constructor.name)) || // knex qb
         (a instanceof RegExp && b instanceof RegExp) ||
         (a instanceof String && b instanceof String) ||
         (a instanceof Number && b instanceof Number)) {
@@ -124,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.114';
+    static #ORM_VERSION = '7.0.0-dev.116';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/env-vars.js

@@ -60,7 +60,6 @@ export function loadEnvironmentVars() {
     read1('warnWhenNoEntities', bool);
     read1('checkDuplicateTableNames', bool);
     read1('checkDuplicateFieldNames', bool);
-    read1('checkDuplicateEntities', bool);
     read1('checkNonPersistentCompositeProps', bool);
     read1('inferDefaultValues', bool);
     read1('tsConfigPath');