@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/typings.js

@@ -1,8 +1,10 @@
 import { ReferenceKind, } from './enums.js';
 import { Reference } from './entity/Reference.js';
 import { EntityHelper } from './entity/EntityHelper.js';
+import { helper } from './entity/wrap.js';
 import { Utils } from './utils/Utils.js';
 import { EntityComparator } from './utils/EntityComparator.js';
+import { BaseEntity } from './entity/BaseEntity.js';
 export const EntityRepositoryType = Symbol('EntityRepositoryType');
 export const PrimaryKeyProp = Symbol('PrimaryKeyProp');
 export const OptionalProps = Symbol('OptionalProps');
@@ -25,22 +27,24 @@ export class EntityMetadata {
         this.referencingProperties = [];
         this.concurrencyCheckKeys = new Set();
         Object.assign(this, meta);
-    }
-    addProperty(prop, sync = true) {
-        if (prop.pivotTable && !prop.pivotEntity) {
-            prop.pivotEntity = prop.pivotTable;
+        const name = meta.className ?? meta.name;
+        if (!this.class && name) {
+            const Class = this.extends === BaseEntity
+                ? ({ [name]: class extends BaseEntity {
+                    } })[name]
+                : ({ [name]: class {
+                    } })[name];
+            this.class = Class;
         }
+    }
+    addProperty(prop) {
         this.properties[prop.name] = prop;
         this.propertyOrder.set(prop.name, this.props.length);
-        /* v8 ignore next */
-        if (sync) {
-            this.sync();
-        }
+        this.sync();
     }
     removeProperty(name, sync = true) {
         delete this.properties[name];
         this.propertyOrder.delete(name);
-        /* v8 ignore next */
         if (sync) {
             this.sync();
         }
@@ -60,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];
             }
