@mikro-orm/core 7.0.0-dev.228 → 7.0.0-dev.229

package/EntityManager.js

@@ -297,7 +297,7 @@ export class EntityManager {
     // this method only handles the problem for mongo driver, SQL drivers have their implementation inside QueryBuilder
     applyDiscriminatorCondition(entityName, where) {
         const meta = this.metadata.find(entityName);
-        if (!meta?.discriminatorValue) {
+        if (meta?.root.inheritanceType !== 'sti' || !meta?.discriminatorValue) {
             return where;
         }
         const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
@@ -1413,9 +1413,11 @@ export class EntityManager {
         if (p.includes(':')) {
             p = p.split(':', 2)[0];
         }
-        const ret = p in meta.root.properties;
+        // For TPT inheritance, check the entity's own properties, not just the root's
+        // For STI, meta.properties includes all properties anyway
+        const ret = p in meta.properties;
         if (parts.length > 0) {
-            return this.canPopulate(meta.root.properties[p].targetMeta.class, parts.join('.'));
+            return this.canPopulate(meta.properties[p].targetMeta.class, parts.join('.'));
         }
         return ret;
     }

package/entity/EntityFactory.js

@@ -83,7 +83,7 @@ export class EntityFactory {
         else {
             this.hydrate(entity, meta2, data, options);
         }
-        if (exists && meta.discriminatorColumn && !(entity instanceof meta2.class)) {
+        if (exists && meta.root.inheritanceType && !(entity instanceof meta2.class)) {
             Object.setPrototypeOf(entity, meta2.prototype);
         }
         if (options.merge && wrapped.hasPrimaryKey()) {
@@ -281,13 +281,22 @@ export class EntityFactory {
         return this.unitOfWork.getById(meta.class, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
-        if (!meta.root.discriminatorColumn) {
+        // Handle STI discriminator (persisted column)
+        if (meta.root.inheritanceType === 'sti') {
+            const prop = meta.properties[meta.root.discriminatorColumn];
+            const value = data[prop.name];
+            const type = meta.root.discriminatorMap[value];
+            meta = type ? this.metadata.get(type) : meta;
             return meta;
         }
-        const prop = meta.properties[meta.root.discriminatorColumn];
-        const value = data[prop.name];
-        const type = meta.root.discriminatorMap[value];
-        meta = type ? this.metadata.get(type) : meta;
+        // Handle TPT discriminator (computed at query time)
+        if (meta.root.inheritanceType === 'tpt' && meta.root.discriminatorMap) {
+            const value = data[meta.root.tptDiscriminatorColumn];
+            if (value) {
+                const type = meta.root.discriminatorMap[value];
+                meta = type ? this.metadata.get(type) : meta;
+            }
+        }
         return meta;
     }
     /**

package/entity/defineEntity.d.ts

@@ -429,6 +429,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
+    inheritance?: 'tpt';
     discriminatorColumn?: keyof TProperties;
     versionProperty?: keyof TProperties;
     concurrencyCheckKeys?: Set<keyof TProperties>;
@@ -579,18 +580,18 @@ type MaybeOpt<Value, Options> = Options extends {
     mapToPk: true;
 } ? Value extends Opt<infer OriginalValue> ? OriginalValue : Value : Options extends {
     autoincrement: true;
-} ? Opt<Value> : Options extends {
+} | {
     onCreate: Function;
-} ? Opt<Value> : Options extends {
+} | {
     default: string | string[] | number | number[] | boolean | null | Date | Raw;
-} ? Opt<Value> : Options extends {
+} | {
     defaultRaw: string;
-} ? Opt<Value> : Options extends {
+} | {
     persist: false;
-} ? Opt<Value> : Options extends {
+} | {
     version: true;
-} ? Opt<Value> : Options extends {
-    formula: string | ((...args: any[]) => string);
+} | {
+    formula: string | ((...args: any[]) => any);
 } ? Opt<Value> : Value;
 type MaybeHidden<Value, Options> = Options extends {
     hidden: true;

package/errors.d.ts

@@ -68,6 +68,8 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError<Partial<any>>;
     static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
     static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
+    static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
+    static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     private static fromMessage;
 }
 export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {

package/errors.js

@@ -233,6 +233,12 @@ export class MetadataError extends ValidationError {
     static viewEntityWithoutExpression(meta) {
         return new MetadataError(`View entity ${meta.className} is missing 'expression'. View entities must have an expression defining the SQL query.`);
     }
+    static mixedInheritanceStrategies(root, child) {
+        return new MetadataError(`Entity ${child.className} cannot mix STI (Single Table Inheritance) and TPT (Table-Per-Type) inheritance. Root entity ${root.className} uses STI (discriminatorColumn) but also has inheritance: 'tpt'. Choose one inheritance strategy per hierarchy.`);
+    }
+    static tptNotSupportedByDriver(meta) {
+        return new MetadataError(`Entity ${meta.className} uses TPT (Table-Per-Type) inheritance which is not supported by the current driver. TPT requires SQL JOINs and is only available with SQL drivers.`);
+    }
     static fromMessage(meta, prop, message) {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }

package/index.d.ts

@@ -3,7 +3,7 @@
  * @module core
  */
 export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
-export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/EntitySchema.d.ts

@@ -39,6 +39,8 @@ export type EntitySchemaMetadata<Entity, Base = never, Class extends EntityCtor
     properties?: {
         [Key in keyof OmitBaseProps<Entity, Base> as CleanKeys<OmitBaseProps<Entity, Base>, Key>]-?: EntitySchemaProperty<ExpandProperty<NonNullable<Entity[Key]>>, Entity>;
     };
+} & {
+    inheritance?: 'tpt';
 };
 export declare class EntitySchema<Entity = any, Base = never, Class extends EntityCtor = EntityCtor<Entity>> {
     /**
@@ -78,6 +80,11 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
      * @internal
      */
     init(): 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).
+     */
+    private isPartOfTPTHierarchy;
     private initProperties;
     private initPrimaryKeys;
     private normalizeType;

package/metadata/EntitySchema.js

@@ -201,7 +201,9 @@ export class EntitySchema {
             return this;
         }
         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;
@@ -216,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)) {

package/metadata/MetadataDiscovery.d.ts

@@ -71,8 +71,43 @@ export declare class MetadataDiscovery {
     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 getDefaultVersionValue;

package/metadata/MetadataDiscovery.js

@@ -78,6 +78,9 @@ export class MetadataDiscovery {
         });
         for (const meta of discovered) {
             meta.root = discovered.get(meta.root.class);
+            if (meta.inheritanceType === 'tpt') {
+                this.computeTPTOwnProps(meta);
+            }
         }
         return discovered;
     }
@@ -122,6 +125,7 @@ export class MetadataDiscovery {
         // sort so we discover entities first to get around issues with nested embeddables
         filtered.sort((a, b) => !a.embeddable === !b.embeddable ? 0 : (a.embeddable ? 1 : -1));
         filtered.forEach(meta => this.initSingleTableInheritance(meta, filtered));
+        filtered.forEach(meta => this.initTPTRelationships(meta, filtered));
         filtered.forEach(meta => this.defineBaseEntityProperties(meta));
         filtered.forEach(meta => {
             const newMeta = EntitySchema.fromMetadata(meta).init().meta;
@@ -136,6 +140,8 @@ export class MetadataDiscovery {
         forEachProp((_m, p) => this.initRelation(p));
         forEachProp((m, p) => this.initEmbeddables(m, p));
         forEachProp((_m, p) => this.initFieldName(p));
+        filtered.forEach(meta => this.finalizeTPTInheritance(meta, filtered));
+        filtered.forEach(meta => this.computeTPTOwnProps(meta));
         forEachProp((m, p) => this.initVersionProperty(m, p));
         forEachProp((m, p) => this.initCustomType(m, p));
         forEachProp((m, p) => this.initGeneratedColumn(m, p));
@@ -158,6 +164,9 @@ export class MetadataDiscovery {
             meta = this.metadata.get(meta.class);
             meta.sync(true);
             this.findReferencingProperties(meta, filtered);
+            if (meta.inheritanceType === 'tpt') {
+                this.computeTPTOwnProps(meta);
+            }
             return meta;
         });
     }
@@ -296,7 +305,9 @@ export class MetadataDiscovery {
             return meta;
         }
         const root = this.getRootEntity(base);
-        if (root.discriminatorColumn) {
+        // For STI or TPT, use the root entity.
+        // Check both `inheritanceType` (set during discovery) and raw `inheritance` option (set before discovery).
+        if (root.discriminatorColumn || root.inheritanceType || root.inheritance === 'tpt') {
             return root;
         }
         return meta;
@@ -1151,6 +1162,7 @@ export class MetadataDiscovery {
         if (!meta.root.discriminatorColumn) {
             return;
         }
+        meta.root.inheritanceType = 'sti';
         if (meta.root.discriminatorMap) {
             const map = meta.root.discriminatorMap;
             Object.keys(map)
@@ -1220,6 +1232,175 @@ export class MetadataDiscovery {
         meta.root.uniques = Utils.unique([...meta.root.uniques, ...meta.uniques]);
         meta.root.checks = Utils.unique([...meta.root.checks, ...meta.checks]);
     }
+    /**
+     * First pass of TPT initialization: sets up hierarchy relationships
+     * (inheritanceType, tptParent, tptChildren) before properties have fieldNames.
+     */
+    initTPTRelationships(meta, metadata) {
+        if (meta.root !== meta) {
+            meta.root = metadata.find(m => m.class === meta.root.class);
+        }
+        const inheritance = meta.inheritance;
+        if (inheritance === 'tpt' && meta.root === meta) {
+            meta.inheritanceType = 'tpt';
+            meta.tptChildren = [];
+        }
+        if (meta.root.inheritanceType !== 'tpt') {
+            return;
+        }
+        const parent = this.getTPTParent(meta, metadata);
+        if (parent) {
+            meta.tptParent = parent;
+            meta.inheritanceType = 'tpt';
+            parent.tptChildren ??= [];
+            if (!parent.tptChildren.includes(meta)) {
+                parent.tptChildren.push(meta);
+            }
+        }
+    }
+    /**
+     * Second pass of TPT initialization: re-resolves metadata references after fieldNames
+     * are set, syncs to registry metadata, and sets up discriminators.
+     */
+    finalizeTPTInheritance(meta, metadata) {
+        if (meta.inheritanceType !== 'tpt') {
+            return;
+        }
+        if (meta.tptParent) {
+            meta.tptParent = metadata.find(m => m.class === meta.tptParent.class) ?? meta.tptParent;
+        }
+        if (meta.tptChildren) {
+            meta.tptChildren = meta.tptChildren.map(child => metadata.find(m => m.class === child.class) ?? child);
+        }
+        const registryMeta = this.metadata.get(meta.class);
+        if (registryMeta && registryMeta !== meta) {
+            registryMeta.inheritanceType = meta.inheritanceType;
+            registryMeta.tptParent = meta.tptParent ? this.metadata.get(meta.tptParent.class) : undefined;
+            registryMeta.tptChildren = meta.tptChildren?.map(child => this.metadata.get(child.class));
+        }
+        this.initTPTDiscriminator(meta, metadata);
+    }
+    /**
+     * 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.
+     */
+    initTPTDiscriminator(meta, metadata) {
+        const allDescendants = this.collectAllTPTDescendants(meta, metadata);
+        allDescendants.sort((a, b) => this.getTPTDepth(b) - this.getTPTDepth(a));
+        meta.allTPTDescendants = allDescendants;
+        if (meta.root !== meta) {
+            return;
+        }
+        meta.root.discriminatorMap = {};
+        for (const m of allDescendants) {
+            const name = this.namingStrategy.classToTableName(m.className);
+            meta.root.discriminatorMap[name] = m.class;
+            m.discriminatorValue = name;
+        }
+        if (!meta.abstract) {
+            const name = this.namingStrategy.classToTableName(meta.className);
+            meta.root.discriminatorMap[name] = meta.class;
+            meta.discriminatorValue = name;
+        }
+        // Virtual discriminator property - computed at query time via CASE WHEN, not persisted
+        const discriminatorColumn = '__tpt_type';
+        if (!meta.root.properties[discriminatorColumn]) {
+            meta.root.addProperty({
+                name: discriminatorColumn,
+                type: 'string',
+                kind: ReferenceKind.SCALAR,
+                persist: false,
+                userDefined: false,
+                hidden: true,
+            });
+        }
+        meta.root.tptDiscriminatorColumn = discriminatorColumn;
+    }
+    /**
+     * Recursively collect all TPT descendants (children, grandchildren, etc.)
+     */
+    collectAllTPTDescendants(meta, metadata) {
+        const descendants = [];
+        const collect = (parent) => {
+            for (const child of parent.tptChildren ?? []) {
+                const resolved = metadata.find(m => m.class === child.class) ?? child;
+                if (!resolved.abstract) {
+                    descendants.push(resolved);
+                }
+                collect(resolved);
+            }
+        };
+        collect(meta);
+        return descendants;
+    }
+    /**
+     * 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.
+     */
+    computeTPTOwnProps(meta) {
+        if (meta.inheritanceType !== 'tpt') {
+            return;
+        }
+        const belongsToTable = (prop) => prop.persist !== false || prop.primary;
+        // Use meta.properties (object) since meta.props (array) may not be populated yet
+        const allProps = Object.values(meta.properties);
+        if (!meta.tptParent) {
+            meta.ownProps = allProps.filter(belongsToTable);
+            return;
+        }
+        const parentPropNames = new Set(Object.values(meta.tptParent.properties).map(p => p.name));
+        meta.ownProps = allProps.filter(prop => !parentPropNames.has(prop.name) && belongsToTable(prop));
+        // Create synthetic join properties for the parent-child relationship
+        const childFieldNames = meta.getPrimaryProps().flatMap(p => p.fieldNames);
+        const parentFieldNames = meta.tptParent.getPrimaryProps().flatMap(p => p.fieldNames);
+        meta.tptParentProp = {
+            name: '[tpt:parent]',
+            kind: ReferenceKind.MANY_TO_ONE,
+            targetMeta: meta.tptParent,
+            fieldNames: childFieldNames,
+            referencedColumnNames: parentFieldNames,
+            persist: false,
+        };
+        meta.tptInverseProp = {
+            name: '[tpt:child]',
+            kind: ReferenceKind.ONE_TO_ONE,
+            owner: true,
+            targetMeta: meta,
+            fieldNames: parentFieldNames,
+            joinColumns: parentFieldNames,
+            referencedColumnNames: childFieldNames,
+            persist: false,
+        };
+    }
+    /** Returns the depth of a TPT entity in its hierarchy (0 for root). */
+    getTPTDepth(meta) {
+        let depth = 0;
+        let current = meta;
+        while (current.tptParent) {
+            depth++;
+            current = current.tptParent;
+        }
+        return depth;
+    }
+    /**
+     * Find the direct TPT parent entity for the given entity.
+     */
+    getTPTParent(meta, metadata) {
+        if (meta.root === meta) {
+            return undefined;
+        }
+        return metadata.find(m => {
+            const ext = meta.extends;
+            if (ext instanceof EntitySchema) {
+                return m.class === ext.meta.class || m.className === ext.meta.className;
+            }
+            return m.class === ext || m.className === Utils.className(ext);
+        });
+    }
     createDiscriminatorProperty(meta) {
         meta.addProperty({
             name: meta.discriminatorColumn,
@@ -1236,13 +1417,23 @@ export class MetadataDiscovery {
             pks[0].autoincrement ??= true;
         }
     }
+    createSchemaTable(meta) {
+        const qualifiedName = meta.schema ? `${meta.schema}.${meta.tableName}` : meta.tableName;
+        return {
+            name: meta.tableName,
+            schema: meta.schema,
+            qualifiedName,
+            toString: () => qualifiedName,
+        };
+    }
     initCheckConstraints(meta) {
-        const map = meta.createColumnMappingObject();
+        const columns = meta.createSchemaColumnMappingObject();
+        const table = this.createSchemaTable(meta);
         for (const check of meta.checks) {
-            const columns = check.property ? meta.properties[check.property].fieldNames : [];
-            check.name ??= this.namingStrategy.indexName(meta.tableName, columns, 'check');
+            const fieldNames = check.property ? meta.properties[check.property].fieldNames : [];
+            check.name ??= this.namingStrategy.indexName(meta.tableName, fieldNames, 'check');
             if (check.expression instanceof Function) {
-                check.expression = check.expression(map);
+                check.expression = check.expression(columns, table);
             }
         }
         if (this.platform.usesEnumCheckConstraints() && !meta.embeddable) {
@@ -1272,9 +1463,9 @@ export class MetadataDiscovery {
             }
             return;
         }
-        const map = meta.createColumnMappingObject();
         if (prop.generated instanceof Function) {
-            prop.generated = prop.generated(map);
+            const columns = meta.createSchemaColumnMappingObject();
+            prop.generated = prop.generated(columns, this.createSchemaTable(meta));
         }
     }
     getDefaultVersionValue(meta, prop) {

package/metadata/MetadataValidator.d.ts

@@ -35,4 +35,13 @@ export declare class MetadataValidator {
      * View entities must have an expression.
      */
     private validateViewEntity;
+    /**
+     * Validates that STI and TPT are not mixed in the same inheritance hierarchy.
+     * An entity hierarchy can use either STI (discriminatorColumn) or TPT (inheritance: 'tpt'),
+     * but not both.
+     *
+     * Note: This validation runs before `initTablePerTypeInheritance` sets `inheritanceType`,
+     * so we check the raw `inheritance` option from the decorator/schema.
+     */
+    private validateInheritanceStrategies;
 }

package/metadata/MetadataValidator.js

@@ -61,6 +61,8 @@ export class MetadataValidator {
         if (discovered.length === 0 && options.warnWhenNoEntities) {
             throw MetadataError.noEntityDiscovered();
         }
+        // Validate no mixing of STI and TPT in the same hierarchy
+        this.validateInheritanceStrategies(discovered);
         const tableNames = discovered.filter(meta => !meta.abstract && !meta.embeddable && meta === meta.root && (meta.tableName || meta.collection) && meta.schema !== '*');
         const duplicateTableNames = Utils.findDuplicates(tableNames.map(meta => {
             const tableName = meta.tableName || meta.collection;
@@ -117,7 +119,7 @@ export class MetadataValidator {
         if (!targetMeta) {
             throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
-        if (targetMeta.abstract && !targetMeta.discriminatorColumn && !targetMeta.embeddable) {
+        if (targetMeta.abstract && !targetMeta.root?.inheritanceType && !targetMeta.embeddable) {
             throw MetadataError.targetIsAbstract(meta, prop);
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && targetMeta.compositePK && options.checkNonPersistentCompositeProps) {
@@ -336,4 +338,30 @@ export class MetadataValidator {
         // Validate property names
         this.validatePropertyNames(meta);
     }
+    /**
+     * Validates that STI and TPT are not mixed in the same inheritance hierarchy.
+     * An entity hierarchy can use either STI (discriminatorColumn) or TPT (inheritance: 'tpt'),
+     * but not both.
+     *
+     * Note: This validation runs before `initTablePerTypeInheritance` sets `inheritanceType`,
+     * so we check the raw `inheritance` option from the decorator/schema.
+     */
+    validateInheritanceStrategies(discovered) {
+        const checkedRoots = new Set();
+        for (const meta of discovered) {
+            if (meta.embeddable) {
+                continue;
+            }
+            const root = meta.root;
+            if (checkedRoots.has(root)) {
+                continue;
+            }
+            checkedRoots.add(root);
+            const hasSTI = !!root.discriminatorColumn;
+            const hasTPT = root.inheritanceType === 'tpt' || root.inheritance === 'tpt';
+            if (hasSTI && hasTPT) {
+                throw MetadataError.mixedInheritanceStrategies(root, meta);
+            }
+        }
+    }
 }

package/metadata/types.d.ts

@@ -1,10 +1,9 @@
-import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery } from '../typings.js';
+import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw } from '../typings.js';
 import type { Cascade, LoadStrategy, DeferMode, QueryOrderMap, EmbeddedPrefixMode } from '../enums.js';
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { FilterOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-import type { Raw } from '../utils/RawQueryFragment.js';
 export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     /** Override default collection/table name. Alias for `collection`. */
     tableName?: string;
@@ -18,6 +17,8 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     discriminatorMap?: Dictionary<string>;
     /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorValue?: number | string;
+    /** Set inheritance strategy: 'tpt' for {@doclink inheritance-mapping#table-per-type-inheritance-tpt | Table-Per-Type} inheritance. When set on the root entity, each entity in the hierarchy gets its own table with a FK from child PK to parent PK. */
+    inheritance?: 'tpt';
     /**	Enforce use of constructor when creating managed entity instances. */
     forceConstructor?: boolean;
     /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
@@ -137,7 +138,7 @@ export interface PropertyOptions<Owner> {
     /**
      * For generated columns. This will be appended to the column type after the `generated always` clause.
      */
-    generated?: string | GeneratedColumnCallback<Owner>;
+    generated?: string | Raw | GeneratedColumnCallback<Owner>;
     /**
      * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.228",
+  "version": "7.0.0-dev.229",
   "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.",
   "exports": {
     "./package.json": "./package.json",

package/typings.d.ts

@@ -18,6 +18,7 @@ import type { Raw } from './utils/RawQueryFragment.js';
 import type { EntityManager } from './EntityManager.js';
 import type { EventSubscriber } from './events/EventSubscriber.js';
 import type { FilterOptions, FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
+export type { Raw };
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Dictionary<T = any> = {
     [k: string]: T;
@@ -400,22 +401,46 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 };
 type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
 type PropertyName<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
-type TableName = {
+export type FormulaTable = {
+    alias: string;
     name: string;
     schema?: string;
+    qualifiedName: string;
     toString: () => string;
 };
-export type FormulaTable = {
-    alias: string;
+/**
+ * Table reference for schema callbacks (indexes, checks, generated columns).
+ * Unlike FormulaTable, this has no alias since schema generation doesn't use query aliases.
+ */
+export type SchemaTable = {
     name: string;
     schema?: string;
     qualifiedName: string;
     toString: () => string;
 };
-export type IndexCallback<T> = (table: TableName, columns: Record<PropertyName<T>, string>, indexName: string) => string | Raw;
-export type FormulaCallback<T> = (table: FormulaTable, columns: Record<PropertyName<T>, string>) => string;
-export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>) => string | Raw;
-export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
+/**
+ * Column mapping for formula callbacks. Maps property names to fully-qualified alias.fieldName.
+ * Has toString() returning the main alias for backwards compatibility with old formula syntax.
+ * @example
+ * // New recommended syntax - use cols.propName for fully-qualified references
+ * formula: cols => `${cols.firstName} || ' ' || ${cols.lastName}`
+ *
+ * // Old syntax still works - cols.toString() returns the alias
+ * formula: cols => `${cols}.first_name || ' ' || ${cols}.last_name`
+ */
+export type FormulaColumns<T> = Record<PropertyName<T>, string> & {
+    toString(): string;
+};
+/**
+ * Column mapping for schema callbacks (indexes, checks, generated columns).
+ * Maps property names to field names. For TPT entities, only includes properties
+ * that belong to the current table (not inherited properties from parent tables).
+ */
+export type SchemaColumns<T> = Record<PropertyName<T>, string>;
+export type IndexCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable, indexName: string) => string | Raw;
+export type FormulaCallback<T> = (columns: FormulaColumns<T>, table: FormulaTable) => string | Raw;
+export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
+export type GeneratedColumnCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 export interface CheckConstraint<T = any> {
     name?: string;
     property?: string;
@@ -430,7 +455,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     runtimeType: 'number' | 'string' | 'boolean' | 'bigint' | 'Buffer' | 'Date' | 'object' | 'any' | AnyString;
     targetMeta?: EntityMetadata<Target>;
     columnTypes: string[];
-    generated?: string | GeneratedColumnCallback<Owner>;
+    generated?: string | Raw | GeneratedColumnCallback<Owner>;
     customType?: Type<any>;
     customTypes: (Type<any> | undefined)[];
     hasConvertToJSValueSQL: boolean;
@@ -533,7 +558,18 @@ export declare class EntityMetadata<Entity = any, Class extends EntityCtor<Entit
     removeProperty(name: string, sync?: boolean): void;
     getPrimaryProps(flatten?: boolean): EntityProperty<Entity>[];
     getPrimaryProp(): EntityProperty<Entity>;
-    createColumnMappingObject(): Record<PropertyName<Entity>, string>;
+    /**
+     * Creates a mapping from property names to field names.
+     * @param alias - Optional alias to prefix field names. Can be a string (same for all) or a function (per-property).
+     *                When provided, also adds toString() returning the alias for backwards compatibility with formulas.
+     * @param toStringAlias - Optional alias to return from toString(). Defaults to `alias` when it's a string.
+     */
+    createColumnMappingObject(alias?: string | ((prop: EntityProperty<Entity>) => string), toStringAlias?: string): FormulaColumns<Entity>;
+    /**
+     * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
+     * For TPT entities, only includes properties that belong to the current table (ownProps).
+     */
+    createSchemaColumnMappingObject(): SchemaColumns<Entity>;
     get tableName(): string;
     set tableName(name: string);
     get uniqueName(): string;
@@ -628,6 +664,22 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     definedProperties: Dictionary;
     /** For polymorphic M:N pivot tables, maps discriminator values to entity classes */
     polymorphicDiscriminatorMap?: Dictionary<EntityClass>;
+    /** Inheritance type: 'sti' (Single Table Inheritance) or 'tpt' (Table-Per-Type). Only set on root entities. */
+    inheritanceType?: 'sti' | 'tpt';
+    /** For TPT: direct parent entity metadata (the entity this one extends). */
+    tptParent?: EntityMetadata;
+    /** For TPT: direct child entities (entities that extend this one). */
+    tptChildren?: EntityMetadata[];
+    /** For TPT: all non-abstract descendants, sorted by depth (deepest first). Precomputed during discovery. */
+    allTPTDescendants?: EntityMetadata[];
+    /** For TPT: synthetic property representing the join to the parent table (child PK → parent PK). */
+    tptParentProp?: EntityProperty;
+    /** For TPT: inverse of tptParentProp, used for joining from parent to child (parent PK → child PK). */
+    tptInverseProp?: EntityProperty;
+    /** For TPT: virtual discriminator property name (computed at query time, not persisted). */
+    tptDiscriminatorColumn?: string;
+    /** For TPT: properties defined only in THIS entity (not inherited from parent). */
+    ownProps?: EntityProperty<Entity>[];
     hasTriggers?: boolean;
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
@@ -997,4 +1049,3 @@ export interface EntitySchemaWithMeta<TName extends string = string, TTableName
 export type InferEntity<Schema> = Schema extends {
     '~entity': infer E;
 } ? E : Schema extends EntitySchema<infer Entity> ? Entity : Schema extends EntityClass<infer Entity> ? Entity : Schema;
-export {};

package/typings.js

@@ -64,8 +64,52 @@ export class EntityMetadata {
     getPrimaryProp() {
         return this.properties[this.primaryKeys[0]];
     }
-    createColumnMappingObject() {
-        return Object.values(this.properties).reduce((o, prop) => {
+    /**
+     * Creates a mapping from property names to field names.
+     * @param alias - Optional alias to prefix field names. Can be a string (same for all) or a function (per-property).
+     *                When provided, also adds toString() returning the alias for backwards compatibility with formulas.
+     * @param toStringAlias - Optional alias to return from toString(). Defaults to `alias` when it's a string.
+     */
+    createColumnMappingObject(alias, toStringAlias) {
+        const resolveAlias = typeof alias === 'function' ? alias : () => alias;
+        const defaultAlias = toStringAlias ?? (typeof alias === 'string' ? alias : undefined);
+        const result = Object.values(this.properties).reduce((o, prop) => {
+            if (prop.fieldNames) {
+                const propAlias = resolveAlias(prop);
+                o[prop.name] = propAlias ? `${propAlias}.${prop.fieldNames[0]}` : prop.fieldNames[0];
+            }
+            return o;
+        }, {});
+        // Add toString() for backwards compatibility when alias is provided
+        Object.defineProperty(result, 'toString', {
+            value: () => defaultAlias ?? '',
+            enumerable: false,
+        });
+        // Wrap in Proxy to detect old formula signature usage where the first param was FormulaTable.
+        // If user accesses `.alias` or `.qualifiedName` (FormulaTable-only properties), warn them.
+        const warnedProps = new Set(['alias', 'qualifiedName']);
+        return new Proxy(result, {
+            get(target, prop, receiver) {
+                if (typeof prop === 'string' && warnedProps.has(prop) && !(prop in target)) {
+                    // eslint-disable-next-line no-console
+                    console.warn(`[MikroORM] Detected old formula callback signature. The first parameter is now 'columns', not 'table'. ` +
+                        `Accessing '.${prop}' on the columns object will return undefined. ` +
+                        `Update your formula: formula(cols => quote\`\${cols.propName} ...\`). See the v7 upgrade guide.`);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    /**
+     * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
+     * For TPT entities, only includes properties that belong to the current table (ownProps).
+     */
+    createSchemaColumnMappingObject() {
+        // For TPT entities, only include properties that belong to this entity's table
+        const props = this.inheritanceType === 'tpt' && this.ownProps
+            ? this.ownProps
+            : Object.values(this.properties);
+        return props.reduce((o, prop) => {
             if (prop.fieldNames) {
                 o[prop.name] = prop.fieldNames[0];
             }
@@ -149,8 +193,8 @@ export class EntityMetadata {
             this.props.forEach(prop => this.initIndexes(prop));
         }
         this.definedProperties = this.trackingProps.reduce((o, prop) => {
-            const isReference = (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
-            if (isReference) {
+            const hasInverse = (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
+            if (hasInverse) {
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const meta = this;
                 o[prop.name] = {

package/unit-of-work/ChangeSet.d.ts

@@ -19,6 +19,8 @@ export interface ChangeSet<T> {
     payload: EntityDictionary<T>;
     persisted: boolean;
     originalEntity?: EntityData<T>;
+    /** For TPT: changesets for parent tables, ordered from immediate parent to root */
+    tptChangeSets?: ChangeSet<T>[];
 }
 export declare enum ChangeSetType {
     CREATE = "create",

package/unit-of-work/ChangeSetPersister.d.ts

@@ -43,6 +43,11 @@ export declare class ChangeSetPersister {
      * so we use a single query in case of both versioning and default values is used.
      */
     private reloadVersionValues;
+    /**
+     * For TPT child tables, resolve EntityIdentifier values in PK fields.
+     * The parent table insert assigns the actual PK value, which the child table references.
+     */
+    private resolveTPTIdentifiers;
     private processProperty;
     /**
      * Maps values returned via `returning` statement (postgres) or the inserted id (other sql drivers).

package/unit-of-work/ChangeSetPersister.js

@@ -116,6 +116,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
+        this.resolveTPTIdentifiers(changeSet);
         // Use changeSet's own meta for STI entities to get correct field mappings
         const res = await this.driver.nativeInsertMany(changeSet.meta.class, [changeSet.payload], options);
         if (!wrapped.hasPrimaryKey()) {
@@ -154,6 +155,9 @@ export class ChangeSetPersister {
             convertCustomTypes: false,
             processCollections: false,
         });
+        for (const changeSet of changeSets) {
+            this.resolveTPTIdentifiers(changeSet);
+        }
         const res = await this.driver.nativeInsertMany(meta.class, changeSets.map(cs => cs.payload), options);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
@@ -370,6 +374,21 @@ export class ChangeSetPersister {
             Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
     }
+    /**
+     * For TPT child tables, resolve EntityIdentifier values in PK fields.
+     * The parent table insert assigns the actual PK value, which the child table references.
+     */
+    resolveTPTIdentifiers(changeSet) {
+        if (changeSet.meta.inheritanceType !== 'tpt' || !changeSet.meta.tptParent) {
+            return;
+        }
+        for (const pk of changeSet.meta.primaryKeys) {
+            const value = changeSet.payload[pk];
+            if (value instanceof EntityIdentifier) {
+                changeSet.payload[pk] = value.getValue();
+            }
+        }
+    }
     processProperty(changeSet, prop) {
         const meta = changeSet.meta;
         const value = changeSet.payload[prop.name]; // for inline embeddables

package/unit-of-work/UnitOfWork.d.ts

@@ -96,6 +96,11 @@ export declare class UnitOfWork {
     getOrphanRemoveStack(): Set<AnyEntity>;
     getChangeSetPersister(): ChangeSetPersister;
     private findNewEntities;
+    /**
+     * For TPT inheritance, creates separate changesets for each table in the hierarchy.
+     * Uses the same entity instance for all changesets - only the metadata and payload differ.
+     */
+    private createTPTChangeSets;
     /**
      * Returns `true` when the change set should be skipped as it will be empty after the extra update.
      */

package/unit-of-work/UnitOfWork.js

@@ -559,7 +559,68 @@ export class UnitOfWork {
         }
         const changeSet = this.changeSetComputer.computeChangeSet(entity);
         if (changeSet && !this.checkUniqueProps(changeSet)) {
-            this.changeSets.set(entity, changeSet);
+            // For TPT child entities, create changesets for each table in hierarchy
+            if (wrapped.__meta.inheritanceType === 'tpt' && wrapped.__meta.tptParent) {
+                this.createTPTChangeSets(entity, changeSet);
+            }
+            else {
+                this.changeSets.set(entity, changeSet);
+            }
+        }
+    }
+    /**
+     * For TPT inheritance, creates separate changesets for each table in the hierarchy.
+     * Uses the same entity instance for all changesets - only the metadata and payload differ.
+     */
+    createTPTChangeSets(entity, originalChangeSet) {
+        const meta = helper(entity).__meta;
+        const isCreate = originalChangeSet.type === ChangeSetType.CREATE;
+        let current = meta;
+        let leafCs;
+        const parentChangeSets = [];
+        while (current) {
+            const isRoot = !current.tptParent;
+            const payload = {};
+            for (const prop of current.ownProps) {
+                if (prop.name in originalChangeSet.payload) {
+                    payload[prop.name] = originalChangeSet.payload[prop.name];
+                }
+            }
+            // For CREATE on non-root tables, include the PK (EntityIdentifier for deferred resolution)
+            if (isCreate && !isRoot) {
+                const wrapped = helper(entity);
+                const identifier = wrapped.__identifier;
+                const identifiers = Array.isArray(identifier) ? identifier : [identifier];
+                for (let i = 0; i < current.primaryKeys.length; i++) {
+                    const pk = current.primaryKeys[i];
+                    payload[pk] = identifiers[i] ?? originalChangeSet.payload[pk];
+                }
+            }
+            if (!isCreate && Object.keys(payload).length === 0) {
+                current = current.tptParent;
+                continue;
+            }
+            const cs = new ChangeSet(entity, originalChangeSet.type, payload, current);
+            if (current === meta) {
+                cs.originalEntity = originalChangeSet.originalEntity;
+                leafCs = cs;
+            }
+            else {
+                parentChangeSets.push(cs);
+            }
+            current = current.tptParent;
+        }
+        // When only parent properties changed (UPDATE), leaf payload is empty—create a stub anchor
+        if (!leafCs && parentChangeSets.length > 0) {
+            leafCs = new ChangeSet(entity, originalChangeSet.type, {}, meta);
+            leafCs.originalEntity = originalChangeSet.originalEntity;
+        }
+        // Store the leaf changeset in the main map (entity as key), with parent CSs attached
+        if (leafCs) {
+            if (parentChangeSets.length > 0) {
+                leafCs.tptChangeSets = parentChangeSets;
+            }
+            this.changeSets.set(entity, leafCs);
         }
     }
     /**
@@ -876,8 +937,20 @@ export class UnitOfWork {
                     }
                     return false;
                 });
+                continue;
+            }
+            const refEntity = Reference.unwrapReference(ref);
+            // For mapToPk properties, the value is a primitive (string/array), not an entity
+            if (!Utils.isEntity(refEntity)) {
+                continue;
+            }
+            // For TPT entities, check if the ROOT table's changeset has been persisted
+            // (since the FK is to the root table, not the concrete entity's table)
+            let cs = this.changeSets.get(refEntity);
+            if (cs?.tptChangeSets?.length) {
+                // Root table changeset is the last one (ordered immediate parent → root)
+                cs = cs.tptChangeSets[cs.tptChangeSets.length - 1];
             }
-            const cs = this.changeSets.get(Reference.unwrapReference(ref));
             const isScheduledForInsert = cs?.type === ChangeSetType.CREATE && !cs.persisted;
             if (isScheduledForInsert) {
                 this.scheduleExtraUpdate(changeSet, [prop]);
@@ -1000,12 +1073,23 @@ export class UnitOfWork {
             [ChangeSetType.UPDATE_EARLY]: new Map(),
             [ChangeSetType.DELETE_EARLY]: new Map(),
         };
-        for (const cs of this.changeSets.values()) {
+        const addToGroup = (cs) => {
+            // Skip stub TPT changesets with empty payload (e.g. leaf with no own-property changes on UPDATE)
+            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) && !Utils.hasObjectKeys(cs.payload)) {
+                return;
+            }
             const group = groups[cs.type];
-            const classGroup = group.get(cs.rootMeta) ?? [];
+            const groupKey = cs.meta.inheritanceType === 'tpt' ? cs.meta : cs.rootMeta;
+            const classGroup = group.get(groupKey) ?? [];
             classGroup.push(cs);
-            if (!group.has(cs.rootMeta)) {
-                group.set(cs.rootMeta, classGroup);
+            if (!group.has(groupKey)) {
+                group.set(groupKey, classGroup);
+            }
+        };
+        for (const cs of this.changeSets.values()) {
+            addToGroup(cs);
+            for (const parentCs of cs.tptChangeSets ?? []) {
+                addToGroup(parentCs);
             }
         }
         return groups;
@@ -1013,7 +1097,17 @@ export class UnitOfWork {
     getCommitOrder() {
         const calc = new CommitOrderCalculator();
         const set = new Set();
-        this.changeSets.forEach(cs => set.add(cs.rootMeta));
+        this.changeSets.forEach(cs => {
+            if (cs.meta.inheritanceType === 'tpt') {
+                set.add(cs.meta);
+                for (const parentCs of cs.tptChangeSets ?? []) {
+                    set.add(parentCs.meta);
+                }
+            }
+            else {
+                set.add(cs.rootMeta);
+            }
+        });
         set.forEach(meta => calc.addNode(meta._id));
         for (const meta of set) {
             for (const prop of meta.relations) {
@@ -1026,6 +1120,10 @@ export class UnitOfWork {
                     calc.discoverProperty(prop, meta._id);
                 }
             }
+            // For TPT, parent table must be inserted BEFORE child tables
+            if (meta.inheritanceType === 'tpt' && meta.tptParent && set.has(meta.tptParent)) {
+                calc.addDependency(meta.tptParent._id, meta._id, 1);
+            }
         }
         return calc.sort().map(id => this.metadata.getById(id));
     }

package/utils/AbstractSchemaGenerator.js

@@ -92,14 +92,23 @@ export class AbstractSchemaGenerator {
     getOrderedMetadata(schema) {
         const metadata = [...this.metadata.getAll().values()].filter(meta => {
             const isRootEntity = meta.root.class === meta.class;
-            return isRootEntity && !meta.embeddable && !meta.virtual;
+            const isTPTChild = meta.inheritanceType === 'tpt' && meta.tptParent;
+            return (isRootEntity || isTPTChild) && !meta.embeddable && !meta.virtual;
         });
         const calc = new CommitOrderCalculator();
-        metadata.forEach(meta => calc.addNode(meta.root._id));
+        metadata.forEach(meta => {
+            const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
+            calc.addNode(nodeId);
+        });
         let meta = metadata.pop();
         while (meta) {
+            const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
             for (const prop of meta.relations) {
-                calc.discoverProperty(prop, meta.root._id);
+                calc.discoverProperty(prop, nodeId);
+            }
+            if (meta.inheritanceType === 'tpt' && meta.tptParent) {
+                const parentId = meta.tptParent._id;
+                calc.addDependency(parentId, nodeId, 1);
             }
             meta = metadata.pop();
         }

package/utils/EntityComparator.js

@@ -215,7 +215,7 @@ export class EntityComparator {
         const context = new Map();
         context.set('clone', clone);
         context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
-        if (meta.discriminatorValue) {
+        if (meta.root.inheritanceType === 'sti' && meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.228';
+    static #ORM_VERSION = '7.0.0-dev.229';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */