@mikro-orm/core 7.2.0-dev.13 → 7.2.0-dev.14

package/EntityManager.js

@@ -1,4 +1,4 @@
-import { getOnConflictReturningFields, getWhereCondition, resetUntouchedCollections } from './utils/upsert-utils.js';
+import { getOnConflictReturningFields, getOnCreateGeneratedFields, getWhereCondition, resetUntouchedCollections, } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
 import { QueryHelper } from './utils/QueryHelper.js';
@@ -260,7 +260,7 @@ export class EntityManager {
     addFilter(options) {
         options = { ...options };
         if (options.entity) {
-            options.entity = Utils.asArray(options.entity).map(n => Utils.className(n));
+            options.entity = Utils.asArray(options.entity).map(n => Utils.classOrName(n));
         }
         options.default ??= true;
         this.getContext(false).#filters[options.name] = options;
@@ -793,6 +793,7 @@ export class EntityManager {
         }
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data);
+        let generatedFields = [];
         if (Utils.isEntity(data)) {
             entity = data;
             if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
@@ -800,6 +801,7 @@ export class EntityManager {
                 return entity;
             }
             where = helper(entity).getPrimaryKey();
+            generatedFields = getOnCreateGeneratedFields(meta, entity);
             em.#entityFactory.assignDefaultValues(entity, meta);
             data = em.#comparator.prepareEntity(entity);
         }
@@ -812,6 +814,7 @@ export class EntityManager {
                     return em.assign(exists, data);
                 }
             }
+            generatedFields = getOnCreateGeneratedFields(meta, data);
             em.#entityFactory.assignDefaultValues(data, meta, true);
             for (const key of Object.keys(data)) {
                 const prop = meta.properties[key];
@@ -820,6 +823,10 @@ export class EntityManager {
                 }
             }
         }
+        // `onCreate` generated values are for the insert clause only, they must not overwrite an existing row
+        if (generatedFields.length > 0 && !options.onConflictMergeFields) {
+            options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
+        }
         where = getWhereCondition(meta, options.onConflictFields, data, where).where;
         data = QueryHelper.processObjectParams(data);
         validateParams(data, 'insert data');
@@ -939,6 +946,7 @@ export class EntityManager {
         }
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data[0]);
+        const generatedFields = new Set();
         const allData = [];
         const allWhere = [];
         const entities = new Map();
@@ -956,6 +964,7 @@ export class EntityManager {
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
+                getOnCreateGeneratedFields(meta, entity).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(entity, meta);
                 entitiesByAllDataIdx.set(allData.length, entity);
                 row = em.#comparator.prepareEntity(entity);
@@ -972,6 +981,7 @@ export class EntityManager {
                         continue;
                     }
                 }
+                getOnCreateGeneratedFields(meta, row).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(row, meta, true);
                 for (const key of Object.keys(row)) {
                     const prop = meta.properties[key];
@@ -1000,6 +1010,10 @@ export class EntityManager {
         if (entities.size === data.length) {
             return [...entities.keys()];
         }
+        // `onCreate` generated values are for the insert clause only, they must not overwrite existing rows
+        if (generatedFields.size > 0 && !options.onConflictMergeFields) {
+            options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
+        }
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
             for (const dto of data) {
                 const entity = entitiesByData.get(dto) ?? dto;
@@ -1649,8 +1663,9 @@ export class EntityManager {
         }
         // 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) {
+        // use an own-property check so inherited `Object.prototype` members (e.g. `__proto__`, `constructor`) are not treated as populatable
+        const ret = Object.hasOwn(meta.properties, p);
+        if (ret && parts.length > 0) {
             return this.canPopulate(meta.properties[p].targetMeta.class, parts.join('.'));
         }
         return ret;
@@ -2109,7 +2124,11 @@ export class EntityManager {
         ]) {
             delete opts[k];
         }
-        return [Utils.className(entityName), method, opts, where];
+        // the table name (plus discriminator value for STI) is stable across builds and processes,
+        // unlike class names, which minifiers can mangle to the same short name for two entities
+        const meta = this.metadata.find(entityName);
+        const key = meta?.tableName ? [meta.schema, meta.tableName, meta.discriminatorValue] : Utils.className(entityName);
+        return [key, method, opts, where];
     }
     /**
      * @internal

package/drivers/IDatabaseDriver.d.ts

@@ -345,6 +345,7 @@ export interface CountByOptions<T extends object> {
     filters?: FilterOptions;
     having?: FilterQuery<T>;
     schema?: string;
+    connectionType?: ConnectionType;
     flushMode?: FlushMode | `${FlushMode}`;
     loggerContext?: LogContext;
     logging?: LoggingOptions;

package/entity/EntityFactory.js

@@ -77,6 +77,12 @@ export class EntityFactory {
             }
         }
         data = { ...data };
+        if (options.newEntity && meta2.root.inheritanceType === 'sti' && meta2.discriminatorValue != null) {
+            const prop = meta2.properties[meta2.root.discriminatorColumn];
+            if (prop && prop.userDefined !== false) {
+                data[prop.name] ??= meta2.discriminatorValue;
+            }
+        }
         const entity = exists ?? this.createEntity(data, meta2, options);
         wrapped = helper(entity);
         wrapped.__processing = true;

package/entity/EntityLoader.js

@@ -1,5 +1,5 @@
 import { QueryHelper } from '../utils/QueryHelper.js';
-import { Utils } from '../utils/Utils.js';
+import { DANGEROUS_PROPERTY_NAMES, Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
 import { LoadStrategy, PopulatePath, ReferenceKind, } from '../enums.js';
 import { Reference } from './Reference.js';
@@ -124,10 +124,10 @@ export class EntityLoader {
     mergeNestedPopulate(populate) {
         const tmp = populate.reduce((ret, item) => {
             /* v8 ignore next */
-            if (item.field === PopulatePath.ALL) {
+            if (item.field === PopulatePath.ALL || DANGEROUS_PROPERTY_NAMES.includes(item.field)) {
                 return ret;
             }
-            if (!ret[item.field]) {
+            if (!Object.hasOwn(ret, item.field)) {
                 ret[item.field] = item;
                 return ret;
             }
@@ -229,9 +229,10 @@ export class EntityLoader {
                 }
                 toPopulate.push(entity);
             }
-            else if (refValue == null && !helper(entity).__loadedProperties.has(prop.name)) {
+            else if (refValue == null && !prop.object && !helper(entity).__loadedProperties.has(prop.name)) {
                 // FK columns weren't loaded (partial loading) — need to re-fetch them.
                 // If the property IS in __loadedProperties, the FK was loaded and is genuinely null.
+                // Object-embedded virtual props are skipped — they are populated via the embeddable instance.
                 needsFkLoad.push(entity);
             }
         }
@@ -445,7 +446,10 @@ export class EntityLoader {
                 }
             }
         }
