@mikro-orm/core 7.2.0-dev.3 → 7.2.0-dev.5

package/cache/CacheAdapter.d.ts

@@ -1,9 +1,10 @@
 /** Interface for async-capable cache storage used by result cache and metadata cache. */
 export interface CacheAdapter {
     /**
-     * Gets the items under `name` key from the cache.
+     * Gets the items under `name` key from the cache. When `origin` is provided, adapters that
+     * track the entry origin should ignore entries cached from a different source file.
      */
-    get<T = any>(name: string): T | Promise<T | undefined> | undefined;
+    get<T = any>(name: string, origin?: string): T | Promise<T | undefined> | undefined;
     /**
      * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
      */
@@ -24,9 +25,10 @@ export interface CacheAdapter {
 /** Synchronous variant of CacheAdapter, used for metadata cache where async access is not needed. */
 export interface SyncCacheAdapter extends CacheAdapter {
     /**
-     * Gets the items under `name` key from the cache.
+     * Gets the items under `name` key from the cache. When `origin` is provided, adapters that
+     * track the entry origin should ignore entries cached from a different source file.
      */
-    get<T = any>(name: string): T | undefined;
+    get<T = any>(name: string, origin?: string): T | undefined;
     /**
      * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
      */

package/cache/FileCacheAdapter.d.ts

@@ -8,7 +8,7 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     /**
      * @inheritDoc
      */
-    get(name: string): any;
+    get(name: string, origin?: string): any;
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -16,12 +16,17 @@ export class FileCacheAdapter {
     /**
      * @inheritDoc
      */
-    get(name) {
+    get(name, origin) {
         const path = this.path(name);
         if (!existsSync(path)) {
             return null;
         }
         const payload = fs.readJSONSync(path);
+        // Two classes with the same name share the cache key, ignore entries cached
+        // from a different source file.
+        if (origin && fs.absolutePath(payload.origin, this.#baseDir) !== fs.absolutePath(origin, this.#baseDir)) {
+            return null;
+        }
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;

package/drivers/DatabaseDriver.d.ts

@@ -64,6 +64,13 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;
     };
+    /**
+     * Restores the JS value of a single cursor offset: ISO strings become `Date` instances based on the
+     * property type (never based on the string shape alone), and custom types are restored via
+     * `convertToJSValue`. Values compared against a JSON document keep their serialized form instead,
+     * unless the platform preserves native date types inside JSON documents (mongo).
+     */
+    private mapCursorOffset;
     protected createCursorCondition<T extends object>(definition: (readonly [keyof T & string, QueryOrder])[], offsets: Dictionary[], inverse: boolean, meta: EntityMetadata<T>): FilterQuery<T>;
     /** @internal */
     mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;

package/drivers/DatabaseDriver.js

@@ -7,8 +7,11 @@ import { EntityManager } from '../EntityManager.js';
 import { CursorError, ValidationError } from '../errors.js';
 import { DriverException } from '../exceptions.js';
 import { helper } from '../entity/wrap.js';
+import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { JsonType } from '../types/JsonType.js';
+import { DateTimeType } from '../types/DateTimeType.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 import { MikroORM } from '../MikroORM.js';
 /** Abstract base class for all database drivers, implementing common driver logic. */
 export class DatabaseDriver {
@@ -141,13 +144,24 @@ export class DatabaseDriver {
             return !!val && typeof val === 'object' && key in val;
         };
         const createCursor = (val, key, inverse = false) => {
-            let def = isCursor(val, key) ? val[key] : val;
-            if (Utils.isPlainObject(def)) {
-                def = Cursor.for(meta, def, orderBy);
+            const def = Reference.unwrapReference((isCursor(val, key) ? val[key] : val));
+            let offsets;
+            // entity (and reference) instances are supported as cursors too, their properties are read the same way
+            if (Utils.isPlainObject(def) || Utils.isEntity(def)) {
+                // POJO values are already JS values, extract them ordered per the definition,
+                // without the JSON round trip `Cursor.for` + `Cursor.decode` would impose
+                offsets = definition.map(([key]) => {
+                    if (def[key] === undefined) {
+                        throw CursorError.missingValue(meta.className, key);
+                    }
+                    return def[key];
+                });
             }
-            /* v8 ignore next */
-            const offsets = def ? Cursor.decode(def) : [];
-            if (definition.length === offsets.length) {
+            else {
+                /* v8 ignore next */
+                offsets = def ? Cursor.decode(def) : [];
+            }
+            if (definition.length > 0 && definition.length === offsets.length) {
                 return this.createCursorCondition(definition, offsets, inverse, meta);
             }
             /* v8 ignore next */
@@ -174,19 +188,67 @@ export class DatabaseDriver {
             const dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
             return { [prop]: dir };
         };
+        // the cursor condition is created at the driver level, after the EM already converted custom types
+        // in the user `where`, so we need to run the same conversion over it explicitly
+        const where = QueryHelper.processWhere({
+            where: ($and.length > 1 ? { $and } : { ...$and[0] }),
+            entityName: meta.class,
+            metadata: this.metadata,
+            platform: this.platform,
+            convertCustomTypes: options.convertCustomTypes,
+        });
         return {
             orderBy: definition.map(([prop, direction]) => createOrderBy(prop, direction)),
-            where: ($and.length > 1 ? { $and } : { ...$and[0] }),
+            where,
         };
     }
+    /**
+     * Restores the JS value of a single cursor offset: ISO strings become `Date` instances based on the
+     * property type (never based on the string shape alone), and custom types are restored via
+     * `convertToJSValue`. Values compared against a JSON document keep their serialized form instead,
+     * unless the platform preserves native date types inside JSON documents (mongo).
+     */
+    mapCursorOffset(prop, value, insideJson) {
+        if (Utils.isScalarReference(value)) {
+            value = value.unwrap();
+        }
+        // scalar direction on a relation orders by its primary key
+        if (Utils.isEntity(value, true)) {
+            value = helper(value).getPrimaryKey();
+        }
+        if (value == null) {
+            return value;
+        }
+        if (insideJson && !this.platform.preservesDatesInsideJson()) {
+            // compared against the JSON document, which holds the serialized form
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            // restore the JS value from the serialized form, `processWhere` then converts it to
+            // the database form, which is what the JSON document holds for custom typed props
+            return prop?.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
+        }
+        if (typeof value === 'string' &&
+            (prop?.runtimeType === 'Date' ||
+                (prop?.customType && this.platform.getMappedType(prop.columnTypes?.[0] ?? '') instanceof DateTimeType))) {
+            value = new Date(value);
+        }
+        return prop?.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
+    }
     createCursorCondition(definition, offsets, inverse, meta) {
-        const createCondition = (prop, direction, offset, eq = false, path = prop) => {
+        const createCondition = (prop, direction, offset, eq = false, path = prop, properties = meta.properties, insideJson = false) => {
+            const propMeta = properties[prop];
             if (Utils.isPlainObject(direction)) {
                 if (offset === undefined) {
                     throw CursorError.missingValue(meta.className, path);
                 }
+                // POJO cursors can carry entity, reference or embeddable class instances, read their properties directly
+                offset = Reference.unwrapReference(offset);
+                const childProps = propMeta?.kind === ReferenceKind.EMBEDDED ? propMeta.embeddedProps : propMeta?.targetMeta?.properties;
+                insideJson ||=
+                    (propMeta?.kind === ReferenceKind.EMBEDDED && !!propMeta.object) || propMeta?.customType instanceof JsonType;
                 const value = Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, createCondition(key, direction[key], offset?.[key], eq, `${path}.${key}`));
+                    Object.assign(o, createCondition(key, direction[key], offset?.[key], eq, `${path}.${key}`, childProps ?? {}, insideJson));
                     return o;
                 }, {});
                 return { [prop]: value };
@@ -209,6 +271,7 @@ export class DatabaseDriver {
             if (offset === undefined) {
                 throw CursorError.missingValue(meta.className, path);
             }
+            offset = this.mapCursorOffset(propMeta, offset, insideJson);
             // Handle null offset (intentional null cursor value)
             if (offset === null) {
                 if (eq) {

package/hydration/ObjectHydrator.js

@@ -364,6 +364,9 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`    data${dataKey}.forEach((_, idx_${idx}) => {`);
             ret.push(...hydrateEmbedded(prop, [...path, `[idx_${idx}]`], `${dataKey}[idx_${idx}]`).map(l => '    ' + l));
             ret.push(`    });`);
+            ret.push(`  } else if (data${dataKey} === null) {`);
+            /* v8 ignore next */
+            ret.push(`    entity${entityKey} = ${this.config.get('forceUndefined') ? 'undefined' : 'null'};`);
             ret.push(`  }`);
             return ret;
         };

package/metadata/EntitySchema.js

@@ -4,6 +4,8 @@ import { Cascade, ReferenceKind } from '../enums.js';
 import { Type } from '../types/Type.js';
 import { Utils } from '../utils/Utils.js';
 import { EnumArrayType } from '../types/EnumArrayType.js';
+// mirrors `MetadataStorage.META_SYMBOL`, we can't import it here due to a module cycle
+const META_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.META_SYMBOL');
 /** Class-less entity definition that provides a programmatic API for defining entities without decorators. */
 export class EntitySchema {
     /**
@@ -220,8 +222,9 @@ export class EntitySchema {
         // Only set extends if the parent is NOT the auto-generated class for this same entity.
         // When the user extends the auto-generated class (from defineEntity without a class option)
         // and registers their custom class via setClass, we don't want to discover the
-        // auto-generated class as a separate parent entity.
-        if (base !== BaseEntity && base.name !== this._meta.className) {
+        // auto-generated class as a separate parent entity. A parent carrying its own decorator
+        // metadata is a real base class even when a minifier mangles it to the same name as the child.
+        if (base !== BaseEntity && (base.name !== this._meta.className || Object.hasOwn(base, META_SYMBOL))) {
             this._meta.extends ??= base.name ? base : undefined;
         }
     }

package/metadata/MetadataDiscovery.js

@@ -212,6 +212,12 @@ export class MetadataDiscovery {
             .replace(/Array<(.*)>/, '$1') // unwrap array
             .replace(/\[]$/, '') // remove array suffix
             .replace(/\((.*)\)/, '$1'); // unwrap union types
+        // Names can be ambiguous when a minifier mangles two classes to the same name,
+        // so class references also need to be checked by identity.
+        const discoveredByIdentity = (target) => {
+            const cls = EntitySchema.is(target) ? target.meta.class : target;
+            return typeof cls !== 'function' || this.#discovered.some(m => m.class === cls);
+        };
         const missing = [];
         this.#discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
             if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.pivotEntity) {
@@ -219,7 +225,7 @@ export class MetadataDiscovery {
                 const target = typeof pivotEntity === 'function' && !pivotEntity.prototype
                     ? pivotEntity()
                     : pivotEntity;
-                if (!this.#discovered.find(m => m.className === Utils.className(target))) {
+                if (!this.#discovered.find(m => m.className === Utils.className(target)) || !discoveredByIdentity(target)) {
                     missing.push(target);
                 }
             }
@@ -227,7 +233,8 @@ export class MetadataDiscovery {
                 const target = typeof prop.entity === 'function' && !prop.entity.prototype ? prop.entity() : prop.type;
                 if (!unwrap(prop.type)
                     .split(/ ?\| ?/)
-                    .every(type => this.#discovered.find(m => m.className === type))) {
+                    .every(type => this.#discovered.find(m => m.className === type)) ||
+                    !Utils.asArray(target).every(discoveredByIdentity)) {
                     missing.push(...Utils.asArray(target));
                 }
             }
@@ -275,9 +282,11 @@ export class MetadataDiscovery {
                 continue;
             }
             parent = Object.getPrototypeOf(meta.class);
-            // Skip if parent is the auto-generated base class for the same entity (from setClass usage)
+            // Skip if parent is the auto-generated base class for the same entity (from setClass usage).
+            // A parent carrying its own decorator metadata is a real base class even when a minifier
+            // mangles it to the same name as the child.
             if (parent.name !== '' &&
-                parent.name !== meta.className &&
+                (parent.name !== meta.className || Object.hasOwn(parent, MetadataStorage.META_SYMBOL)) &&
                 !this.#metadata.has(parent) &&
                 parent !== BaseEntity) {
                 this.discoverReferences([parent], false);
@@ -311,7 +320,12 @@ export class MetadataDiscovery {
         const cls = entity;
         const path = cls[MetadataStorage.PATH_SYMBOL];
         if (path) {
-            const meta = Utils.copy(MetadataStorage.getMetadata(cls.name, path), false);
+            // Prefer the metadata stored on the class reference, the `className-path` key can
+            // collide when a minifier mangles two classes to the same name.
+            const stored = Object.hasOwn(cls, MetadataStorage.META_SYMBOL)
+                ? cls[MetadataStorage.META_SYMBOL]
+                : MetadataStorage.getMetadata(cls.name, path);
+            const meta = Utils.copy(stored, false);
             meta.path = path;
             this.#metadata.set(cls, meta);
         }
@@ -834,7 +848,7 @@ export class MetadataDiscovery {
             pivotMeta.properties[primaryProp.name] = primaryProp;
             pivotMeta.compositePK = false;
         }
-        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !isCompositePK, nullable: false });
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !prop.fixedOrder, nullable: false });
         this.initFieldName(discriminatorProp);
         pivotMeta.properties[discriminatorColumn] = discriminatorProp;
         const columnTypes = this.getPrimaryKeyColumnTypes(meta);
@@ -849,7 +863,7 @@ export class MetadataDiscovery {
             pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, persist: false });
         }
         else {
-            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, primary: true, nullable: false });
+            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, primary: !prop.fixedOrder, nullable: false });
         }
         pivotMeta.properties[targetMeta.className + '_inverse'] = this.definePivotProperty(prop, targetMeta.className + '_inverse', targetMeta.class, prop.discriminator, false, false);
         // Create virtual M:1 relation to the polymorphic owner for single-query join loading
@@ -871,11 +885,11 @@ export class MetadataDiscovery {
         const discriminatorColumn = prop.discriminatorColumn;
         const targets = prop.polymorphTargets;
         pivotMeta.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, prop.discriminator, true, false);
-        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: true, nullable: false });
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !prop.fixedOrder, nullable: false });
         this.initFieldName(discriminatorProp);
         pivotMeta.properties[discriminatorColumn] = discriminatorProp;
         const firstTargetColumnTypes = this.getPrimaryKeyColumnTypes(targets[0]);
-        pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, firstTargetColumnTypes, [...prop.inverseJoinColumns], { type: targets[0].className, primary: true, nullable: false });
+        pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, firstTargetColumnTypes, [...prop.inverseJoinColumns], { type: targets[0].className, primary: !prop.fixedOrder, nullable: false });
         pivotMeta.polymorphicDiscriminatorMap ??= {};
         for (const targetMeta of targets) {
             const relationName = `${prop.discriminator}_${targetMeta.tableName}`;
@@ -1184,7 +1198,11 @@ export class MetadataDiscovery {
             return;
         }
         visited.add(embeddedProp);
-        const embeddable = this.#discovered.find(m => m.name === embeddedProp.type);
+        // Prefer resolution via the class reference, the name can be ambiguous when a minifier
+        // mangles two classes to the same name. Only named metadata counts, an auto-discovered
+        // class without the `@Embeddable()` decorator should still fail as unknown below.
+        const embeddable = this.#discovered.find(m => m.name && m.class === embeddedProp.target) ??
+            this.#discovered.find(m => m.name === embeddedProp.type);
         if (!embeddable) {
             throw MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
         }

package/metadata/MetadataProvider.js

@@ -92,7 +92,7 @@ export class MetadataProvider {
         if (!this.useCache()) {
             return undefined;
         }
-        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
+        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta), meta.path);
         if (cache) {
             this.loadFromCache(meta, cache);
             meta.root = root;

package/metadata/MetadataStorage.d.ts

@@ -1,13 +1,14 @@
-import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
+import { type Dictionary, type EntityCtor, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 /** Registry that stores and provides access to entity metadata by class, name, or id. */
 export declare class MetadataStorage {
     #private;
     static readonly PATH_SYMBOL: unique symbol;
+    static readonly META_SYMBOL: unique symbol;
     constructor(metadata?: Dictionary<EntityMetadata>);
-    /** Returns the global metadata dictionary, or a specific entry by entity name and path. */
+    /** Returns the global metadata dictionary, or a specific entry by entity name and path (keyed by the class reference when `target` is provided). */
     static getMetadata(): Dictionary<EntityMetadata>;
-    static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
+    static getMetadata<T = any>(entity: string, path: string, target?: EntityCtor): EntityMetadata<T>;
     /** Checks whether an entity with the given class name exists in the global metadata. */
     static isKnownEntity(name: string): boolean;
     /** Clears all entries from the global metadata registry. */

package/metadata/MetadataStorage.js

@@ -11,6 +11,7 @@ function getGlobalStorage(namespace) {
 /** Registry that stores and provides access to entity metadata by class, name, or id. */
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
+    static META_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.META_SYMBOL');
     static #metadata = getGlobalStorage('metadata');
     #metadataMap = new Map();
     #idMap;
@@ -26,8 +27,21 @@ export class MetadataStorage {
             this.#metadataMap.set(meta.class, meta);
         }
     }
-    static getMetadata(entity, path) {
+    static getMetadata(entity, path, target) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+        // Key the registry by the class reference when available, so two classes minified
+        // to the same mangled name don't collide on the `className-path` key.
+        if (key && target) {
+            if (!Object.hasOwn(target, MetadataStorage.META_SYMBOL)) {
+                Object.defineProperty(target, MetadataStorage.META_SYMBOL, {
+                    value: new EntityMetadata({ className: entity, path }),
+                    writable: true,
+                });
+            }
+            // Keep the name-keyed entry in sync, the class-keyed metadata survives `MetadataStorage.clear()`.
+            MetadataStorage.#metadata[key] = target[MetadataStorage.META_SYMBOL];
+            return target[MetadataStorage.META_SYMBOL];
+        }
         if (key && !MetadataStorage.#metadata[key]) {
             MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
         }

package/metadata/Routine.js

@@ -135,6 +135,9 @@ export class Routine {
         return new Routine(config);
     }
     static is(item) {
-        return item instanceof Routine;
+        if (item instanceof Routine) {
+            return true;
+        }
+        return item != null && typeof item === 'object' && item.constructor?.name === 'Routine' && 'type' in item;
     }
 }

package/naming-strategy/AbstractNamingStrategy.js

@@ -10,7 +10,8 @@ export class AbstractNamingStrategy {
     classToMigrationName(timestamp, customMigrationName) {
         let migrationName = `Migration${timestamp}`;
         if (customMigrationName) {
-            migrationName += `_${customMigrationName}`;
+            // the name becomes part of a class identifier
+            migrationName += `_${customMigrationName.replace(/[^$\p{ID_Continue}]+/gu, '_')}`;
         }
         return migrationName;
     }

package/naming-strategy/NamingStrategy.d.ts

@@ -9,7 +9,8 @@ export interface NamingStrategy {
      */
     classToTableName(entityName: string, tableName?: string): string;
     /**
-     * Return a migration name. This name should allow ordering.
+     * Return a migration name. This name should allow ordering, and has to be a valid class identifier,
+     * as it is used as the class name in the generated migration file.
      */
     classToMigrationName(timestamp: string, customMigrationName?: string): string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.0-dev.3",
+  "version": "7.2.0-dev.5",
   "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

@@ -227,6 +227,8 @@ export declare abstract class Platform {
     formatIndexHint(indexNames: string[]): string | undefined;
     /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically(): boolean;
+    /** Whether date values inside JSON documents keep their native type (e.g. BSON dates), instead of being serialized to ISO strings. */
+    preservesDatesInsideJson(): boolean;
     /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
     /** Converts a database JSON value to its JS representation. */

package/platforms/Platform.js

@@ -465,6 +465,10 @@ export class Platform {
     convertsJsonAutomatically() {
         return true;
     }
+    /** Whether date values inside JSON documents keep their native type (e.g. BSON dates), instead of being serialized to ISO strings. */
+    preservesDatesInsideJson() {
+        return false;
+    }
     /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);

package/typings.d.ts

@@ -1470,6 +1470,8 @@ export interface IMigrationGenerator {
 }
 /** Interface that all migration classes must implement. */
 export interface Migration {
+    /** Stable migration name, used instead of the class name (which minifiers can mangle). */
+    name?: string;
     up(): Promise<void> | void;
     down(): Promise<void> | void;
     isTransactional(): boolean;

package/unit-of-work/ChangeSet.js

@@ -29,15 +29,18 @@ export class ChangeSet {
         else {
             this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
         }
-        if (!this.meta.compositePK &&
-            this.meta.getPrimaryProp().targetMeta?.compositePK &&
-            typeof this.primaryKey === 'object' &&
-            this.primaryKey !== null) {
-            this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
-                return this.primaryKey[childPK];
-            });
+        const primaryProp = this.meta.getPrimaryProp();
+        const relationPK = !this.meta.compositePK && !!primaryProp.targetMeta?.compositePK;
+        // arrays are already the ordered tuple of the target's primary keys
+        if (relationPK && Utils.isPlainObject(this.primaryKey)) {
+            const pk = this.primaryKey;
+            this.primaryKey = primaryProp.targetMeta.primaryKeys.map(childPK => pk[childPK]);
         }
         if (object && this.primaryKey != null) {
+            // the whole tuple belongs to the single relation PK, it must not be spread over the (single) PK prop
+            if (relationPK) {
+                return { [primaryProp.name]: this.primaryKey };
+            }
             return Utils.primaryKeyToObject(this.meta, this.primaryKey);
         }
         return this.primaryKey ?? null;

package/unit-of-work/ChangeSetPersister.js

@@ -3,7 +3,7 @@ import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { helper } from '../entity/wrap.js';
 import { ChangeSetType } from './ChangeSet.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
-import { Utils } from '../utils/Utils.js';
+import { equals, Utils } from '../utils/Utils.js';
 import { OptimisticLockError, ValidationError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 /** @internal Executes change sets against the database, handling inserts, updates, and deletes. */
@@ -230,11 +230,15 @@ export class ChangeSetPersister {
         }
         const res = await this.#driver.nativeUpdateMany(meta.class, cond, payload, options);
         const map = new Map();
-        res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.#platform, true), item));
+        // returning rows are not mapped yet, so they are keyed by field names - we need to build the hash
+        // 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));
         for (const changeSet of changeSets) {
             if (res.rows) {
                 const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
-                this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
+                // STI batches can mix child types, so map through the change set's own metadata
+                this.mapReturnedValues(changeSet.entity, changeSet.payload, row, changeSet.meta);
             }
             changeSet.persisted = true;
         }
@@ -334,7 +338,8 @@ export class ChangeSetPersister {
         });
         const res = await this.#driver.find(meta.root.class, { $or }, options);
         if (res.length !== changeSets.length) {
-            const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
+            // 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]));
             const entity = changeSets.find(cs => {
                 return !res.some(row => compare(Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
             }).entity;
@@ -375,7 +380,8 @@ export class ChangeSetPersister {
             changeSets.forEach(cs => {
                 Utils.keys(cs.payload).forEach(k => {
                     if (isRaw(cs.payload[k]) && isRaw(cs.entity[k])) {
-                        returning.add(meta.properties[k]);
+                        // STI batches can mix child types, so the property might not exist on `meta`
+                        returning.add(cs.meta.properties[k]);
                     }
                 });
             });
@@ -400,12 +406,14 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
-        const data = await this.#driver.find(meta.class, { [pk]: { $in: pks } }, options);
+        // a mixed STI batch shares one table but the child discriminator would filter out the siblings
+        const target = changeSets.some(cs => cs.meta !== meta) && meta.root.discriminatorColumn ? meta.root : meta;
+        const data = await this.#driver.find(target.class, { [pk]: { $in: pks } }, options);
         const map = new Map();
         data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.#platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
-            this.#hydrator.hydrate(changeSet.entity, meta, data, this.#factory, 'full', false, true);
+            this.#hydrator.hydrate(changeSet.entity, changeSet.meta, data, this.#factory, 'full', false, true);
             Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
     }

package/utils/AbstractMigrator.d.ts

@@ -103,7 +103,7 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
         name: string;
         path: string;
     }): RunnableMigration;
-    protected initialize(MigrationClass: Constructor<Migration>, name: string): RunnableMigration;
+    protected initialize(MigrationClass: Constructor<Migration>, name?: string): RunnableMigration;
     /**
      * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
      * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be

package/utils/AbstractMigrator.js

@@ -358,7 +358,8 @@ export class AbstractMigrator {
     initialize(MigrationClass, name) {
         const instance = new MigrationClass(this.driver, this.config);
         return {
-            name: this.storage.getMigrationName(name),
+            // the constructor name is the last resort, minifiers can mangle it (e.g. when bundling)
+            name: this.storage.getMigrationName(name ?? instance.name ?? MigrationClass.name),
             up: afterRun => this.runner.run(instance, 'up', afterRun),
             down: afterRun => this.runner.run(instance, 'down', afterRun),
         };
@@ -409,7 +410,7 @@ export class AbstractMigrator {
         if (this.options.migrationsList) {
             return this.options.migrationsList.map(migration => {
                 if (typeof migration === 'function') {
-                    return this.initialize(migration, migration.name);
+                    return this.initialize(migration);
                 }
                 return this.initialize(migration.class, migration.name);
             });

package/utils/Configuration.js

@@ -86,7 +86,8 @@ const DEFAULTS = {
         snapshot: true,
         snapshotOnMigrate: true,
         emit: 'ts',
-        fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name : ''}`,
+        // mirrors `NamingStrategy.classToMigrationName`, so the file name matches the class it declares
+        fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name.replace(/[^$\p{ID_Continue}]+/gu, '_') : ''}`,
     },
     schemaGenerator: {
         createForeignKeyConstraints: true,

package/utils/Cursor.js

@@ -150,12 +150,7 @@ export class Cursor {
         return Buffer.from(JSON.stringify(value)).toString('base64url');
     }
     static decode(value) {
-        return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')).map((value) => {
-            if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/.exec(value)) {
-                return new Date(value);
-            }
-            return value;
-        });
+        return JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
     }
     static getDefinition(meta, orderBy) {
         return Utils.asArray(orderBy).flatMap(order => {

package/utils/EntityComparator.js

@@ -164,7 +164,9 @@ export class EntityComparator {
         const lines = [];
         const context = new Map();
         context.set('isEntityOrRef', (val) => Utils.isEntity(val, true));
-        context.set('getCompositeKeyValue', (val) => Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.#platform)));
+        context.set('getCompositeKeyValue', (val) => 
+        // deep flatten, nested composite PKs produce nested arrays that would be comma-joined by the hash
+        Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.#platform), true));
         context.set('getPrimaryKeyHash', (val) => Utils.getPrimaryKeyHash(Utils.asArray(val)));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const pks = entity.__helper.__pk ? getCompositeKeyValue(entity.__helper.__pk) : [`);
@@ -447,6 +449,7 @@ export class EntityComparator {
         const ret = [];
         const padding = ' '.repeat(level * 2);
         const idx = this.#tmpIndex++;
+        ret.push(`${padding}if (entity${entityKey} === null) ret${dataKey} = null;`);
         ret.push(`${padding}if (Array.isArray(entity${entityKey})) {`);
         ret.push(`${padding}  ret${dataKey} = [];`);
         ret.push(`${padding}  entity${entityKey}.forEach((_, idx_${idx}) => {`);

package/utils/QueryHelper.d.ts

@@ -40,6 +40,11 @@ export declare class QueryHelper {
     static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
     static isFilterActive<T>(meta: EntityMetadata<T>, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
+    /**
+     * Composite PK conditions are keyed by a hash of all the PK names, which `findProperty` cannot
+     * resolve, so the custom types have to be applied positionally instead.
+     */
+    private static processCompositeCustomTypes;
     private static isSupportedOperator;
     private static processJsonCondition;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;

package/utils/QueryHelper.js

@@ -227,6 +227,13 @@ export class QueryHelper {
             if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
+            else if (!prop &&
+                meta?.compositePK &&
+                convertCustomTypes &&
+                Array.isArray(value) &&
+                key === Utils.getPrimaryKeyHash(meta.primaryKeys)) {
+                value = QueryHelper.processCompositeCustomTypes(value, meta, platform);
+            }
             // 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) {
@@ -321,6 +328,24 @@ export class QueryHelper {
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
     }
+    /**
+     * Composite PK conditions are keyed by a hash of all the PK names, which `findProperty` cannot
+     * resolve, so the custom types have to be applied positionally instead.
+     */
+    static processCompositeCustomTypes(value, meta, platform) {
+        const props = meta.primaryKeys.map(pk => meta.properties[pk]);
+        if (!props.some(prop => prop.customType)) {
+            return value;
+        }
+        // the tuple can be longer than the PK when the user passes a malformed condition
+        const convert = (tuple) => tuple.map((val, idx) => {
+            if (!props[idx]?.customType) {
+                return val;
+            }
+            return QueryHelper.processCustomType(props[idx], val, platform, undefined, true);
+        });
+        return value.every(val => Array.isArray(val)) ? value.map(val => convert(val)) : convert(value);
+    }
     static isSupportedOperator(key) {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }

package/utils/TransactionManager.d.ts

@@ -50,6 +50,12 @@ export declare class TransactionManager {
      * Merges entities from fork to parent EntityManager.
      */
     private mergeEntitiesToParent;
+    /**
+     * Returns the property names a given property is tracked and snapshotted under, paired with their values.
+     * Inlined embeddables are hydrated as a single object, so only their leaves tell whether it is complete.
+     */
+    private getTrackedValues;
+    private restore;
     /**
      * Registers a deletion handler to unset entity identities after flush.
      */

package/utils/TransactionManager.js

@@ -169,19 +169,52 @@ export class TransactionManager {
                 if (!wrapped.__initialized && parentWrapped.__initialized) {
                     continue;
                 }
-                parentWrapped.__data = wrapped.__data;
-                parentWrapped.__originalEntityData = wrapped.__originalEntityData;
+                const parentData = parentWrapped.__data;
+                const parentSnapshot = parentWrapped.__originalEntityData;
+                parentWrapped.__data = { ...wrapped.__data };
+                const originalEntityData = { ...wrapped.__originalEntityData };
                 for (const prop of meta.hydrateProps) {
+                    const tracked = this.getTrackedValues(prop, entity[prop.name]);
+                    // the fork entity can be partially loaded, and propagating a property it does not know about
+                    // would clobber the parent state, so we restore both its value and its snapshot entries
+                    if (!tracked.every(([key, value]) => value !== undefined || wrapped.__loadedProperties.has(key))) {
+                        this.restore(parentWrapped.__data, parentData, prop.name);
+                        tracked.forEach(([key]) => this.restore(originalEntityData, parentSnapshot, key));
+                        continue;
+                    }
                     if (prop.kind === ReferenceKind.SCALAR) {
                         parentEntity[prop.name] = entity[prop.name];
                     }
                 }
+                if (wrapped.__originalEntityData) {
+                    parentWrapped.__originalEntityData = originalEntityData;
+                }
             }
             else {
                 parentUoW.merge(entity, new Set([entity]));
             }
         }
     }
+    /**
+     * Returns the property names a given property is tracked and snapshotted under, paired with their values.
+     * Inlined embeddables are hydrated as a single object, so only their leaves tell whether it is complete.
+     */
+    getTrackedValues(prop, value) {
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+            return Object.values(prop.embeddedProps).flatMap(child => {
+                return this.getTrackedValues(child, value?.[child.embedded[1]]);
+            });
+        }
+        return [[prop.name, value]];
+    }
+    restore(target, source, key) {
+        if (source && key in source) {
+            target[key] = source[key];
+        }
+        else {
+            delete target[key];
+        }
+    }
     /**
      * Registers a deletion handler to unset entity identities after flush.
      */

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.3';
+    static #ORM_VERSION = '7.2.0-dev.5';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -402,7 +402,8 @@ export class Utils {
     static getCompositeKeyHash(data, meta, convertCustomTypes = false, platform, flat = false) {
         let pks = this.getCompositeKeyValue(data, meta, convertCustomTypes, platform);
         if (flat) {
-            pks = Utils.flatten(pks);
+            // deep flatten, nested composite PKs produce nested arrays that would be comma-joined by the hash
+            pks = Utils.flatten(pks, true);
         }
         return Utils.getPrimaryKeyHash(pks);
     }
@@ -462,7 +463,9 @@ export class Utils {
     }
     static getPrimaryKeyCond(entity, primaryKeys) {
         const cond = primaryKeys.reduce((o, pk) => {
-            o[pk] = Utils.extractPK(entity[pk]);
+            const value = entity[pk];
+            // FKs pointing to a composite PK are arrays, which `extractPK` rejects
+            o[pk] = Utils.isPrimaryKey(value, true) ? value : Utils.extractPK(value);
             return o;
         }, {});
         if (Object.values(cond).some(v => v === null)) {

package/utils/clone.js

@@ -112,6 +112,12 @@ export function clone(parent, respectCustomCloneMethod = true) {
             });
         }
         for (const i in parent) {
+            // an own `__proto__` key (as produced by `JSON.parse`) has no own counterpart on
+            // `child` to shadow the inherited accessor, so assigning it would replace the
+            // clone's prototype instead of copying the value
+            if (i === '__proto__') {
+                continue;
+            }
             let attrs;
             if (proto) {
                 attrs = getPropertyDescriptor(proto, i);