@mikro-orm/core 7.3.0-dev.2 → 7.3.0-dev.20

package/serialization/EntitySerializer.js

@@ -4,20 +4,50 @@ import { ReferenceKind } from '../enums.js';
 import { Reference } from '../entity/Reference.js';
 import { SerializationContext } from './SerializationContext.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
-/** Returns true when any entry in `items` is `propName`, the wildcard `*`, or a dot-path under `propName`. */
-function matchesPath(items, propName) {
-    return items.some(item => item === propName || item === '*' || item.startsWith(propName + '.'));
+// Keyed by option objects created for a single `serialize()` call, so caller-owned options are never cached.
+const preparedOptions = new WeakMap();
+function createPathLookup(items) {
+    const heads = new Set();
+    let all = false;
+    for (const item of items) {
+        const dot = item.indexOf('.');
+        heads.add(dot === -1 ? item : item.substring(0, dot));
+        all ||= item === '*';
+    }
+    return { all, heads };
+}
+/**
+ * Copies caller options once per `serialize()` call, so the derived child options and path lookups can be cached
+ * for every entity of the call without ever caching an options object the caller might mutate later.
+ */
+function prepareOptions(options) {
+    if (preparedOptions.has(options)) {
+        return options;
+    }
+    const prepared = {
+        ...options,
+        populate: options.populate ? Utils.asArray(options.populate) : options.populate,
+    };
+    preparedOptions.set(prepared, { children: new Map() });
+    return prepared;
+}
+function pathLookup(options, key) {
+    return (preparedOptions.get(options)[key] ??= createPathLookup(options[key]));
+}
+/** Returns true when any entry in `options[key]` is `propName`, the wildcard `*`, or a dot-path under `propName`. */
+function matchesPath(options, key, propName) {
+    const lookup = pathLookup(options, key);
+    return lookup.all || lookup.heads.has(propName);
 }
 function isVisible(meta, propName, options) {
     const prop = meta.properties[propName];
     if (options.groups && prop?.groups) {
         return prop.groups.some(g => options.groups.includes(g));
     }
-    if (Array.isArray(options.fields) && options.fields.length > 0 && !matchesPath(options.fields, propName)) {
+    if (Array.isArray(options.fields) && options.fields.length > 0 && !matchesPath(options, 'fields', propName)) {
         return false;
     }
-    if (Array.isArray(options.populate) &&
-        options.populate.find(item => item === propName || item.startsWith(propName + '.'))) {
+    if (Array.isArray(options.populate) && pathLookup(options, 'populate').heads.has(propName)) {
         return true;
     }
     if (options.exclude?.find(item => item === propName)) {
@@ -30,7 +60,7 @@ function isVisible(meta, propName, options) {
 function isPopulated(propName, options) {
     if (typeof options.populate !== 'boolean' &&
         Array.isArray(options.populate) &&
-        matchesPath(options.populate, propName)) {
+        matchesPath(options, 'populate', propName)) {
         return true;
     }
     if (typeof options.populate === 'boolean') {
@@ -45,10 +75,10 @@ export class EntitySerializer {
         const wrapped = helper(entity);
         const meta = wrapped.__meta;
         let contextCreated = false;
+        options = prepareOptions(options);
         if (!wrapped.__serializationContext.root) {
             const root = new SerializationContext();
             SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== ReferenceKind.SCALAR);
-            options.populate = (options.populate ? Utils.asArray(options.populate) : options.populate);
             contextCreated = true;
         }
         const root = wrapped.__serializationContext.root;
@@ -145,7 +175,8 @@ export class EntitySerializer {
         if (entity[prop] instanceof Function) {
             const returnValue = entity[prop]();
             if (!options.ignoreSerializers && serializer) {
-                return serializer(returnValue, this.extractChildOptions(options, prop));
+                // copy, so a serializer mutating its options cannot leak into the cached child options
+                return serializer(returnValue, { ...this.extractChildOptions(options, prop) });
             }
             return returnValue;
         }
@@ -186,7 +217,12 @@ export class EntitySerializer {
         return prop.customType.toJSON(value, platform);
     }
     static extractChildOptions(options, prop) {
-        return {
+        const prepared = preparedOptions.get(options);
+        const cached = prepared.children.get(prop);
+        if (cached) {
+            return cached;
+        }
+        const child = {
             ...options,
             populate: Array.isArray(options.populate)
                 ? Utils.extractChildElements(options.populate, prop, '*')
@@ -194,6 +230,9 @@ export class EntitySerializer {
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop) : options.exclude,
             fields: Array.isArray(options.fields) ? this.extractChildFields(options.fields, prop) : options.fields,
         };
+        prepared.children.set(prop, child);
+        preparedOptions.set(child, { children: new Map() });
+        return child;
     }
     /**
      * Extracts the nested `fields` whitelist for a child property. A bare parent name (`fields: ['books']`) or a
@@ -269,8 +308,9 @@ export class EntitySerializer {
  * ```
  */
 export function serialize(entities, options) {
+    const prepared = prepareOptions(options ?? {});
     if (Array.isArray(entities)) {
-        return entities.map(e => EntitySerializer.serialize(e, options));
+        return entities.map(e => EntitySerializer.serialize(e, prepared));
     }
-    return EntitySerializer.serialize(entities, options);
+    return EntitySerializer.serialize(entities, prepared);
 }

package/types/DecimalType.js

@@ -1,4 +1,24 @@
 import { Type } from './Type.js';
+/** Scales a plain decimal string to an integer rounded half away from zero at `scale`, like the DB does. */
+function toScaledInteger(value, scale) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const negative = value.startsWith('-');
+    const [int, fraction = ''] = (negative ? value.slice(1) : value).split('.');
+    const digits = int + fraction;
+    for (let i = 0; i < digits.length; i++) {
+        const code = digits.charCodeAt(i);
+        if (code < 48 || code > 57) {
+            return undefined;
+        }
+    }
+    let scaled = BigInt('0' + int + fraction.slice(0, scale).padEnd(scale, '0'));
+    if (fraction.charCodeAt(scale) >= 53) {
+        scaled++;
+    }
+    return negative ? -scaled : scaled;
+}
 /**
  * Type that maps an SQL DECIMAL to a JS string or number.
  */
@@ -16,7 +36,20 @@ export class DecimalType extends Type {
         return String(value);
     }
     compareValues(a, b) {
-        return this.platform.formatDecimal(a, this.prop?.scale) === this.platform.formatDecimal(b, this.prop?.scale);
+        if (a === b) {
+            return true;
+        }
+        const scale = this.prop?.scale;
+        if (this.platform.formatDecimal(a, scale) !== this.platform.formatDecimal(b, scale)) {
+            return false;
+        }
+        // doubles are exact only up to 15 significant digits, so only higher precision strings can differ past the numeric check
+        if ((this.prop?.precision ?? 0) <= 15 || this.compareAsType() !== 'string') {
+            return true;
+        }
+        const scaledA = toScaledInteger(a, scale ?? 0);
+        const scaledB = toScaledInteger(b, scale ?? 0);
+        return scaledA == null || scaledB == null || scaledA === scaledB;
     }
     getColumnType(prop, platform) {
         return platform.getDecimalTypeDeclarationSQL(prop);

package/types/DoubleType.d.ts

@@ -2,10 +2,14 @@ import { Type } from './Type.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /**
- * Type that maps an SQL DOUBLE to a JS string or number.
+ * Type that maps an SQL DOUBLE to a JS number (default) or string.
  */
-export declare class DoubleType extends Type<number | string, string> {
-    convertToJSValue(value: string): number | string;
+export declare class DoubleType<Mode extends 'number' | 'string' = 'number'> extends Type<JSTypeByMode<Mode>, string> {
+    mode?: Mode | undefined;
+    constructor(mode?: Mode | undefined);
+    convertToJSValue(value: string): JSTypeByMode<Mode>;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
 }
+type JSTypeByMode<Mode extends 'number' | 'string'> = Mode extends 'number' ? number : string;
+export {};

package/types/DoubleType.js

@@ -1,11 +1,16 @@
 import { Type } from './Type.js';
 /**
- * Type that maps an SQL DOUBLE to a JS string or number.
+ * Type that maps an SQL DOUBLE to a JS number (default) or string.
  */
 export class DoubleType extends Type {
+    mode;
+    constructor(mode) {
+        super();
+        this.mode = mode;
+    }
     /* v8 ignore next */
     convertToJSValue(value) {
-        if (this.prop?.runtimeType === 'number') {
+        if ((this.mode ?? this.prop?.runtimeType) === 'number') {
             return +value;
         }
         return String(value);
@@ -14,6 +19,6 @@ export class DoubleType extends Type {
         return platform.getDoubleDeclarationSQL();
     }
     compareAsType() {
-        return this.prop?.runtimeType ?? 'number';
+        return this.mode ?? this.prop?.runtimeType ?? 'number';
     }
 }

package/typings.d.ts

@@ -12,7 +12,7 @@ import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { Routine } from './metadata/Routine.js';
 import type { EntitySchema } from './metadata/EntitySchema.js';
-import type { EntityPartitionBy, IndexColumnOptions } from './metadata/types.js';
+import type { EntityPartitionBy, IndexColumnOptions, SequenceOptions } from './metadata/types.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
@@ -358,12 +358,15 @@ type ElemMatchCondition<T extends Record<string, any>> = {
     $and?: ElemMatchCondition<T>[];
     $not?: ElemMatchCondition<T>;
 };
-type ElemMatchFilter<T> = T extends readonly (infer E)[] ? E extends Record<string, any> ? {
+type ArrayFilter<T> = T extends readonly (infer E)[] ? [E] extends [Scalar] ? {
+    $in?: readonly (readonly ExpandScalar<E>[])[];
+    $nin?: readonly (readonly ExpandScalar<E>[])[];
+} : E extends Record<string, any> ? {
     $elemMatch: ElemMatchCondition<E>;
 } : never : never;
 /** Object form of a filter query, mapping entity keys to their filter conditions. */
 export type FilterObject<T> = {
-    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
+    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ArrayFilter<FilterObjectProp<T, K>> | null;
 };
 /** Recursively expands a type into its `FilterQuery` form for nested object filtering. */
 export type ExpandQuery<T> = T extends object ? (T extends Scalar ? never : FilterQuery<T>) : FilterValue<T>;
@@ -383,7 +386,7 @@ export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T
  * Used when `using` option is set in `FindOptions` to enforce type-safe index usage.
  */
 export type IndexFilterQuery<T, Using extends string> = [Using] extends [never] ? FilterQuery<T> : (OperatorMap<T> & {
-    -readonly [K in Extract<EntityKey<T>, IndexColumns<T, Using>>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
+    -readonly [K in Extract<EntityKey<T>, IndexColumns<T, Using>>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ArrayFilter<FilterObjectProp<T, K>> | null;
 }) | NonNullable<ExpandScalar<Primary<T>>> | IndexFilterQuery<T, Using>[];
 /** Replaces `where` and `using` on an options type with index-aware variants when `Using` is specified. */
 export type WithUsingOptions<Opts, Entity, Using extends string> = Omit<Opts, 'where' | 'using'> & {
@@ -564,6 +567,13 @@ export declare namespace LazyRef {
         [__lazyRef]?: (arg: T) => T;
     }
 }
+/**
+ * The brand's only key is optional, so an object type without named properties (like `Record<string, number>`)
+ * extends `LazyRef.Brand<infer U>` too, with `U` inferred as `unknown`. `LazyRef<T>` needs `T extends object`,
+ * so an `unknown` target means the type is not a `LazyRef` and resolves to `Fallback`. `any` stays `any`.
+ * Only checked once `unknown extends U` holds, so a real `LazyRef` skips it.
+ */
+type NotLazyRef<U, Fallback> = IsAny<U> extends true ? U : Fallback;
 /** Alias for `Reference<T> & { id: number }` (see {@apilink Ref}). */
 export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : {
     [K in PrimaryProperty<T> & keyof T]: T[K];
@@ -986,6 +996,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     hasConvertToJSValueSQL: boolean;
     hasConvertToDatabaseValueSQL: boolean;
     autoincrement?: boolean;
+    sequence?: SequenceOptions;
     returning?: boolean;
     primary?: boolean;
     serializedPrimaryKey: boolean;
@@ -1175,6 +1186,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         meta: EntityMetadata<Entity>;
         prop: EntityProperty<Entity>;
     }[];
+    targetKeys?: EntityKey<Entity>[];
     comparableProps: EntityProperty<Entity>[];
     trackingProps: EntityProperty<Entity>[];
     hydrateProps: EntityProperty<Entity>[];
@@ -1258,6 +1270,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
+    /** @internal name that does not depend on module evaluation order (unlike `_id`), used to key `compiledFunctions` */
+    compiledName?: string;
 }
 /** Options for `ISchemaGenerator.create()`. */
 export interface CreateSchemaOptions {
@@ -1616,7 +1630,8 @@ export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 /** Extracts the element type from an array type. */
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
 /** Unwraps a property type from its wrapper (Reference, Collection, or array) to the inner entity type. */
-export type ExpandProperty<T> = T extends LazyRef.Brand<infer U> ? NonNullable<U> : T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
+export type ExpandProperty<T> = ExpandPropertyOf<T, T>;
+type ExpandPropertyOf<T, R> = T extends LazyRef.Brand<infer U> ? unknown extends U ? NotLazyRef<U, NonNullable<R>> : NonNullable<U> : T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
 type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends LazyRef.Brand<any> ? E : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
 type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? (T extends true ? true : false) : false;
 type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
@@ -1651,7 +1666,12 @@ export type MergeSelected<T, U, F extends string> = IsLoadedType<T> extends true
 export type MergeLoaded<T, U, P extends string, F extends string, E extends string, R extends boolean = false> = IsLoadedType<T> extends true ? T & Loaded<U, P, F, E> : Loaded<T, P, F, E>;
 /** Extracts the nullability modifiers (`null`, `undefined`, or both) from a type `T`. */
 export type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
-type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractTypeWithLazyRef<T>, L, F, E>>;
+/**
+ * Like {@link ExtractTypeWithLazyRef}, but a record type that matched `LazyRef.Brand` resolves to itself (see
+ * {@link NotLazyRef}). `AutoPath` keeps the unguarded version, as it is on its hot path.
+ */
+type ExtractLoadedType<T> = T extends LazyRef.Brand<infer U> ? (unknown extends U ? NotLazyRef<U, ExtractType<T>> : U) : ExtractType<T>;
+type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractLoadedType<T>, L, F, E>>;
 /** Extracts the eager-loaded property names declared via `[EagerProps]` as a string union. */
 export type AddEager<T> = ExtractEagerProps<T> & string;
 /** Combines an explicit populate hint `L` with the entity's eagerly loaded properties. */

package/typings.js

@@ -304,8 +304,11 @@ export class EntityMetadata {
         }, { __gettersDefined: { value: true, enumerable: false } });
     }
     initIndexes(prop) {
-        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression && index.where == null);
-        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options && !index.expression && index.where == null);
+        // `prop.index`/`prop.unique` keep only the name, so an index with any other option must stay in `meta.indexes`
+        const isSimple = (index) => index.properties === prop.name &&
+            Object.entries(index).every(([key, value]) => key === 'name' || key === 'properties' || value == null);
+        const simpleIndex = this.indexes.find(isSimple);
+        const simpleUnique = this.uniques.find(isSimple);
         const owner = prop.kind === ReferenceKind.MANY_TO_ONE;
         if (!prop.index && simpleIndex) {
             Utils.defaultValue(simpleIndex, 'name', true);

package/unit-of-work/ChangeSetComputer.js

@@ -7,6 +7,7 @@ import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { ReferenceKind } from '../enums.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
+import { ValidationError } from '../errors.js';
 /** @internal Computes change sets by comparing entity state against original snapshots. */
 export class ChangeSetComputer {
     #comparator;
@@ -48,6 +49,10 @@ export class ChangeSetComputer {
             if (Utils.equals(data, wrapped.__originalEntityData)) {
                 return null;
             }
+            // a reference known only by its `targetKey` has no PK, so the update would have no condition
+            if (!wrapped.hasPrimaryKey()) {
+                throw ValidationError.referenceWithoutPK(entity);
+            }
         }
         const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
         changeSet.originalEntity = wrapped.__originalEntityData;
@@ -160,23 +165,33 @@ export class ChangeSetComputer {
         const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
         targets.forEach(([rawTarget, idx]) => {
             const target = Reference.unwrapReference(rawTarget);
-            const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
+            // a same-named scalar of another polymorphic embeddable variant is not a reference
+            const needsProcessing = Utils.isEntity(target) && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
             if (needsProcessing) {
+                // a reference known only by its `targetKey` has no PK, and is never inserted to generate one
+                if (!prop.targetKey && !target.__helper.__initialized) {
+                    throw ValidationError.referenceWithoutPK(target);
+                }
                 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];
+                // use the actual target's meta, a polymorphic relation has several
+                if (prop.targetKey) {
+                    const targetProp = target.__meta.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);
+                    value = new PolymorphicRef(discriminator, value);
                 }
-                else {
-                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
+                // an unchanged `targetKey` FK is not part of the diff
+                if (prop.targetKey &&
+                    changeSet.type === ChangeSetType.UPDATE &&
+                    !(prop.name in changeSet.payload) &&
+                    Utils.equals(changeSet.originalEntity?.[prop.name], value)) {
+                    return;
                 }
+                Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
             }
         });
     }

package/unit-of-work/ChangeSetPersister.js

@@ -196,10 +196,17 @@ export class ChangeSetPersister {
     }
     async persistManagedEntities(meta, changeSets, options) {
         const size = this.#config.get('batchSize');
-        for (let i = 0; i < changeSets.length; i += size) {
-            const chunk = changeSets.slice(i, i + size);
-            await this.persistManagedEntitiesBatch(meta, chunk, options);
-            await this.reloadVersionValues(meta, chunk, options);
+        // a batch checks the version in all rows or none, so references without a loaded version go separately
+        const hasVersion = (cs) => cs.entity[meta.versionProperty] != null;
+        const groups = meta.ownsVersionProperty()
+            ? [changeSets.filter(hasVersion), changeSets.filter(cs => !hasVersion(cs))]
+            : [changeSets];
+        for (const group of groups) {
+            for (let i = 0; i < group.length; i += size) {
+                const chunk = group.slice(i, i + size);
+                await this.persistManagedEntitiesBatch(meta, chunk, options);
+                await this.reloadVersionValues(meta, chunk, options);
+            }
         }
     }
     checkConcurrencyKeys(meta, changeSet, cond) {
@@ -223,9 +230,14 @@ export class ChangeSetPersister {
         });
         const cond = [];
         const payload = [];
+        // like in `updateEntity()`, but the batch needs the version in all rows or none
+        const versioned = meta.ownsVersionProperty() && changeSets.every(cs => cs.entity[meta.versionProperty] != null);
         for (const changeSet of changeSets) {
             const where = changeSet.getPrimaryKey(true);
             this.checkConcurrencyKeys(meta, changeSet, where);
+            if (versioned) {
+                where[meta.versionProperty] = this.#platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            }
             cond.push(where);
             payload.push(changeSet.payload);
         }
@@ -235,6 +247,12 @@ export class ChangeSetPersister {
         // from those to be able to match them with `getSerializedPrimaryKey()` of the entity
         const pkFields = meta.getPrimaryProps().flatMap(prop => prop.fieldNames);
         res.rows?.forEach(item => map.set(Utils.getPrimaryKeyHash(pkFields.map(field => item[field])), item));
+        if ((meta.ownsVersionProperty() || meta.getOwnConcurrencyCheckKeys().length > 0) &&
+            res.affectedRows < changeSets.length) {
+            // without `returning`, the stale entity can't be identified, so we report the first one
+            const failed = changeSets.find(cs => !map.has(helper(cs.entity).getSerializedPrimaryKey())) ?? changeSets[0];
+            throw OptimisticLockError.lockFailed(failed.entity);
+        }
         for (const changeSet of changeSets) {
             if (res.rows) {
                 const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
@@ -484,7 +502,8 @@ export class ChangeSetPersister {
         }
         if (upsert) {
             for (const prop of meta.props) {
-                if (prop.customType && prop.name in mapped) {
+                // null is not converted, the same way the hydrator handles it
+                if (prop.customType && mapped[prop.name] != null) {
                     mapped[prop.name] = prop.customType.convertToJSValue(mapped[prop.name], this.#platform);
                 }
             }

package/unit-of-work/CommitOrderCalculator.js

@@ -44,7 +44,8 @@ export class CommitOrderCalculator {
         if (!toOneOwner && !toManyOwner) {
             return;
         }
-        const propertyType = prop.targetMeta?.root._id;
+        // TPT tables are separate nodes and the FK references the target's own table, not the root
+        const propertyType = (prop.targetMeta?.inheritanceType === 'tpt' ? prop.targetMeta : prop.targetMeta?.root)?._id;
         if (propertyType == null || !this.hasNode(propertyType)) {
             return;
         }

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

@@ -1,9 +1,9 @@
 import type { AnyEntity, EntityMetadata } from '../typings.js';
-/** @internal Stores managed entity instances keyed by their primary key hash, ensuring each row is loaded once. */
+/** @internal Stores managed entity instances keyed by their primary key hash (and `targetKey` values), ensuring each row is loaded once. */
 export declare class IdentityMap {
     #private;
     constructor(defaultSchema?: string);
-    /** Stores an entity in the identity map under its primary key hash. */
+    /** Stores an entity in the identity map under its primary key hash and the `targetKey` values referencing it. */
     store<T>(item: T): void;
     /**
      * Stores an entity under an alternate key (non-PK property).
@@ -25,6 +25,7 @@ export declare class IdentityMap {
     /** Returns all entities currently in the identity map. */
     values(): AnyEntity[];
     [Symbol.iterator](): IterableIterator<AnyEntity>;
+    private getEntities;
     /** Returns all hash keys currently in the identity map. */
     keys(): string[];
     /**

package/unit-of-work/IdentityMap.js

@@ -1,15 +1,29 @@
-/** @internal Stores managed entity instances keyed by their primary key hash, ensuring each row is loaded once. */
+/** @internal Stores managed entity instances keyed by their primary key hash (and `targetKey` values), ensuring each row is loaded once. */
 export class IdentityMap {
     #defaultSchema;
     #registry = new Map();
     /** Tracks alternate key hashes for each entity so we can clean them up on delete */
     #alternateKeys = new WeakMap();
+    #storesWithAlternateKeys = new WeakSet();
     constructor(defaultSchema) {
         this.#defaultSchema = defaultSchema;
     }
-    /** Stores an entity in the identity map under its primary key hash. */
+    /** Stores an entity in the identity map under its primary key hash and the `targetKey` values referencing it. */
     store(item) {
-        this.getStore(item.__meta.root).set(this.getPkHash(item), item);
+        const meta = item.__meta.root;
+        const wrapped = item.__helper;
+        // PK-less references (known only by a `targetKey`) would share one slot that outlives their later removal
+        if (!meta.targetKeys || wrapped.hasPrimaryKey()) {
+            this.getStore(meta).set(this.getPkHash(item), item);
+        }
+        // references resolved via `targetKey` look the entity up by that key instead of the PK
+        for (const key of meta.targetKeys ?? []) {
+            const value = item[key];
+            if (value != null) {
+                const schema = wrapped.__schema ?? meta.schema ?? this.#defaultSchema;
+                this.storeByKey(item, key, '' + value, schema);
+            }
+        }
     }
     /**
      * Stores an entity under an alternate key (non-PK property).
@@ -17,7 +31,9 @@ export class IdentityMap {
      */
     storeByKey(item, key, value, schema) {
         const hash = this.getKeyHash(key, value, schema);
-        this.getStore(item.__meta.root).set(hash, item);
+        const store = this.getStore(item.__meta.root);
+        store.set(hash, item);
+        this.#storesWithAlternateKeys.add(store);
         // Track this alternate key so we can clean it up when the entity is deleted
         let keys = this.#alternateKeys.get(item);
         if (!keys) {
@@ -35,7 +51,10 @@ export class IdentityMap {
         const altKeys = this.#alternateKeys.get(item);
         if (altKeys) {
             for (const hash of altKeys) {
-                store.delete(hash);
+                // the hash might be owned by another entity by now, e.g. after swapping unique values
+                if (store.get(hash) === item) {
+                    store.delete(hash);
+                }
             }
             this.#alternateKeys.delete(item);
         }
@@ -69,7 +88,7 @@ export class IdentityMap {
     values() {
         const ret = [];
         for (const store of this.#registry.values()) {
-            for (const item of store.values()) {
+            for (const item of this.getEntities(store)) {
                 ret.push(item);
             }
         }
@@ -77,11 +96,15 @@ export class IdentityMap {
     }
     *[Symbol.iterator]() {
         for (const store of this.#registry.values()) {
-            for (const item of store.values()) {
+            for (const item of this.getEntities(store)) {
                 yield item;
             }
         }
     }
+    getEntities(store) {
+        // an entity indexed by alternate keys occupies several slots of its store
+        return this.#storesWithAlternateKeys.has(store) ? new Set(store.values()) : store.values();
+    }
     /** Returns all hash keys currently in the identity map. */
     keys() {
         const ret = [];