-        if ([ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && items.length !== children.length) {
+        // a missing target row means an orphaned reference, unless the query was narrowed by a populate condition
+        if ([ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) &&
+            items.length !== children.length &&
+            Utils.isEmpty(options.where)) {
             const nullVal = this.#em.config.get('forceUndefined') ? undefined : null;
             const itemsMap = new Set();
             const childrenMap = new Set();
@@ -667,7 +671,8 @@ export class EntityLoader {
                     }
                     return cond;
                 });
-                if (child.length > 0) {
+                // partial extraction from `$or` is unsound — the parent may have matched via a dropped branch
+                if (child.length > 0 && (op === '$and' || child.length === where[op].length)) {
                     subCond[op] = child;
                 }
             }

package/entity/EntityRepository.js

@@ -224,7 +224,11 @@ export class EntityRepository {
         }
         const entityName = entities[0].constructor.name;
         const repoType = Utils.className(this.entityName);
-        if (entityName && repoType !== entityName) {
+        // compare class identity where possible, as minifiers can mangle two classes to the same name
+        const entityMeta = entities[0].__meta;
+        const repoMeta = this.getEntityManager().getMetadata?.().find(this.entityName);
+        const mismatch = entityMeta && repoMeta ? entityMeta.class !== repoMeta.class : entityName && repoType !== entityName;
+        if (mismatch) {
             throw ValidationError.fromWrongRepositoryType(entityName, repoType, method);
         }
     }

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, LazyRef, IndexCallback, TriggerCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise, IndexHints, ExtractDefineEntityProperties } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, LazyRef, IndexCallback, TriggerCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise, IndexHints, OptionalProps, ExtractDefineEntityProperties } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -22,7 +22,7 @@ type HasKind<Options, K extends string> = Options extends {
     kind: infer X extends string;
 } ? X extends K ? true : false : false;
 /** Lightweight chain result type for property builders - reduces type instantiation cost by avoiding full class resolution. */
