@mikro-orm/core 7.0.0-dev.113 → 7.0.0-dev.115

package/errors.js

@@ -1,4 +1,5 @@
 import { inspect } from './logging/inspect.js';
+import { Utils } from '@mikro-orm/core';
 export class ValidationError extends Error {
     entity;
     constructor(message, entity) {
@@ -46,7 +47,7 @@ export class ValidationError extends Error {
         return new ValidationError(err);
     }
     static invalidPropertyName(entityName, invalid) {
-        return new ValidationError(`Entity '${entityName}' does not have property '${invalid}'`);
+        return new ValidationError(`Entity '${Utils.className(entityName)}' does not have property '${invalid}'`);
     }
     static invalidCollectionValues(entityName, propName, invalid) {
         return new ValidationError(`Invalid collection values provided for '${entityName}.${propName}' in ${entityName}.assign(): ${inspect(invalid)}`);
@@ -92,14 +93,14 @@ export class ValidationError extends Error {
     static cannotUseGlobalContext() {
         return new ValidationError('Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance\'s identity map, use `allowGlobalContext` configuration option or `fork()` instead.');
     }
-    static cannotUseOperatorsInsideEmbeddables(className, propName, payload) {
-        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
+    static cannotUseOperatorsInsideEmbeddables(entityName, propName, payload) {
+        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
     }
-    static cannotUseGroupOperatorsInsideScalars(className, propName, payload) {
-        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
+    static cannotUseGroupOperatorsInsideScalars(entityName, propName, payload) {
+        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
     }
-    static invalidEmbeddableQuery(className, propName, embeddableType) {
-        return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
+    static invalidEmbeddableQuery(entityName, propName, embeddableType) {
+        return new ValidationError(`Invalid query for entity '${Utils.className(entityName)}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
     }
     /* v8 ignore next */
     static invalidQueryCondition(cond) {
@@ -169,8 +170,8 @@ export class MetadataError extends ValidationError {
         const prop = meta.properties[meta.versionProperty];
         return new MetadataError(`Version property ${meta.className}.${prop.name} has unsupported type '${prop.type}'. Only 'number' and 'Date' are allowed.`);
     }
-    static fromUnknownEntity(className, source) {
-        return new MetadataError(`Entity '${className}' was not discovered, please make sure to provide it in 'entities' array when initializing the ORM (used in ${source})`);
+    static fromUnknownEntity(entityName, source) {
+        return new MetadataError(`Entity '${entityName}' was not discovered, please make sure to provide it in 'entities' array when initializing the ORM (used in ${source})`);
     }
     static noEntityDiscovered() {
         return new MetadataError('No entities were discovered');
@@ -178,11 +179,11 @@ export class MetadataError extends ValidationError {
     static onlyAbstractEntitiesDiscovered() {
         return new MetadataError('Only abstract entities were discovered, maybe you forgot to use @Entity() decorator? This can also happen when you have multiple `@mikro-orm/core` packages installed side by side.');
     }
-    static duplicateEntityDiscovered(paths, subject = 'entity names') {
-        return new MetadataError(`Duplicate ${subject} are not allowed: ${paths.join(', ')}`);
+    static duplicateEntityDiscovered(paths) {
+        return new MetadataError(`Duplicate table names are not allowed: ${paths.join(', ')}`);
     }
-    static duplicateFieldName(className, names) {
-        return new MetadataError(`Duplicate fieldNames are not allowed: ${names.map(n => `${className}.${n[0]} (fieldName: '${n[1]}')`).join(', ')}`);
+    static duplicateFieldName(entityName, names) {
+        return new MetadataError(`Duplicate fieldNames are not allowed: ${names.map(n => `${Utils.className(entityName)}.${n[0]} (fieldName: '${n[1]}')`).join(', ')}`);
     }
     static multipleDecorators(entityName, propertyName) {
         return new MetadataError(`Multiple property decorators used on '${entityName}.${propertyName}' property`);

package/hydration/ObjectHydrator.js

@@ -3,7 +3,7 @@ import { Collection } from '../entity/Collection.js';
 import { Reference, ScalarReference } from '../entity/Reference.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export class ObjectHydrator extends Hydrator {
     hydrators = {
         'full~true': new Map(),
@@ -39,7 +39,7 @@ export class ObjectHydrator extends Hydrator {
      */
     getEntityHydrator(meta, type, normalizeAccessors = false) {
         const key = `${type}~${normalizeAccessors}`;
-        const exists = this.hydrators[key].get(meta.className);
+        const exists = this.hydrators[key].get(meta.class);
         if (exists) {
             return exists;
         }
@@ -52,14 +52,14 @@ export class ObjectHydrator extends Hydrator {
         const registerCustomType = (prop, convertorKey, method, context) => {
             context.set(`${method}_${convertorKey}`, (val) => {
                 /* v8 ignore next */
-                if (RawQueryFragment.isKnownFragment(val)) {
+                if (Raw.isKnownFragment(val)) {
                     return val;
                 }
                 return prop.customType[method](val, this.platform, { mode: 'serialization' });
             });
             return convertorKey;
         };
-        const hydrateScalar = (prop, object, path, dataKey) => {
+        const hydrateScalar = (prop, path, dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const tz = this.platform.getTimezone();
             const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
@@ -135,23 +135,25 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`  if (data${dataKey} === null) {\n    entity${entityKey} = ${nullVal};`);
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             ret.push(`    if (isPrimaryKey(data${dataKey}, true)) {`);
+            const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+            context.set(targetKey, prop.targetMeta.class);
             if (prop.ref) {
-                ret.push(`      entity${entityKey} = Reference.create(factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema }));`);
+                ret.push(`      entity${entityKey} = Reference.create(factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema }));`);
             }
             else {
-                ret.push(`      entity${entityKey} = factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema });`);
+                ret.push(`      entity${entityKey} = factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema });`);
             }
             ret.push(`    } else if (data${dataKey} && typeof data${dataKey} === 'object') {`);
             if (prop.ref) {
-                ret.push(`      entity${entityKey} = Reference.create(factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema }));`);
+                ret.push(`      entity${entityKey} = Reference.create(factory.${method}(${targetKey}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema }));`);
             }
             else {
-                ret.push(`      entity${entityKey} = factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema });`);
+                ret.push(`      entity${entityKey} = factory.${method}(${targetKey}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema });`);
             }
             ret.push(`    }`);
             ret.push(`  }`);
             if (prop.kind === ReferenceKind.ONE_TO_ONE) {
-                const meta2 = this.metadata.get(prop.type);
+                const meta2 = this.metadata.get(prop.targetMeta.class);
                 const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
                 if (prop2 && !prop2.mapToPk) {
                     ret.push(`  if (data${dataKey} && entity${entityKey} && !entity${entityKey}.${this.safeKey(prop2.name)}) {`);
@@ -169,7 +171,7 @@ export class ObjectHydrator extends Hydrator {
         };
         const hydrateToMany = (prop, dataKey, entityKey) => {
             const ret = [];
-            ret.push(...this.createCollectionItemMapper(prop));
+            ret.push(...this.createCollectionItemMapper(prop, context));
             ret.push(`  if (data${dataKey} && !Array.isArray(data${dataKey}) && typeof data${dataKey} === 'object') {`);
             ret.push(`    data${dataKey} = [data${dataKey}];`);
             ret.push(`  }`);
@@ -252,10 +254,11 @@ export class ObjectHydrator extends Hydrator {
                 prop.targetMeta.polymorphs.forEach(childMeta => {
                     const childProp = prop.embeddedProps[prop.targetMeta.discriminatorColumn];
                     const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    context.set(childMeta.className, childMeta.class);
                     // weak comparison as we can have numbers that might have been converted to strings due to being object keys
                     ret.push(`    if (data${childDataKey} == '${childMeta.discriminatorValue}') {`);
                     ret.push(`      if (entity${entityKey} == null) {`);
-                    ret.push(`        entity${entityKey} = factory.createEmbeddable('${childMeta.className}', embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
+                    ret.push(`        entity${entityKey} = factory.createEmbeddable(${childMeta.className}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                     ret.push(`      }`);
                     meta.props
                         .filter(p => p.embedded?.[0] === prop.name)
@@ -275,8 +278,10 @@ export class ObjectHydrator extends Hydrator {
                 });
             }
             else {
+                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+                context.set(targetKey, prop.targetMeta.class);
                 ret.push(`    if (entity${entityKey} == null) {`);
-                ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
+                ret.push(`      entity${entityKey} = factory.createEmbeddable(${targetKey}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                 ret.push(`    }`);
                 meta.props
                     .filter(p => p.embedded?.[0] === prop.name)
@@ -334,7 +339,7 @@ export class ObjectHydrator extends Hydrator {
                 }
             }
             else { // ReferenceKind.SCALAR
-                ret.push(...hydrateScalar(prop, object, path, dataKey));
+                ret.push(...hydrateScalar(prop, path, dataKey));
             }
             if (this.config.get('forceUndefined')) {
                 ret.push(`  if (data${dataKey} === null) entity${entityKey} = undefined;`);
@@ -348,11 +353,11 @@ export class ObjectHydrator extends Hydrator {
             + `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n`
             + `${lines.join('\n')}\n}`;
         const hydrator = Utils.createFunction(context, code);
-        this.hydrators[key].set(meta.className, hydrator);
+        this.hydrators[key].set(meta.class, hydrator);
         return hydrator;
     }
-    createCollectionItemMapper(prop) {
-        const meta = this.metadata.get(prop.type);
+    createCollectionItemMapper(prop, context) {
+        const meta = this.metadata.get(prop.targetMeta.class);
         const lines = [];
         lines.push(`  const createCollectionItem_${this.safeKey(prop.name)} = (value, entity) => {`);
         const prop2 = prop.targetMeta.properties[prop.mappedBy];
@@ -361,9 +366,11 @@ export class ObjectHydrator extends Hydrator {
             lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
             lines.push(`    }`);
         }
-        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference('${prop.type}', value, { convertCustomTypes, schema, normalizeAccessors, merge: true });`);
+        const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+        context.set(targetKey, prop.targetMeta.class);
+        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference(${targetKey}, value, { convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`    if (value && value.__entity) return value;`);
-        lines.push(`    return factory.create('${prop.type}', value, { newEntity, convertCustomTypes, schema, normalizeAccessors, merge: true });`);
+        lines.push(`    return factory.create(${targetKey}, value, { newEntity, convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`  }`);
         return lines;
     }

package/metadata/EntitySchema.d.ts

@@ -6,12 +6,12 @@ type TypeType = string | NumberConstructor | StringConstructor | BooleanConstruc
 type TypeDef<Target> = {
     type: TypeType;
 } | {
-    entity: string | (() => string | EntityName<Target>);
+    entity: () => EntityName<Target>;
 };
 type EmbeddedTypeDef<Target> = {
     type: TypeType;
 } | {
-    entity: string | (() => string | EntityName<Target> | EntityName<Target>[]);
+    entity: () => EntityName<Target> | EntityName<Target>[];
 };
 export type EntitySchemaProperty<Target, Owner> = ({
     kind: ReferenceKind.MANY_TO_ONE | 'm:1';
@@ -63,10 +63,10 @@ export declare class EntitySchema<Entity = any, Base = never> {
     addIndex<Key extends string>(options: IndexOptions<Entity, Key>): void;
     addUnique<Key extends string>(options: UniqueOptions<Entity, Key>): void;
     setCustomRepository(repository: () => Constructor): void;
-    setExtends(base: EntityName<any>): void;
-    setClass(proto: EntityClass<Entity>): void;
+    setExtends(base: EntityName): void;
+    setClass(cls: EntityClass<Entity>): void;
     get meta(): EntityMetadata<Entity>;
-    get name(): EntityName<Entity>;
+    get name(): string | EntityName<Entity>;
     get tableName(): string;
     get properties(): Record<string, any>;
     /**

package/metadata/EntitySchema.js

@@ -10,7 +10,7 @@ export class EntitySchema {
      * so we can use the class in `entities` option just like the EntitySchema instance.
      */
     static REGISTRY = new Map();
-    _meta = new EntityMetadata();
+    _meta;
     internal = false;
     initialized = false;
     constructor(meta) {
@@ -18,11 +18,14 @@ export class EntitySchema {
         if (meta.name) {
             meta.abstract ??= false;
         }
+        this._meta = new EntityMetadata({
+            className: meta.name,
+            ...meta,
+        });
+        this._meta.root ??= this._meta;
         if (meta.class && !meta.internal) {
             EntitySchema.REGISTRY.set(meta.class, this);
         }
-        Object.assign(this._meta, { className: meta.name }, meta);
-        this._meta.root ??= this._meta;
     }
     static fromMetadata(meta) {
         const schema = new EntitySchema({ ...meta, internal: true });
@@ -31,7 +34,7 @@ export class EntitySchema {
     }
     addProperty(name, type, options = {}) {
         this.renameCompositeOptions(name, options);
-        const prop = { name, kind: ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
+        const prop = { name, kind: ReferenceKind.SCALAR, ...options, ...this.normalizeType(options, type) };
         if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
         }
@@ -81,8 +84,8 @@ export class EntitySchema {
         }
         this._meta.properties[name] = {
             name,
-            type: this.normalizeType(options),
             kind: ReferenceKind.EMBEDDED,
+            ...this.normalizeType(options),
             ...options,
         };
     }
@@ -147,19 +150,20 @@ export class EntitySchema {
     setExtends(base) {
         this._meta.extends = base;
     }
-    setClass(proto) {
-        const sameClass = this._meta.className === proto.name;
-        this._meta.class = proto;
-        this._meta.prototype = proto.prototype;
-        this._meta.className = proto.name;
+    setClass(cls) {
+        const sameClass = this._meta.className === cls.name;
+        this._meta.class = cls;
+        this._meta.prototype = cls.prototype;
+        this._meta.className = this._meta.name ?? cls.name;
         if (!sameClass || !this._meta.constructorParams) {
-            this._meta.constructorParams = Utils.getConstructorParams(proto);
+            this._meta.constructorParams = Utils.getConstructorParams(cls);
         }
         if (!this.internal) {
-            EntitySchema.REGISTRY.set(proto, this);
+            EntitySchema.REGISTRY.set(cls, this);
         }
-        if (Object.getPrototypeOf(proto) !== BaseEntity) {
-            this._meta.extends = this._meta.extends || Object.getPrototypeOf(proto).name || undefined;
+        const base = Object.getPrototypeOf(cls);
+        if (base !== BaseEntity) {
+            this._meta.extends ??= base.name ? base : undefined;
         }
     }
     get meta() {
@@ -181,11 +185,6 @@ export class EntitySchema {
         if (this.initialized) {
             return this;
         }
-        if (!this._meta.class) {
-            const name = this.name;
-            this._meta.class = ({ [name]: class {
-                } })[name];
-        }
         this.setClass(this._meta.class);
         if (this._meta.abstract && !this._meta.discriminatorColumn) {
             delete this._meta.name;
@@ -259,12 +258,15 @@ export class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
+            /* v8 ignore next */
             if (typeof options.entity === 'string') {
-                type = options.type = options.entity;
+                throw new Error(`Relation target needs to be an entity class or EntitySchema instance, string '${options.entity}' given instead for ${this._meta.className}.${options.name}.`);
             }
             else if (options.entity) {
                 const tmp = options.entity();
                 type = options.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
+                const target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
+                return { type, target };
             }
         }
         if (type instanceof Function) {
@@ -273,7 +275,7 @@ export class EntitySchema {
         if (['String', 'Number', 'Boolean', 'Array'].includes(type)) {
             type = type.toLowerCase();
         }
-        return type;
+        return { type };
     }
     createProperty(kind, options) {
         return {

package/metadata/MetadataDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { type EntityClass, EntityMetadata } from '../typings.js';
+import { type EntityClass, EntityMetadata, type EntityName } from '../typings.js';
 import type { Configuration } from '../utils/Configuration.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
@@ -16,7 +16,6 @@ export declare class MetadataDiscovery {
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
     discover(preferTs?: boolean): Promise<MetadataStorage>;
     discoverSync(): MetadataStorage;
-    validateDiscovered(metadata: EntityMetadata[]): void;
     private mapDiscoveredEntities;
     private initAccessors;
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];
@@ -24,7 +23,7 @@ export declare class MetadataDiscovery {
     private discoverMissingTargets;
     private tryDiscoverTargets;
     discoverReferences<T>(refs: Iterable<EntityClass<T> | EntitySchema<T>>, validate?: boolean): EntityMetadata<T>[];
-    reset(className: string): void;
+    reset<T>(entityName: EntityName<T>): void;
     private getSchema;
     private getRootEntity;
     private discoverEntity;