@mikro-orm/core 7.2.0-dev.0 → 7.2.0-dev.10

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}`;
@@ -942,6 +956,11 @@ export class MetadataDiscovery {
         return primaryProp;
     }
     definePivotProperty(prop, name, type, inverse, owner, selfReferencing) {
+        let index = prop.index ?? this.#platform.indexForeignKeys();
+        if (owner && prop.index) {
+            // owner join columns are the leading prefix of the composite PK, so an explicit `index` only applies to them with `fixedOrder`; a custom index name always belongs to the inverse side
+            index = prop.fixedOrder ? true : this.#platform.indexForeignKeys();
+        }
         const ret = {
             name,
             type: Utils.className(type),
@@ -950,7 +969,7 @@ export class MetadataDiscovery {
             cascade: [Cascade.ALL],
             fixedOrder: prop.fixedOrder,
             fixedOrderColumn: prop.fixedOrderColumn,
-            index: this.#platform.indexForeignKeys(),
+            index,
             primary: !prop.fixedOrder,
             autoincrement: false,
             updateRule: prop.updateRule,
@@ -1184,7 +1203,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/MetadataValidator.js

@@ -1,19 +1,7 @@
-import { Utils } from '../utils/Utils.js';
+import { DANGEROUS_PROPERTY_NAMES, Utils } from '../utils/Utils.js';
 import { normalizePartitionNameForComparison, splitCommaSeparatedIdentifiers } from '../utils/partition-utils.js';
 import { MetadataError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
-/**
- * List of property names that could lead to prototype pollution vulnerabilities.
- * These names should never be used as entity property names because they could
- * allow malicious code to modify object prototypes when property values are assigned.
- *
- * - `__proto__`: Could modify the prototype chain
- * - `constructor`: Could modify the constructor property
- * - `prototype`: Could modify the prototype object
- *
- * @internal
- */
-const DANGEROUS_PROPERTY_NAMES = ['__proto__', 'constructor', 'prototype'];
 /**
  * @internal
  */

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.0",
+  "version": "7.2.0-dev.10",
   "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/ChangeSetComputer.js

@@ -138,7 +138,8 @@ export class ChangeSetComputer {
         return data;
     }
     processProperty(changeSet, prop, target) {
-        if (!target) {
+        // check for `null`/`undefined` explicitly, the target can be a falsy raw PK value like `0` (e.g. with `mapToPk`)
+        if (target == null) {
             const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
             targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
             return;

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/unit-of-work/IdentityMap.d.ts

@@ -12,6 +12,11 @@ export declare class IdentityMap {
     storeByKey<T>(item: T, key: string, value: string, schema?: string): void;
     /** Removes an entity and its alternate key entries from the identity map. */
     delete<T>(item: T): void;
+    /**
+     * Retrieves the entity occupying the same slot as the given one, if any. Hashes the entity the same way `store()`
+     * does, so it matches regardless of the primary key shape — unlike hashing a primary key value obtained elsewhere.
+     */
+    getByEntity<T>(item: T): T | undefined;
     /** Retrieves an entity by its hash key from the identity map. */
     getByHash<T>(meta: EntityMetadata<T>, hash: string): T | undefined;
     /** Returns (or creates) the per-entity-class store within the identity map. */

package/unit-of-work/IdentityMap.js

@@ -40,6 +40,13 @@ export class IdentityMap {
             this.#alternateKeys.delete(item);
         }
     }
+    /**
+     * Retrieves the entity occupying the same slot as the given one, if any. Hashes the entity the same way `store()`
+     * does, so it matches regardless of the primary key shape — unlike hashing a primary key value obtained elsewhere.
+     */
+    getByEntity(item) {
+        return this.getStore(item.__meta.root).get(this.getPkHash(item));
+    }
     /** Retrieves an entity by its hash key from the identity map. */
     getByHash(meta, hash) {
         const store = this.getStore(meta);

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

@@ -48,7 +48,7 @@ export declare class UnitOfWork {
      */
     storeByKey<T extends object>(entity: T, key: string, value: unknown, schema?: string, convertCustomTypes?: boolean): void;
     /** Attempts to extract a primary key from the where condition and look up the entity in the identity map. */
-    tryGetById<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
+    tryGetById<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, schema?: string, strict?: boolean, convertCustomTypes?: boolean): T | null;
     /**
      * Returns map of all managed entities.
      */

package/unit-of-work/UnitOfWork.js

@@ -227,12 +227,12 @@ export class UnitOfWork {
         this.#identityMap.storeByKey(entity, key, '' + value, schema);
     }
     /** Attempts to extract a primary key from the where condition and look up the entity in the identity map. */
-    tryGetById(entityName, where, schema, strict = true) {
+    tryGetById(entityName, where, schema, strict = true, convertCustomTypes) {
         const pk = Utils.extractPK(where, this.#metadata.find(entityName), strict);
         if (!pk) {
             return null;
         }
-        return this.getById(entityName, pk, schema);
+        return this.getById(entityName, pk, schema, convertCustomTypes);
     }
     /**
      * Returns map of all managed entities.

package/utils/AbstractMigrator.d.ts

@@ -95,13 +95,15 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
      */
     unlogMigration(name: string): Promise<void>;
     protected init(): Promise<void>;
+    /** Resolves the migrations path (including source folder auto-detection) without touching the filesystem. */
+    protected resolvePaths(): Promise<void>;
     protected initPaths(): Promise<void>;
     protected initServices(): void;
     protected resolve(params: {
         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

@@ -9,6 +9,7 @@ export class AbstractMigrator {
     options;
     absolutePath;
     initialized = false;
+    #pathsEnsured = false;
     #listeners = new Map();
     constructor(em) {
         this.em = em;
@@ -303,7 +304,8 @@ export class AbstractMigrator {
         this.initialized = true;
         await this.initPaths();
     }
-    async initPaths() {
+    /** Resolves the migrations path (including source folder auto-detection) without touching the filesystem. */
+    async resolvePaths() {
         if (this.absolutePath || this.options.migrationsList) {
             return;
         }
@@ -312,6 +314,14 @@ export class AbstractMigrator {
         /* v8 ignore next */
         const key = this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs ? 'pathTs' : 'path';
         this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
+    }
+    async initPaths() {
+        await this.resolvePaths();
+        if (this.#pathsEnsured || this.options.migrationsList) {
+            return;
+        }
+        this.#pathsEnsured = true;
+        const { fs } = await import('@mikro-orm/core/fs-utils');
         try {
             fs.ensureDir(this.absolutePath);
         }
@@ -348,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),
         };
@@ -399,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.d.ts

@@ -233,6 +233,12 @@ export type MigrationsOptions = {
      * @default true
      */
     snapshot?: boolean;
+    /**
+     * Update the snapshot from the database schema when running migrations up or down.
+     * Disable to keep the snapshot managed solely by `migration:create`.
+     * @default true
+     */
+    snapshotOnMigrate?: boolean;
     /** Custom name for the snapshot file. */
     snapshotName?: string;
     /**

package/utils/Configuration.js

@@ -84,8 +84,10 @@ const DEFAULTS = {
         dropTables: true,
         safe: false,
         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) : [`);
@@ -172,6 +174,10 @@ export class EntityComparator {
                 if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) ? entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey() : entity${this.wrap(pk)},`);
                 }
+                else if (meta.properties[pk].customType) {
+                    const convertorKey = this.registerCustomType(meta.properties[pk], context);
+                    lines.push(`    convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)}),`);
+                }
                 else {
                     lines.push(`    entity${this.wrap(pk)},`);
                 }
@@ -443,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;