@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.300

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,15 +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);
         }
-        if (meta.tableName || meta.collection) {
-            Utils.renameKey(meta, 'tableName', 'collection');
-            meta.tableName = meta.collection;
-        }
-        Object.assign(this._meta, { className: meta.name }, meta);
-        this._meta.root ??= this._meta;
     }
     static fromMetadata(meta) {
         const schema = new EntitySchema({ ...meta, internal: true });
@@ -34,29 +33,13 @@ export class EntitySchema {
         return schema;
     }
     addProperty(name, type, options = {}) {
-        const rename = (data, from, to) => {
-            if (from in options && !(to in options)) {
-                // @ts-ignore
-                options[to] = [options[from]];
-                // @ts-ignore
-                delete options[from];
-            }
-        };
-        if (name !== options.name) {
-            Utils.renameKey(options, 'name', 'fieldName');
-        }
-        rename(options, 'fieldName', 'fieldNames');
-        rename(options, 'ref', 'ref');
-        rename(options, 'joinColumn', 'joinColumns');
-        rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
-        rename(options, 'referenceColumnName', 'referencedColumnNames');
-        rename(options, 'columnType', 'columnTypes');
-        const prop = { name, kind: ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
+        this.renameCompositeOptions(name, options);
+        const prop = { name, kind: ReferenceKind.SCALAR, ...options, ...this.normalizeType(options, type) };
         if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
         }
-        if (Utils.isString(prop.formula)) {
-            const formula = prop.formula; // tmp var is needed here
+        if (typeof prop.formula === 'string') {
+            const formula = prop.formula;
             prop.formula = () => formula;
         }
         if (prop.formula) {
@@ -91,17 +74,18 @@ export class EntitySchema {
     }
     addSerializedPrimaryKey(name, type, options = {}) {
         this._meta.serializedPrimaryKey = name;
-        this.addProperty(name, type, options);
+        this.addProperty(name, type, { serializedPrimaryKey: true, ...options });
     }
     addEmbedded(name, options) {
+        this.renameCompositeOptions(name, options);
         Utils.defaultValue(options, 'prefix', true);
         if (options.array) {
             options.object = true; // force object mode for arrays
         }
         this._meta.properties[name] = {
             name,
-            type: this.normalizeType(options),
             kind: ReferenceKind.EMBEDDED,
+            ...this.normalizeType(options),
             ...options,
         };
     }
@@ -114,6 +98,8 @@ export class EntitySchema {
         if (prop.fieldNames && !prop.joinColumns) {
             prop.joinColumns = prop.fieldNames;
         }
+        // By default, the foreign key constraint is created on the relation
+        Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         this.addProperty(name, type, prop);
     }
     addManyToMany(name, type, options) {
@@ -123,6 +109,8 @@ export class EntitySchema {
         }
         if (options.owner) {
             Utils.renameKey(options, 'mappedBy', 'inversedBy');
+            // By default, the foreign key constraint is created on the relation
+            Utils.defaultValue(options, 'createForeignKeyConstraint', true);
         }
         const prop = this.createProperty(ReferenceKind.MANY_TO_MANY, options);
         this.addProperty(name, type, prop);
@@ -135,8 +123,12 @@ export class EntitySchema {
         const prop = this.createProperty(ReferenceKind.ONE_TO_ONE, options);
         Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
         Utils.defaultValue(prop, 'unique', prop.owner);
-        if (prop.owner && options.mappedBy) {
-            Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+        if (prop.owner) {
+            if (options.mappedBy) {
+                Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+            }
+            // By default, the foreign key constraint is created on the relation
+            Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         }
         if (prop.joinColumns && !prop.fieldNames) {
             prop.fieldNames = prop.joinColumns;
@@ -158,21 +150,29 @@ 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 oldClass = this._meta.class;
+        const sameClass = this._meta.class === cls;
+        this._meta.class = cls;
+        this._meta.prototype = cls.prototype;
+        this._meta.className = this._meta.name ?? cls.name;
         if (!sameClass || !this._meta.constructorParams) {
-            const tokens = Utils.tokenize(proto);
-            this._meta.constructorParams = Utils.getParamNames(tokens, 'constructor');
-            this._meta.toJsonParams = Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
+            this._meta.constructorParams = Utils.getConstructorParams(cls);
         }
         if (!this.internal) {
-            EntitySchema.REGISTRY.set(proto, this);
+            // Remove old class from registry if it's being replaced with a different class
+            if (oldClass && oldClass !== cls && EntitySchema.REGISTRY.get(oldClass) === this) {
+                EntitySchema.REGISTRY.delete(oldClass);
+            }
+            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);
+        // Only set extends if the parent is NOT the auto-generated class for this same entity.
+        // When the user extends the auto-generated class (from defineEntity without a class option)
+        // and registers their custom class via setClass, we don't want to discover the
+        // auto-generated class as a separate parent entity.
+        if (base !== BaseEntity && base.name !== this._meta.className) {
+            this._meta.extends ??= base.name ? base : undefined;
         }
     }
     get meta() {
@@ -181,6 +181,18 @@ export class EntitySchema {
     get name() {
         return this._meta.className;
     }
+    get tableName() {
+        return this._meta.tableName;
+    }
+    get class() {
+        return this._meta.class;
+    }
+    get properties() {
+        return this._meta.properties;
+    }
+    new(...params) {
+        return new this._meta.class(...params);
+    }
     /**
      * @internal
      */
@@ -188,19 +200,16 @@ 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) {
+        // Abstract TPT entities keep their name because they have their own table
+        const isTPT = this._meta.inheritance === 'tpt' || this.isPartOfTPTHierarchy();
+        if (this._meta.abstract && !this._meta.discriminatorColumn && !isTPT) {
             delete this._meta.name;
         }
         const tableName = this._meta.collection ?? this._meta.tableName;
         if (tableName?.includes('.') && !this._meta.schema) {
             this._meta.schema = tableName.substring(0, tableName.indexOf('.'));
-            this._meta.collection = tableName.substring(tableName.indexOf('.') + 1);
+            this._meta.tableName = tableName.substring(tableName.indexOf('.') + 1);
         }
         this.initProperties();
         this.initPrimaryKeys();
@@ -209,6 +218,24 @@ export class EntitySchema {
         this.initialized = true;
         return this;
     }
+    /**
+     * Check if this entity is part of a TPT hierarchy by walking up the extends chain.
+     * This handles mid-level abstract entities (e.g., Animal -> Mammal -> Dog where Mammal is abstract).
+     */
+    isPartOfTPTHierarchy() {
+        let parent = this._meta.extends;
+        while (parent) {
+            const parentSchema = parent instanceof EntitySchema ? parent : EntitySchema.REGISTRY.get(parent);
+            if (!parentSchema) {
+                break;
+            }
+            if (parentSchema._meta.inheritance === 'tpt') {
+                return true;
+            }
+            parent = parentSchema._meta.extends;
+        }
+        return false;
+    }
     initProperties() {
         Utils.entries(this._meta.properties).forEach(([name, options]) => {
             if (Type.isMappedType(options.type)) {
@@ -266,12 +293,15 @@ export class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
-            if (Utils.isString(options.entity)) {
-                type = options.type = options.entity;
+            /* v8 ignore next */
+            if (typeof options.entity === 'string') {
+                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) {
@@ -280,7 +310,7 @@ export class EntitySchema {
         if (['String', 'Number', 'Boolean', 'Array'].includes(type)) {
             type = type.toLowerCase();
         }
-        return type;
+        return { type };
     }
     createProperty(kind, options) {
         return {
@@ -289,4 +319,47 @@ export class EntitySchema {
             ...options,
         };
     }
+    rename(data, from, to) {
+        if (from in data && !(to in data)) {
+            // @ts-ignore
+            data[to] = [data[from]];
+            // @ts-ignore
+            delete data[from];
+        }
+    }
+    renameCompositeOptions(name, options = {}) {
+        if (name !== options.name && !options.fieldNames) {
+            Utils.renameKey(options, 'name', 'fieldName');
+        }
+        else if (options.name && (options.fieldNames?.length ?? 0) > 1) {
+            delete options.name;
+        }
+        this.rename(options, 'fieldName', 'fieldNames');
+        this.rename(options, 'joinColumn', 'joinColumns');
+        this.rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
+        this.rename(options, 'referenceColumnName', 'referencedColumnNames');
+        this.rename(options, 'columnType', 'columnTypes');
+    }
+    /**
+     * Adds a lifecycle hook handler to the entity schema.
+     * This method allows registering hooks after the entity is defined,
+     * which can be useful for avoiding circular type references.
+     *
+     * @example
+     * ```ts
+     * export const Article = defineEntity({
+     *   name: 'Article',
+     *   properties: { ... },
+     * });
+     *
+     * Article.addHook('beforeCreate', async args => {
+     *   args.entity.slug = args.entity.title.toLowerCase();
+     * });
+     * ```
+     */
+    addHook(event, handler) {
+        this._meta.hooks[event] ??= [];
+        this._meta.hooks[event].push(handler);
+        return this;
+    }
 }

package/metadata/MetadataDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor, 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';
@@ -9,26 +9,24 @@ export declare class MetadataDiscovery {
     private readonly config;
     private readonly namingStrategy;
     private readonly metadataProvider;
-    private readonly cache;
     private readonly logger;
     private readonly schemaHelper;
     private readonly validator;
     private readonly discovered;
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
     discover(preferTs?: boolean): Promise<MetadataStorage>;
-    discoverSync(preferTs?: boolean): MetadataStorage;
+    discoverSync(): MetadataStorage;
     private mapDiscoveredEntities;
+    private initAccessors;
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];
     private findEntities;
     private discoverMissingTargets;
     private tryDiscoverTargets;
-    private discoverDirectories;
-    discoverReferences<T>(refs: (Constructor<T> | EntitySchema<T>)[]): EntityMetadata<T>[];
-    reset(className: string): void;
-    private prepare;
+    discoverReferences<T>(refs: Iterable<EntityClass<T> | EntitySchema<T>>, validate?: boolean): EntityMetadata<T>[];
+    reset<T>(entityName: EntityName<T>): void;
     private getSchema;
+    private getRootEntity;
     private discoverEntity;
-    private saveToCache;
     private initNullability;
     private applyNamingStrategy;
     private initOwnColumns;
@@ -36,6 +34,7 @@ export declare class MetadataDiscovery {
     private initManyToOneFieldName;
     private initManyToManyFieldName;
     private initManyToManyFields;
+    private isExplicitTableName;
     private initManyToOneFields;
     private initOneToManyFields;
     private processEntity;
@@ -43,18 +42,74 @@ export declare class MetadataDiscovery {
     private initFactoryField;
     private ensureCorrectFKOrderInPivotEntity;
     private definePivotTableEntity;
+    /**
+     * Create a scalar property for a pivot table column.
+     */
+    private createPivotScalarProperty;
+    /**
+     * Get column types for an entity's primary keys, initializing them if needed.
+     */
+    private getPrimaryKeyColumnTypes;
+    /**
+     * Add missing FK columns for a polymorphic entity to an existing pivot table.
+     */
+    private addPolymorphicPivotColumns;
+    /**
+     * Define properties for a polymorphic pivot table.
+     */
+    private definePolymorphicPivotProperties;
+    /**
+     * Create a virtual M:1 relation from pivot to a polymorphic owner entity.
+     * This enables single-query join loading for inverse-side polymorphic M:N.
+     */
+    private definePolymorphicOwnerRelation;
     private defineFixedOrderProperty;
     private definePivotProperty;
     private autoWireBidirectionalProperties;
     private defineBaseEntityProperties;
     private initPolyEmbeddables;
+    private initPolymorphicRelation;
     private initEmbeddables;
     private initSingleTableInheritance;
+    /**
+     * First pass of TPT initialization: sets up hierarchy relationships
+     * (inheritanceType, tptParent, tptChildren) before properties have fieldNames.
+     */
+    private initTPTRelationships;
+    /**
+     * Second pass of TPT initialization: re-resolves metadata references after fieldNames
+     * are set, syncs to registry metadata, and sets up discriminators.
+     */
+    private finalizeTPTInheritance;
+    /**
+     * Initialize TPT discriminator map and virtual discriminator property.
+     * Unlike STI where the discriminator is a persisted column, TPT discriminator is computed
+     * at query time using CASE WHEN expressions based on which child table has data.
+     */
+    private initTPTDiscriminator;
+    /**
+     * Recursively collect all TPT descendants (children, grandchildren, etc.)
+     */
+    private collectAllTPTDescendants;
+    /**
+     * Computes ownProps for TPT entities - only properties defined in THIS entity,
+     * not inherited from parent. Also creates synthetic join properties for parent/child relationships.
+     *
+     * Called multiple times during discovery as metadata is progressively built.
+     * Each pass overwrites earlier results to reflect the final state of properties.
+     */
+    private computeTPTOwnProps;
+    /** Returns the depth of a TPT entity in its hierarchy (0 for root). */
+    private getTPTDepth;
+    /**
+     * Find the direct TPT parent entity for the given entity.
+     */
+    private getTPTParent;
     private createDiscriminatorProperty;
     private initAutoincrement;
+    private createSchemaTable;
     private initCheckConstraints;
     private initGeneratedColumn;
-    private createColumnMappingObject;
     private getDefaultVersionValue;
     private inferDefaultValue;
     private initDefaultValue;
@@ -67,6 +122,5 @@ export declare class MetadataDiscovery {
     private getPrefix;
     private initUnsigned;
     private initIndexes;
-    private getEntityClassOrSchema;
     private shouldForceConstructorUsage;
 }