-export interface PropertyChain<Value, Options> {
+export interface PropertyChain<in out Value, in out Options> {
     '~type'?: {
         value: Value;
     };
@@ -112,7 +112,7 @@ export interface PropertyChain<Value, Options> {
     getter(getter?: boolean): PropertyChain<Value, Options>;
     getterName(getterName: string): PropertyChain<Value, Options>;
     serializedPrimaryKey(serializedPrimaryKey?: boolean): PropertyChain<Value, Options>;
-    serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
+    serializer(serializer: (value: SerializerValue<Value, Options>, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
     serializedName(serializedName: string): PropertyChain<Value, Options>;
     groups(...groups: string[]): PropertyChain<Value, Options>;
     customOrder(...customOrder: string[] | number[] | boolean[]): PropertyChain<Value, Options>;
@@ -180,7 +180,7 @@ export interface PropertyChain<Value, Options> {
     foreignKeyName(foreignKeyName: string): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
 }
 /** @internal */
-export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys extends BuilderKeys> implements Record<Exclude<UniversalPropertyKeys, ExcludeKeys>, any> {
+export declare class UniversalPropertyOptionsBuilder<in out Value, in out Options, in out IncludeKeys extends BuilderKeys> implements Record<Exclude<UniversalPropertyKeys, ExcludeKeys>, any> {
     '~options': Options;
     '~type'?: {
         value: Value;
@@ -627,7 +627,7 @@ type PartialWhere<TProperties, TBase> = string | FilterQuery<{
     [K in AllKeys<TProperties, TBase> & string]?: unknown;
 }>;
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined, TEmbeddable extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
@@ -649,6 +649,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         strict?: boolean;
     }>;
     forceObject?: TForceObject;
+    embeddable?: TEmbeddable;
     inheritance?: 'tpt';
     orderBy?: {
         [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
@@ -699,7 +700,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     }[];
 }
 /** Defines an entity schema using property builders, with full type inference from the property definitions. */
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false, const TDiscriminatorColumn extends string | undefined = undefined, const TDiscriminatorValue extends string | number | undefined = undefined, const TBaseDiscriminatorColumn extends string | undefined = undefined>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject, TDiscriminatorColumn, TDiscriminatorValue, TBaseDiscriminatorColumn>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue>, TBase, TProperties, EntityCtor<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue>>, TDiscriminatorColumn>;
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false, const TDiscriminatorColumn extends string | undefined = undefined, const TDiscriminatorValue extends string | number | undefined = undefined, const TBaseDiscriminatorColumn extends string | undefined = undefined, const TEmbeddable extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject, TDiscriminatorColumn, TDiscriminatorValue, TBaseDiscriminatorColumn, TEmbeddable>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue, TEmbeddable>, TBase, TProperties, EntityCtor<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue, TEmbeddable>>, TDiscriminatorColumn>;
 export declare namespace defineEntity {
     export { propertyBuilders as properties };
 }
@@ -734,22 +735,24 @@ type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJ
 type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TValue> : never;
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
 type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
+interface BaseEntityMethods<in out Entity extends object> extends Pick<IWrappedEntity<Entity>, BaseEntityMethodKeys> {
+}
 /** Infers the entity type from a `defineEntity()` properties map, resolving builders, base classes, and primary keys. */
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false, BaseDiscriminatorColumn extends string | undefined = undefined, DiscriminatorValue extends string | number | undefined = undefined> = (IsNever<Base> extends true ? {} : Base extends {
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false, BaseDiscriminatorColumn extends string | undefined = undefined, DiscriminatorValue extends string | number | undefined = undefined, Embeddable extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
     toObject(...args: any[]): any;
-} ? Pick<IWrappedEntity<{
+} ? BaseEntityMethods<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue>>, BaseEntityMethodKeys> : {}) & {
+}) & NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue, Embeddable>> : {}) & {
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & (IsNever<Base> extends true ? {} : NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue>) & (ForceObject extends true ? {
+}) & (IsNever<Base> extends true ? {} : NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue, Embeddable>) & (ForceObject extends true ? {
     [Config]?: DefineConfig<{
         forceObject: true;
     }>;
@@ -757,13 +760,26 @@ export type InferEntityFromProperties<Properties extends Record<string, any>, PK
     [IndexHints]?: [Omit<ExtractBaseProperties<Base>, keyof Properties> & Properties];
 };
 type ExtractBaseProperties<Base> = [ExtractDefineEntityProperties<Base>] extends [infer P extends Record<string, any>] ? [P] extends [never] ? {} : P : {};
-type NarrowDiscriminator<Base, DiscColumn extends string | undefined, DiscValue> = DiscColumn extends string ? DiscColumn extends keyof Base ? DiscValue extends string | number ? Omit<Base, DiscColumn> & {
+type ExtractOptionalProps<Base> = Base extends {
+    [OptionalProps]?: infer K;
+} ? (K extends string ? K : never) : never;
+type NarrowDiscriminator<Base, DiscColumn extends string | undefined, DiscValue, Embeddable extends boolean = false> = DiscColumn extends string ? DiscColumn extends keyof Base ? DiscValue extends string | number ? Embeddable extends true ? Omit<Base, DiscColumn> & {
+    [K in DiscColumn]: DiscValue;
+} : Omit<Base, DiscColumn | typeof OptionalProps> & {
     [K in DiscColumn]: DiscValue;
+} & {
+    [OptionalProps]?: DiscColumn | ExtractOptionalProps<Base>;
 } : Base : Base : Base;
 type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> = PK extends undefined ? CombinePrimaryKeys<InferPrimaryKey<Properties>, ExtractBasePrimaryKey<Base>> : PK;
-type ExtractBasePrimaryKey<Base> = Base extends {
+type ExtractBasePrimaryKey<Base> = typeof PrimaryKeyProp extends keyof Base ? Base extends {
     [PrimaryKeyProp]?: infer BasePK;
-} ? BasePK : never;
+} ? BasePK : never : [keyof Base] extends [never] ? never : Base extends {
+    _id?: any;
+} ? '_id' : Base extends {
+    id?: any;
+} ? 'id' : Base extends {
+    uuid?: any;
+} ? 'uuid' : never;
 type CombinePrimaryKeys<ChildPK, BasePK> = [ChildPK] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
 /** Extracts the primary key property names from a properties map by finding builders with `primary: true`. */
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
@@ -790,6 +806,8 @@ type InferBuilderValue<Builder> = Builder extends {
 type MaybeArray<Value, Options> = Options extends {
     array: true;
 } ? Value[] : Value;
+/** The runtime value passed to a custom serializer — the property value as stored on the entity (e.g. `Collection`/`Ref` for relations). Skips `MaybeMapToPk`, as its `Primary<Value>` branch is too costly for the type checker. */
+type SerializerValue<Value, Options> = MaybeNullable<MaybeRelationRef<MaybeArray<Value, Options>, Options>, Options>;
 type MaybeMapToPk<Value, Options> = Options extends {
     mapToPk: true;
 } ? Primary<Value> : Value;

package/entity/defineEntity.js

@@ -496,7 +496,7 @@ export class StringPropertyOptionsBuilder extends UniversalPropertyOptionsBuilde
 export class OneToManyOptionsBuilderOnlyMappedBy extends UniversalPropertyOptionsBuilder {
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
-        return new UniversalPropertyOptionsBuilder({ ...this['~options'], mappedBy });
+        return this.assignOptions({ mappedBy });
     }
 }
 function createPropertyBuilders(options) {

package/errors.d.ts

@@ -60,6 +60,7 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
+    static ambiguousEntityName(className: string): MetadataError;
     static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError;
     static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError;
     static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError;

package/errors.js

@@ -195,6 +195,9 @@ export class MetadataError extends ValidationError {
     static missingMetadata(entity) {
         return new MetadataError(`Metadata for entity ${entity} not found`);
     }
+    static ambiguousEntityName(className) {
+        return new MetadataError(`Entity name '${className}' is ambiguous, multiple discovered entity classes share it (possibly due to a minifier mangling class names). Use a class reference instead of a string name.`);
+    }
     static invalidPrimaryKey(meta, prop, requiredName) {
         return this.fromMessage(meta, prop, `has wrong field name, '${requiredName}' is required in current driver`);
     }

package/events/EventManager.js

@@ -43,7 +43,10 @@ export class EventManager {
         }));
         for (const listener of this.#listeners[event] ?? new Set()) {
             const entities = this.#entities.get(listener);
-            if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
+            if (entities.size === 0 ||
+                !entity ||
+                entities.has(entity.constructor) ||
+                entities.has(entity.constructor.name)) {
                 listeners.push(listener[event].bind(listener));
             }
         }
@@ -68,7 +71,7 @@ export class EventManager {
         }
         for (const listener of this.#listeners[event] ?? new Set()) {
             const entities = this.#entities.get(listener);
-            if (entities.size === 0 || entities.has(meta.className)) {
+            if (entities.size === 0 || entities.has(meta.class) || entities.has(meta.className)) {
                 this.#cache.set(cacheKey, true);
                 return true;
             }
@@ -84,6 +87,6 @@ export class EventManager {
         if (!listener.getSubscribedEntities) {
             return new Set();
         }
-        return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
+        return new Set(listener.getSubscribedEntities().map(name => Utils.classOrName(name)));
     }
 }

package/hydration/ObjectHydrator.d.ts

@@ -19,6 +19,8 @@ export declare class ObjectHydrator extends Hydrator {
     getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference', normalizeAccessors?: boolean): EntityHydrator<T>;
     private createCollectionItemMapper;
     private wrap;
+    /** Renders a key as a single-quoted JS string literal, safe to embed in generated code. */
+    private quote;
     private safeKey;
 }
 export {};

package/hydration/ObjectHydrator.js

@@ -87,7 +87,7 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`  if (data${dataKey} === null) {`);
             if (prop.ref) {
                 ret.push(`    entity${entityKey} = new ScalarReference();`);
-                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`    entity${entityKey}.bind(entity, ${this.quote(prop.name)});`);
                 ret.push(`    entity${entityKey}.set(${nullVal});`);
             }
             else {
@@ -127,14 +127,14 @@ export class ObjectHydrator extends Hydrator {
             if (prop.ref) {
                 ret.push(`    const value = isScalarReference(entity${entityKey}) ? entity${entityKey}.unwrap() : entity${entityKey};`);
                 ret.push(`    entity${entityKey} = oldValue_${idx} ?? new ScalarReference(value);`);
-                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`    entity${entityKey}.bind(entity, ${this.quote(prop.name)});`);
                 ret.push(`    entity${entityKey}.set(value);`);
             }
             ret.push(`  }`);
             if (prop.ref) {
                 ret.push(`  if (!entity${entityKey}) {`);
                 ret.push(`    entity${entityKey} = new ScalarReference();`);
-                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`    entity${entityKey}.bind(entity, ${this.quote(prop.name)});`);
                 ret.push(`  }`);
             }
             return ret;
@@ -220,7 +220,7 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`  }`);
             ret.push(`  if (Array.isArray(data${dataKey})) {`);
             ret.push(`    const items = data${dataKey}.map(value => createCollectionItem_${this.safeKey(prop.name)}(value, entity));`);
-            ret.push(`    const coll = Collection.create(entity, '${prop.name}', items, newEntity);`);
+            ret.push(`    const coll = Collection.create(entity, ${this.quote(prop.name)}, items, newEntity);`);
             ret.push(`    if (newEntity) {`);
             ret.push(`      coll.setDirty();`);
             ret.push(`    } else {`);
@@ -231,11 +231,11 @@ export class ObjectHydrator extends Hydrator {
             if (!this.platform.usesPivotTable() && prop.owner && prop.kind === ReferenceKind.MANY_TO_MANY) {
                 ret.push(`  } else if (!entity${entityKey} && Array.isArray(data${dataKey})) {`);
                 const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
-                ret.push(`    const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`);
+                ret.push(`    const coll = Collection.create(entity, ${this.quote(prop.name)}, ${items}, !!data${dataKey} || newEntity);`);
                 ret.push(`    coll.setDirty(false);`);
             }
             ret.push(`  } else if (!entity${entityKey}) {`);
-            ret.push(`    const coll = Collection.create(entity, '${prop.name}', undefined, newEntity);`);
+            ret.push(`    const coll = Collection.create(entity, ${this.quote(prop.name)}, undefined, newEntity);`);
             ret.push(`    coll.setDirty(false);`);
             ret.push(`  }`);
             return ret;
@@ -431,10 +431,14 @@ export class ObjectHydrator extends Hydrator {
         return lines;
     }
     wrap(key) {
-        if (/^\[.*]$/.exec(key)) {
+        if (/^\[idx_\d+]$/.exec(key)) {
             return key;
         }
-        return /^\w+$/.exec(key) ? `.${key}` : `['${key}']`;
+        return /^\w+$/.exec(key) ? `.${key}` : `[${this.quote(key)}]`;
+    }
+    /** Renders a key as a single-quoted JS string literal, safe to embed in generated code. */
+    quote(key) {
+        return `'${key.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
     }
     safeKey(key) {
         return key.replace(/\W/g, '_');

package/metadata/MetadataDiscovery.js

@@ -441,7 +441,18 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
             prop.fieldNames = [this.#namingStrategy.propertyToColumnName(prop.name, object)];
         }
-        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.polymorphic) {
+            if (prop.targetMeta) {
+                // same layout as `initManyToOneFields` builds later: `[discriminatorColumn, ...fkIdColumns]`
+                const pkFields = prop.targetMeta.getPrimaryProps().flatMap(pk => {
+                    this.initFieldName(pk);
+                    return pk.fieldNames;
+                });
+                const idColumns = pkFields.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, pkFields.length > 1));
+                prop.fieldNames = [prop.discriminatorColumn, ...idColumns];
+            }
+        }
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             prop.fieldNames = this.initManyToOneFieldName(prop, prop.name);
         }
         else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
@@ -451,10 +462,13 @@ export class MetadataDiscovery {
     initManyToOneFieldName(prop, name) {
         const meta2 = prop.targetMeta;
         const ret = [];
-        for (const primaryKey of meta2.primaryKeys) {
-            this.initFieldName(meta2.properties[primaryKey]);
-            for (const fieldName of meta2.properties[primaryKey].fieldNames) {
-                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK));
+        // with `targetKey` on a composite PK target, derive the FK field name from that property
+        // instead of the PKs (simple PK targets keep the PK based naming for backwards compatibility)
+        const referencedKeys = prop.targetKey && meta2.compositePK ? [prop.targetKey] : meta2.primaryKeys;
+        for (const referencedKey of referencedKeys) {
+            this.initFieldName(meta2.properties[referencedKey]);
+            for (const fieldName of meta2.properties[referencedKey].fieldNames) {
+                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, !prop.targetKey && meta2.compositePK));
             }
         }
         return ret;
@@ -1055,11 +1069,12 @@ export class MetadataDiscovery {
         }
         // TPT children have their own tables that don't contain the parent's columns,
         // so propagating parent indexes/uniques/checks/triggers would target missing columns.
+        // deep equality, as the subclass items might be copies of the base class ones (e.g. with TC39 decorators)
         if (meta.inheritanceType !== 'tpt' || !meta.tptParent) {
-            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
-            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
-            meta.checks = Utils.unique([...base.checks, ...meta.checks]);
-            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers]);
+            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes], Utils.equals);
+            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques], Utils.equals);
+            meta.checks = Utils.unique([...base.checks, ...meta.checks], Utils.equals);
+            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers], Utils.equals);
         }
         const pks = Object.values(meta.properties)
             .filter(p => p.primary)
@@ -1247,8 +1262,17 @@ export class MetadataDiscovery {
             if (embeddedProp.nullable || refInArray) {
                 meta.properties[name].nullable = true;
             }
+            // polymorphic relations derive their column names from the discriminator, so prefix it too
+            if (meta.properties[name].polymorphic && !object) {
+                meta.properties[name].discriminator = prefix + meta.properties[name].discriminator;
+                meta.properties[name].discriminatorColumn = prefix + meta.properties[name].discriminatorColumn;
+            }
             if (meta.properties[name].fieldNames) {
-                meta.properties[name].fieldNames[0] = prefix + meta.properties[name].fieldNames[0];
+                const { fieldNames, polymorphic } = meta.properties[name];
+                // polymorphic `fieldNames` hold `[discriminatorColumn, ...fkIdColumns]`, so prefix all of them
+                for (let i = 0; i < (polymorphic ? fieldNames.length : 1); i++) {
+                    fieldNames[i] = prefix + fieldNames[i];
+                }
             }
             else {
                 const name2 = meta.properties[name].name;
@@ -1677,6 +1701,9 @@ export class MetadataDiscovery {
                 if (prop.persist === false || prop.nativeEnumName || !prop.items?.every(item => typeof item === 'string')) {
                     continue;
                 }
+                if (prop.customType instanceof t.json || ['json', 'jsonb'].includes(prop.columnTypes?.[0])) {
+                    continue;
+                }
                 this.initFieldName(prop);
                 let expression = null;
                 if (prop.enum) {
@@ -2080,6 +2107,7 @@ export class MetadataDiscovery {
             prop.columnTypes.push(...columnTypes);
             if (!targetMeta.compositePK || prop.targetKey) {
                 prop.customType = referencedProp.customType;
+                prop.collation ??= referencedProp.collation;
             }
         }
     }
@@ -2135,7 +2163,7 @@ export class MetadataDiscovery {
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.#config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {
-            return forceConstructor.some(cls => Utils.className(cls) === meta.className);
+            return forceConstructor.some(cls => Utils.matchesEntity(cls, meta));
         }
         return forceConstructor;
     }

package/metadata/MetadataStorage.js

@@ -17,6 +17,7 @@ export class MetadataStorage {
     #idMap;
     #classNameMap;
     #uniqueNameMap;
+    #ambiguousNames = new Set();
     constructor(metadata = {}) {
         this.#idMap = {};
         this.#uniqueNameMap = {};
@@ -64,6 +65,10 @@ export class MetadataStorage {
     }
     /** Returns metadata for the given entity, optionally initializing it if not found. */
     get(entityName, init = false) {
+        // string lookups cannot be resolved when several classes were minified to the same name
+        if (typeof entityName === 'string' && this.#ambiguousNames.has(entityName)) {
+            throw MetadataError.ambiguousEntityName(entityName);
+        }
         const exists = this.find(entityName);
         if (exists) {
             return exists;
@@ -99,7 +104,13 @@ export class MetadataStorage {
         this.#metadataMap.set(entityName, meta);
         this.#idMap[meta._id] = meta;
         this.#uniqueNameMap[meta.uniqueName] = meta;
-        this.#classNameMap[Utils.className(entityName)] = meta;
+        const className = Utils.className(entityName);
+        const existing = this.#classNameMap[className];
+        // track name collisions caused by minifiers mangling two classes to the same name
+        if (existing && existing !== meta && existing.class !== meta.class) {
+            this.#ambiguousNames.add(className);
+        }
+        this.#classNameMap[className] = meta;
         return meta;
     }
     /** Removes metadata for the given entity from all internal maps. */
@@ -110,6 +121,11 @@ export class MetadataStorage {
             delete this.#idMap[meta._id];
             delete this.#uniqueNameMap[meta.uniqueName];
             delete this.#classNameMap[meta.className];
+            // the name may still be ambiguous among the remaining metas
+            const remaining = new Set([...this.#metadataMap.values()].filter(m => m.className === meta.className).map(m => m.class));
+            if (remaining.size <= 1) {
+                this.#ambiguousNames.delete(meta.className);
+            }
         }
     }
     /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.0-dev.13",
+  "version": "7.2.0-dev.14",
   "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.",
   "keywords": [
     "data-mapper",

package/platforms/Platform.d.ts

@@ -211,8 +211,9 @@ export declare abstract class Platform {
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
-    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    /** When `aliased` is a string, it holds an explicit alias the key was prefixed with. */
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean | string, value?: unknown): string | Raw;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean | string): FilterQuery<T>;
     protected getJsonValueType(value: unknown): string;
     getJsonIndexDefinition(index: {
         columnNames: string[];

package/platforms/Platform.js

@@ -413,6 +413,7 @@ export class Platform {
     getSearchJsonPropertySQL(path, type, aliased) {
         return path;
     }
+    /** When `aliased` is a string, it holds an explicit alias the key was prefixed with. */
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
@@ -424,7 +425,8 @@ export class Platform {
             return o;
         }
         if (path.length === 1) {
-            o[path[0]] = value;
+            const key = typeof alias === 'string' ? `${alias}.${path[0]}` : path[0];
+            o[key] = value;
             return o;
         }
         const type = this.getJsonValueType(value);

package/types/Type.js

@@ -55,11 +55,11 @@ export class Type {
         return prop.columnTypes?.[0] ?? platform.getTextTypeDeclarationSQL(prop);
     }
     static getType(cls) {
-        const key = cls.name;
-        if (!Type.types.has(key)) {
-            Type.types.set(key, new cls());
+        // keyed by class reference, as minifiers can mangle two classes to the same name
+        if (!Type.types.has(cls)) {
+            Type.types.set(cls, new cls());
         }
-        return Type.types.get(key);
+        return Type.types.get(cls);
     }
     /**
      * Checks whether the argument is instance of `Type`.

package/typings.d.ts

@@ -478,12 +478,12 @@ type NonArrayObject = object & {
 export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? EntityDataNested<U, C> : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? EntityDataNested<U, C> : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? [U] extends [NonArrayObject] ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
 /** Like `EntityDataProp` but used in `RequiredEntityData` context with required/optional key distinction. */
 export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? [U] extends [NonArrayObject] ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 /** Nested entity data shape for embedded or related entities within `EntityData`. */
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
 type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
@@ -1050,6 +1050,12 @@ export declare class EntityMetadata<Entity = any, Class extends EntityCtor<Entit
     constructor(meta?: Partial<EntityMetadata>);
     addProperty(prop: Partial<EntityProperty<Entity>>): void;
     removeProperty(name: string, sync?: boolean): void;
+    /** For TPT entities, the version column exists only on the table of the entity that declares it. */
+    ownsVersionProperty(): boolean;
+    /** For TPT entities, concurrency check columns exist only on the table of the entity that declares them. */
+    getOwnConcurrencyCheckKeys(): EntityKey<Entity>[];
+    /** Whether updates of this table are guarded by a version property or concurrency check columns it owns. */
+    hasOptimisticLock(): boolean;
     getPrimaryProps(flatten?: boolean): EntityProperty<Entity>[];
     getPrimaryProp(): EntityProperty<Entity>;
     /**

package/typings.js

@@ -79,6 +79,25 @@ export class EntityMetadata {
             this.sync();
         }
     }
+    /** For TPT entities, the version column exists only on the table of the entity that declares it. */
+    ownsVersionProperty() {
+        if (!this.versionProperty) {
+            return false;
+        }
+        return this.inheritanceType !== 'tpt' || !this.ownProps || this.ownProps.some(p => p.name === this.versionProperty);
+    }
+    /** For TPT entities, concurrency check columns exist only on the table of the entity that declares them. */
+    getOwnConcurrencyCheckKeys() {
+        const keys = [...this.concurrencyCheckKeys];
+        if (this.inheritanceType !== 'tpt' || !this.ownProps) {
+            return keys;
+        }
+        return keys.filter(key => this.ownProps.some(p => p.name === key));
+    }
+    /** Whether updates of this table are guarded by a version property or concurrency check columns it owns. */
+    hasOptimisticLock() {
+        return this.ownsVersionProperty() || this.getOwnConcurrencyCheckKeys().length > 0;
+    }
     getPrimaryProps(flatten = false) {
         const pks = this.primaryKeys.map(pk => this.properties[pk]);
         if (flatten) {
@@ -216,7 +235,10 @@ export class EntityMetadata {
         if (config) {
             const platform = config.getPlatform();
             for (const prop of this.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
+                if (prop.enum &&
+                    !prop.nativeEnumName &&
+                    prop.items?.every(item => typeof item === 'string') &&
+                    !['json', 'jsonb'].includes(prop.columnTypes?.[0])) {
                     const name = platform.getIndexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {

package/unit-of-work/ChangeSetPersister.js

@@ -204,13 +204,14 @@ export class ChangeSetPersister {
     }
     checkConcurrencyKeys(meta, changeSet, cond) {
         const tmp = [];
-        for (const key of meta.concurrencyCheckKeys) {
+        const keys = meta.getOwnConcurrencyCheckKeys();
+        for (const key of keys) {
             cond[key] = changeSet.originalEntity[key];
             if (changeSet.payload[key]) {
                 tmp.push(key);
             }
         }
-        if (tmp.length === 0 && meta.concurrencyCheckKeys.size > 0) {
+        if (tmp.length === 0 && keys.length > 0) {
             throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
@@ -303,32 +304,33 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        if (meta.concurrencyCheckKeys.size === 0 &&
-            (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
+        if (meta.getOwnConcurrencyCheckKeys().length === 0 &&
+            (!meta.ownsVersionProperty() || changeSet.entity[meta.versionProperty] == null)) {
             return this.#driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
-        if (meta.versionProperty) {
+        if (meta.ownsVersionProperty()) {
             cond[meta.versionProperty] = this.#platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
         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))) {
+        const concurrencyCheckKeys = meta.getOwnConcurrencyCheckKeys();
+        if (concurrencyCheckKeys.length === 0 &&
+            (!meta.ownsVersionProperty() || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
             return;
         }
         // skip entity references as they don't have version values loaded
         changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
+        const primaryKeys = meta.primaryKeys.concat(...concurrencyCheckKeys);
         const $or = changeSets.map(cs => {
-            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
-            if (meta.versionProperty) {
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, primaryKeys);
+            if (meta.ownsVersionProperty()) {
                 // @ts-ignore
                 cond[meta.versionProperty] = this.#platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });
-        const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
         options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
             orderBy: meta.primaryKeys.reduce((o, pk) => {
@@ -336,7 +338,9 @@ export class ChangeSetPersister {
                 return o;
             }, {}),
         });
-        const res = await this.#driver.find(meta.root.class, { $or }, options);
+        // TPT tables query their own metadata, as the version column might not live on the root table
+        const target = meta.inheritanceType === 'tpt' ? meta : meta.root;
+        const res = await this.#driver.find(target.class, { $or }, options);
         if (res.length !== changeSets.length) {
             // a FK pointing to a composite PK is an array, so the values need to be compared deeply
             const compare = (a, b, keys) => keys.every(k => equals(a[k], b[k]));
@@ -347,7 +351,7 @@ export class ChangeSetPersister {
         }
     }
     checkOptimisticLock(meta, changeSet, res) {
-        if ((meta.versionProperty || meta.concurrencyCheckKeys.size > 0) && res && !res.affectedRows) {
+        if ((meta.ownsVersionProperty() || meta.getOwnConcurrencyCheckKeys().length > 0) && res && !res.affectedRows) {
             throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
@@ -356,7 +360,7 @@ export class ChangeSetPersister {
      * so we use a single query in case of both versioning and default values is used.
      */
     async reloadVersionValues(meta, changeSets, options) {
-        const reloadProps = meta.versionProperty && !this.#usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
+        const reloadProps = meta.ownsVersionProperty() && !this.#usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
         if (changeSets[0].type === ChangeSetType.CREATE) {
             for (const prop of meta.props) {
                 if (prop.persist === false) {

package/unit-of-work/UnitOfWork.js

@@ -124,7 +124,6 @@ export class UnitOfWork {
         if (options?.newEntity) {
             return entity;
         }
-        const forceUndefined = this.#em.config.get('forceUndefined');
         const wrapped = helper(entity);
         if (options?.loaded && wrapped.__initialized && !wrapped.__onLoadFired) {
             this.#loadedEntities.add(entity);
@@ -332,6 +331,7 @@ export class UnitOfWork {
                     let parentCs = changeSet.tptChangeSets.find(pc => pc.meta === current);
                     if (!parentCs) {
                         parentCs = new ChangeSet(entity, changeSet.type, {}, current);
+                        parentCs.originalEntity = changeSet.originalEntity;
                         changeSet.tptChangeSets.splice(idx, 0, parentCs);
                     }
                     idx++;
@@ -527,6 +527,10 @@ export class UnitOfWork {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
+                    else if (prop.primary) {
+                        // the referrer's primary key contains the removed entity, so its identity cannot survive the removal
+                        this.unsetIdentity(referrer);
+                    }
                     else {
                         delete helper(referrer).__data[prop.name];
                     }
@@ -702,13 +706,14 @@ export class UnitOfWork {
                     payload[pk] = identifiers[i] ?? originalChangeSet.payload[pk];
                 }
             }
-            if (!isCreate && Object.keys(payload).length === 0) {
+            // the table declaring the version property or a concurrency check still needs its bump and lock check
+            if (!isCreate && Object.keys(payload).length === 0 && !current.hasOptimisticLock()) {
                 current = current.tptParent;
                 continue;
             }
             const cs = new ChangeSet(entity, originalChangeSet.type, payload, current);
+            cs.originalEntity = originalChangeSet.originalEntity;
             if (current === meta) {
-                cs.originalEntity = originalChangeSet.originalEntity;
                 leafCs = cs;
             }
             else {
@@ -1205,7 +1210,8 @@ export class UnitOfWork {
         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)) {
+                !Utils.hasObjectKeys(cs.payload) &&
+                !cs.meta.hasOptimisticLock()) {
                 return;
             }
             const group = groups[cs.type];

package/utils/DataloaderUtils.js

@@ -197,7 +197,8 @@ export class DataloaderUtils {
                 const prop = group[0][0].property;
                 const options = {};
                 const wrap = (cond) => ({ [prop.name]: cond });
-                const orderBy = Utils.asArray(group[0][1]?.orderBy).map(o => wrap(o));
+                // `findChildrenFromPivotTable` expects the `orderBy` relative to the target entity, so no wrapping here
+                const orderBy = Utils.asArray(group[0][1]?.orderBy);
                 const populate = wrap(group[0][1]?.populate);
                 const owners = group.map(c => c[0].owner);
                 const $or = [];

package/utils/EntityComparator.d.ts

@@ -80,6 +80,8 @@ export declare class EntityComparator {
     private getGenericComparator;
     private getPropertyComparator;
     private wrap;
+    /** Renders a key as a single-quoted JS string literal, safe to embed in generated code. */
+    private quote;
     private safeKey;
     /**
      * Sets the toArray helper in the context if not already set.

package/utils/EntityComparator.js

@@ -587,7 +587,7 @@ export class EntityComparator {
                 }
             }
             else if (prop.polymorphic) {
-                const discriminatorMapKey = `discriminatorMapReverse_${prop.name}`;
+                const discriminatorMapKey = `discriminatorMapReverse_${this.safeKey(prop.name)}`;
                 const reverseMap = new Map();
                 for (const [key, value] of Object.entries(prop.discriminatorMap)) {
                     reverseMap.set(value, key);
@@ -758,10 +758,14 @@ export class EntityComparator {
         return this.getGenericComparator(this.wrap(prop.name), `!equals(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
     }
     wrap(key) {
-        if (/^\[.*]$/.exec(key)) {
+        if (/^\[idx_\d+]$/.exec(key)) {
             return key;
         }
-        return /^\w+$/.exec(key) ? `.${key}` : `['${key}']`;
+        return /^\w+$/.exec(key) ? `.${key}` : `[${this.quote(key)}]`;
+    }
+    /** Renders a key as a single-quoted JS string literal, safe to embed in generated code. */
+    quote(key) {
+        return `'${key.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
     }
     safeKey(key) {
         return key.replace(/\W/g, '_');

package/utils/QueryHelper.js

@@ -1,5 +1,5 @@
 import { Reference } from '../entity/Reference.js';
-import { Utils } from './Utils.js';
+import { DANGEROUS_PROPERTY_NAMES, Utils } from './Utils.js';
 import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
@@ -237,7 +237,11 @@ export class QueryHelper {
             // oxfmt-ignore
             const isJsonProperty = prop?.customType instanceof JsonType && !isRaw(value) && (Utils.isPlainObject(value) ? !['$eq', '$elemMatch'].includes(Object.keys(value)[0]) : !Array.isArray(value));
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
-                return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
+                // an explicit alias prefix (e.g. `a.meta`) has to survive, otherwise the condition falls back to the root alias
+                const explicitAlias = key.includes('.')
+                    ? key.split('.').slice(0, -1).join('.')
+                    : undefined;
+                return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased && explicitAlias != null ? explicitAlias : aliased);
             }
             // oxfmt-ignore
             if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !(customExpression && Raw.getKnownFragment(key).params.length > 0) && options.type !== 'orderBy') {
@@ -269,7 +273,11 @@ export class QueryHelper {
             options.forEach(filter => (opts[filter] = true));
         }
         else if (Utils.isPlainObject(options)) {
-            Object.keys(options).forEach(filter => (opts[filter] = options[filter]));
+            Object.keys(options).forEach(filter => {
+                if (!DANGEROUS_PROPERTY_NAMES.includes(filter)) {
+                    opts[filter] = options[filter];
+                }
+            });
         }
         return Object.keys(filters)
             .filter(f => QueryHelper.isFilterActive(meta, f, filters[f], opts))
@@ -297,7 +305,7 @@ export class QueryHelper {
         return Utils.mergeConfig({}, propFilters, options);
     }
     static isFilterActive(meta, filterName, filter, options) {
-        if (filter.entity && !filter.entity.includes(meta.className)) {
+        if (filter.entity && !Utils.asArray(filter.entity).some(e => Utils.matchesEntity(e, meta))) {
             return false;
         }
         if (options[filterName] === false) {

package/utils/Utils.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledFunctions, Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
+import type { CompiledFunctions, Dictionary, EntityCtor, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 import { ScalarReference } from '../entity/Reference.js';
 import { Collection } from '../entity/Collection.js';
@@ -58,7 +58,7 @@ export declare class Utils {
     /**
      * Gets array without duplicates.
      */
-    static unique<T = string>(items: T[]): T[];
+    static unique<T = string>(items: T[], equals?: (a: T, b: T) => boolean): T[];
     /**
      * Merges all sources into the target recursively.
      */
@@ -129,6 +129,16 @@ export declare class Utils {
      * Gets string name of given class.
      */
     static className<T>(classOrName: string | EntityName<T>): string;
+    /**
+     * Normalizes an entity reference for identity-safe matching: keeps class references
+     * (minifiers can mangle two classes to the same name) and falls back to the class name otherwise.
+     */
+    static classOrName<T>(classOrName: string | EntityName<T>): EntityCtor<T> | string;
+    /**
+     * Checks whether the given entity reference points at the given metadata,
+     * comparing classes by identity and strings by class name.
+     */
+    static matchesEntity<T>(classOrName: string | EntityName<T>, meta: EntityMetadata<any>): boolean;
     static extractChildElements(items: readonly string[], prefix: string, allSymbol?: string): string[];
     /**
      * Tries to detect TypeScript support.

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.0-dev.13';
+    static #ORM_VERSION = '7.2.0-dev.14';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -216,10 +216,13 @@ export class Utils {
     /**
      * Gets array without duplicates.
      */
-    static unique(items) {
+    static unique(items, equals) {
         if (items.length < 2) {
             return items;
         }
+        if (equals) {
+            return items.filter((a, idx) => items.findIndex(b => equals(a, b)) === idx);
+        }
         return [...new Set(items)];
     }
     /**
@@ -562,6 +565,21 @@ export class Utils {
         }
         return classOrName.name;
     }
+    /**
+     * Normalizes an entity reference for identity-safe matching: keeps class references
+     * (minifiers can mangle two classes to the same name) and falls back to the class name otherwise.
+     */
+    static classOrName(classOrName) {
+        return typeof classOrName === 'function' ? classOrName : Utils.className(classOrName);
+    }
+    /**
+     * Checks whether the given entity reference points at the given metadata,
+     * comparing classes by identity and strings by class name.
+     */
+    static matchesEntity(classOrName, meta) {
+        const ref = Utils.classOrName(classOrName);
+        return typeof ref === 'function' ? ref === meta.class : ref === meta.className;
+    }
     static extractChildElements(items, prefix, allSymbol) {
         return items
             .filter(field => field === allSymbol || field.startsWith(`${prefix}.`))

package/utils/upsert-utils.d.ts

@@ -1,8 +1,16 @@
-import type { EntityData, EntityMetadata, FilterQuery } from '../typings.js';
+import type { EntityData, EntityKey, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
 import { type Raw } from '../utils/RawQueryFragment.js';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T>): (keyof T)[];
+/**
+ * Detects properties that will get their value generated by an `onCreate` hook during the upsert,
+ * i.e. those with an `onCreate` hook and no value provided. Such values are meant for the insert
+ * clause only and must not overwrite an existing row via the `on conflict do update set` clause.
+ * The property filter mirrors `EntityFactory.assignDefaultValues`.
+ * @internal
+ */
+export declare function getOnCreateGeneratedFields<T extends object>(meta: EntityMetadata<T>, data: T | EntityData<T>): EntityKey<T>[];
 /** @internal */
 export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T, P>): (keyof T)[] | '*';
 /** @internal */

package/utils/upsert-utils.js

@@ -72,6 +72,22 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
     }
     return keys;
 }
+/**
+ * Detects properties that will get their value generated by an `onCreate` hook during the upsert,
+ * i.e. those with an `onCreate` hook and no value provided. Such values are meant for the insert
+ * clause only and must not overwrite an existing row via the `on conflict do update set` clause.
+ * The property filter mirrors `EntityFactory.assignDefaultValues`.
+ * @internal
+ */
+export function getOnCreateGeneratedFields(meta, data) {
+    return meta.props
+        .filter(prop => prop.onCreate &&
+        !prop.embedded &&
+        ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+        !(prop.getter && !prop.setter) &&
+        data[prop.name] == null)
+        .map(prop => prop.name);
+}
 /** @internal */
 export function getOnConflictReturningFields(meta, data, uniqueFields, options) {
     /* v8 ignore next */
@@ -122,7 +138,14 @@ function getPropertyValue(obj, key) {
 }
 /** @internal */
 export function getWhereCondition(meta, onConflictFields, data, where) {
-    const unique = onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+    // TPT children do not inherit the unique flags and indexes of their parent tables
+    const uniqueProps = new Set();
+    const uniques = [];
+    for (let current = meta; current; current = current.tptParent) {
+        current.props.filter(p => p.unique).forEach(p => uniqueProps.add(p.name));
+        uniques.push(...current.uniques);
+    }
+    const unique = onConflictFields ?? [...uniqueProps];
     const propIndex = !isRaw(unique) &&
         unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
     if (onConflictFields || where == null) {
@@ -136,8 +159,8 @@ export function getWhereCondition(meta, onConflictFields, data, where) {
             }
             where = { [key]: getPropertyValue(data, unique[propIndex]) };
         }
-        else if (meta.uniques.length > 0) {
-            for (const u of meta.uniques) {
+        else {
+            for (const u of uniques) {
                 if (Utils.asArray(u.properties).every(p => data[p] != null)) {
                     where = Utils.asArray(u.properties).reduce((o, key) => {
                         o[key] = data[key];