@@ -74,6 +122,9 @@ export class EntityMetadata {
     set tableName(name) {
         this.collection = name;
     }
+    get uniqueName() {
+        return this.tableName + '_' + this._id;
+    }
     sync(initIndexes = false, config) {
         this.root ??= this;
         const props = Object.values(this.properties).sort((a, b) => this.propertyOrder.get(a.name) - this.propertyOrder.get(b.name));
@@ -100,10 +151,19 @@ export class EntityMetadata {
             return !prop.getter && !prop.setter && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
         });
         this.selfReferencing = this.relations.some(prop => {
-            return [this.className, this.root.className].includes(prop.targetMeta?.root.className ?? prop.type);
+            return this.root.uniqueName === prop.targetMeta?.root.uniqueName;
         });
         this.hasUniqueProps = this.uniques.length + this.uniqueProps.length > 0;
-        this.virtual = !!this.expression;
+        // Normalize object-form `view` option: `view: { materialized: true, withData: false }`
+        // into flat metadata fields (`view: true`, `materialized: true`, `withData: false`).
+        if (typeof this.view === 'object') {
+            this.materialized = this.view.materialized;
+            this.withData = this.view.withData;
+            this.view = true;
+        }
+        // If `view` is set, this is a database view entity (not a virtual entity).
+        // Virtual entities evaluate expressions at query time, view entities create actual database views.
+        this.virtual = !!this.expression && !this.view;
         if (config) {
             for (const prop of this.props) {
                 if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
@@ -126,15 +186,15 @@ export class EntityMetadata {
         for (const hook of Utils.keys(this.hooks)) {
             this.hooks[hook] = Utils.removeDuplicates(this.hooks[hook]);
         }
-        if (this.virtual) {
+        if (this.virtual || this.view) {
             this.readonly = true;
         }
         if (initIndexes && this.name) {
             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] = {
@@ -152,7 +212,10 @@ export class EntityMetadata {
                         wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                         // when propagation from inside hydration, we set the FK to the entity data immediately
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                            wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
+                            const targetMeta = prop.targetMeta ?? helper(entity)?.__meta;
+                            if (targetMeta) {
+                                wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, targetMeta, true);
+                            }
                         }
                         EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
                     },
@@ -191,4 +254,8 @@ export class EntityMetadata {
     clone() {
         return this;
     }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `[${this.constructor.name}<${this.className}>]`;
+    }
 }

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

@@ -11,15 +11,16 @@ export declare class ChangeSet<T extends object> {
     getSerializedPrimaryKey(): string | null;
 }
 export interface ChangeSet<T> {
-    name: string;
-    rootName: string;
-    collection: string;
+    meta: EntityMetadata<T>;
+    rootMeta: EntityMetadata<T>;
     schema?: string;
     type: ChangeSetType;
     entity: 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/ChangeSet.js

@@ -13,9 +13,8 @@ export class ChangeSet {
         this.type = type;
         this.payload = payload;
         this.meta = meta;
-        this.name = meta.className;
-        this.rootName = meta.root.className;
-        this.collection = meta.root.collection;
+        this.meta = meta;
+        this.rootMeta = meta.root;
         this.schema = helper(entity).__schema ?? meta.root.schema;
     }
     getPrimaryKey(object = false) {

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

@@ -1,18 +1,15 @@
-import { type Configuration } from '../utils/Configuration.js';
-import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { AnyEntity } from '../typings.js';
 import { ChangeSet } from './ChangeSet.js';
 import { type Collection } from '../entity/Collection.js';
-import type { Platform } from '../platforms/Platform.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetComputer {
+    private readonly em;
     private readonly collectionUpdates;
+    private readonly comparator;
     private readonly metadata;
     private readonly platform;
     private readonly config;
-    private readonly em;
-    private readonly comparator;
-    constructor(collectionUpdates: Set<Collection<AnyEntity>>, metadata: MetadataStorage, platform: Platform, config: Configuration, em: EntityManager);
+    constructor(em: EntityManager, collectionUpdates: Set<Collection<AnyEntity>>);
     computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
     /**
      * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.

package/unit-of-work/ChangeSetComputer.js

@@ -1,25 +1,28 @@
 import { Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 import { ChangeSet, ChangeSetType } from './ChangeSet.js';
 import { helper } from '../entity/wrap.js';
 import { validateEntity } from '../entity/validators.js';
+import { Reference } from '../entity/Reference.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetComputer {
+    em;
     collectionUpdates;
+    comparator;
     metadata;
     platform;
     config;
-    em;
-    comparator;
-    constructor(collectionUpdates, metadata, platform, config, em) {
-        this.collectionUpdates = collectionUpdates;
-        this.metadata = metadata;
-        this.platform = platform;
-        this.config = config;
+    constructor(em, collectionUpdates) {
         this.em = em;
+        this.collectionUpdates = collectionUpdates;
+        this.config = this.em.config;
+        this.metadata = this.em.getMetadata();
+        this.platform = this.em.getPlatform();
         this.comparator = this.config.getComparator(this.metadata);
     }
     computeChangeSet(entity) {
-        const meta = this.metadata.get(entity.constructor.name);
+        const meta = this.metadata.get(entity.constructor);
         if (meta.readonly) {
             return null;
         }
@@ -91,7 +94,7 @@ export class ChangeSetComputer {
     computePayload(entity, ignoreUndefined = false) {
         const data = this.comparator.prepareEntity(entity);
         const wrapped = helper(entity);
-        const entityName = wrapped.__meta.className;
+        const entityName = wrapped.__meta.class;
         const originalEntityData = wrapped.__originalEntityData;
         if (!wrapped.__initialized) {
             for (const prop of wrapped.__meta.primaryKeys) {
@@ -130,9 +133,25 @@ export class ChangeSetComputer {
             return;
         }
         const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
-        targets.forEach(([target, idx]) => {
-            if (!target.__helper.hasPrimaryKey()) {
-                Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
+        targets.forEach(([rawTarget, idx]) => {
+            const target = Reference.unwrapReference(rawTarget);
+            const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
+            if (needsProcessing) {
+                let value = prop.targetKey ? target[prop.targetKey] : target.__helper.__identifier;
+                /* v8 ignore next */
+                if (prop.targetKey && prop.targetMeta) {
+                    const targetProp = prop.targetMeta.properties[prop.targetKey];
+                    if (targetProp?.customType) {
+                        value = targetProp.customType.convertToDatabaseValue(value, this.platform, { mode: 'serialization' });
+                    }
+                }
+                if (prop.polymorphic) {
+                    const discriminator = QueryHelper.findDiscriminatorValue(prop.discriminatorMap, target.constructor);
+                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, new PolymorphicRef(discriminator, value), idx);
+                }
+                else {
+                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
+                }
             }
         });
     }
@@ -145,7 +164,9 @@ export class ChangeSetComputer {
             this.collectionUpdates.add(target);
         }
         if (prop.owner && !this.platform.usesPivotTable()) {
-            changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
+            changeSet.payload[prop.name] = target.getItems(false).map((item) => {
+                return item.__helper.__identifier ?? item.__helper.getPrimaryKey();
+            });
         }
     }
 }

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

@@ -1,21 +1,18 @@
-import type { MetadataStorage } from '../metadata/MetadataStorage.js';
-import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings.js';
-import { type EntityFactory } from '../entity/EntityFactory.js';
+import type { Dictionary, EntityDictionary, EntityMetadata } from '../typings.js';
 import { type ChangeSet } from './ChangeSet.js';
-import { type Configuration } from '../utils/Configuration.js';
-import type { DriverMethodOptions, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+import type { DriverMethodOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetPersister {
+    private readonly em;
+    private readonly platform;
+    private readonly comparator;
+    private readonly usesReturningStatement;
     private readonly driver;
     private readonly metadata;
     private readonly hydrator;
     private readonly factory;
     private readonly config;
-    private readonly em;
-    private readonly platform;
-    private readonly comparator;
-    private readonly usesReturningStatement;
-    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, config: Configuration, em: EntityManager);
+    constructor(em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
@@ -43,6 +40,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

@@ -1,4 +1,5 @@
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { helper } from '../entity/wrap.js';
 import { ChangeSetType } from './ChangeSet.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
@@ -6,23 +7,23 @@ import { Utils } from '../utils/Utils.js';
 import { OptimisticLockError, ValidationError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetPersister {
+    em;
+    platform;
+    comparator;
+    usesReturningStatement;
     driver;
     metadata;
     hydrator;
     factory;
     config;
-    em;
-    platform;
-    comparator;
-    usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, config, em) {
-        this.driver = driver;
-        this.metadata = metadata;
-        this.hydrator = hydrator;
-        this.factory = factory;
-        this.config = config;
+    constructor(em) {
         this.em = em;
+        this.driver = this.em.getDriver();
+        this.config = this.em.config;
+        this.metadata = this.em.getMetadata();
+        this.factory = this.em.getEntityFactory();
         this.platform = this.driver.getPlatform();
+        this.hydrator = this.config.getHydrator(this.metadata);
         this.comparator = this.config.getComparator(this.metadata);
         this.usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
     }
@@ -30,7 +31,7 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeInserts', options);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
         if (changeSets.length > 1 && this.config.get('useBatchInserts', this.platform.usesBatchInserts())) {
             return this.persistNewEntities(meta, changeSets, options);
@@ -43,9 +44,12 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeUpdates', options, batched);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
-        if (batched && changeSets.length > 1 && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
+        // For STI with conflicting fieldNames (renamedFrom properties), we can't batch mixed child types
+        const hasSTIConflicts = meta.root.props.some(p => p.renamedFrom);
+        const hasMixedTypes = hasSTIConflicts && changeSets.some(cs => cs.meta.class !== meta.class);
+        if (batched && changeSets.length > 1 && !hasMixedTypes && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
         }
         for (const changeSet of changeSets) {
@@ -63,7 +67,7 @@ export class ChangeSetPersister {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
             options = this.prepareOptions(meta, options);
-            await this.driver.nativeDelete(meta.root.className, { [pk]: { $in: pks } }, options);
+            await this.driver.nativeDelete(meta.root.class, { [pk]: { $in: pks } }, options);
         }
     }
     async runForEachSchema(changeSets, method, options, ...args) {
@@ -99,7 +103,7 @@ export class ChangeSetPersister {
         }
     }
     processProperties(changeSet) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
@@ -112,7 +116,9 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
+        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()) {
             this.mapPrimaryKey(meta, res.insertId, changeSet);
         }
@@ -149,7 +155,10 @@ export class ChangeSetPersister {
             convertCustomTypes: false,
             processCollections: false,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, changeSets.map(cs => cs.payload), options);
+        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];
             const wrapped = helper(changeSet.entity);
@@ -167,7 +176,7 @@ export class ChangeSetPersister {
         }
     }
     async persistManagedEntity(changeSet, options) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const res = await this.updateEntity(meta, changeSet, options);
         this.checkOptimisticLock(meta, changeSet, res);
         this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
@@ -208,7 +217,7 @@ export class ChangeSetPersister {
             cond.push(where);
             payload.push(changeSet.payload);
         }
-        const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
+        const res = await this.driver.nativeUpdateMany(meta.class, cond, payload, options);
         const map = new Map();
         res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
@@ -260,13 +269,13 @@ export class ChangeSetPersister {
             convertCustomTypes: false,
         });
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
-            return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+            return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
             cond[meta.versionProperty] = this.platform.quoteVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
-        return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+        return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
@@ -286,7 +295,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
-        const res = await this.driver.find(meta.root.className, { $or }, options);
+        const res = await this.driver.find(meta.root.class, { $or }, options);
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
@@ -356,7 +365,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
-        const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
+        const data = await this.driver.find(meta.class, { [pk]: { $in: pks } }, options);
         const map = new Map();
         data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
@@ -365,13 +374,34 @@ 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 = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const value = changeSet.payload[prop.name]; // for inline embeddables
         if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
             return;
         }
+        if (value instanceof PolymorphicRef) {
+            if (value.id instanceof EntityIdentifier) {
+                value.id = value.id.getValue();
+            }
+            return;
+        }
         if (Array.isArray(value) && value.every(item => item instanceof EntityIdentifier)) {
             changeSet.payload[prop.name] = value.map(item => item.getValue());
             return;
@@ -399,7 +429,7 @@ export class ChangeSetPersister {
         if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
-        const mapped = this.comparator.mapResult(meta.className, row);
+        const mapped = this.comparator.mapResult(meta, row);
         if (entity) {
             this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
         }

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

@@ -1,17 +1,18 @@
-import type { Dictionary, EntityProperty } from '../typings.js';
+import type { EntityProperty } from '../typings.js';
 export declare const enum NodeState {
     NOT_VISITED = 0,
     IN_PROGRESS = 1,
     VISITED = 2
 }
+type Hash = number;
 export interface Node {
-    hash: string;
+    hash: Hash;
     state: NodeState;
-    dependencies: Dictionary<Edge>;
+    dependencies: Map<Hash, Edge>;
 }
 export interface Edge {
-    from: string;
-    to: string;
+    from: Hash;
+    to: Hash;
     weight: number;
 }
 /**
@@ -32,23 +33,23 @@ export declare class CommitOrderCalculator {
     /**
      * Checks for node existence in graph.
      */
-    hasNode(hash: string): boolean;
+    hasNode(hash: Hash): boolean;
     /**
      * Adds a new node to the graph, assigning its hash.
      */
-    addNode(hash: string): void;
+    addNode(hash: Hash): void;
     /**
      * Adds a new dependency (edge) to the graph using their hashes.
      */
-    addDependency(from: string, to: string, weight: number): void;
-    discoverProperty(prop: EntityProperty, entityName: string): void;
+    addDependency(from: Hash, to: Hash, weight: number): void;
+    discoverProperty(prop: EntityProperty, entityName: Hash): void;
     /**
      * Return a valid order list of all current nodes.
      * The desired topological sorting is the reverse post order of these searches.
      *
      * @internal Highly performance-sensitive method.
      */
-    sort(): string[];
+    sort(): Hash[];
     /**
      * Visit a given node definition for reordering.
      *
@@ -60,3 +61,4 @@ export declare class CommitOrderCalculator {
      */
     private visitOpenNode;
 }
+export {};