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

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.1",
+  "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/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.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) : [`);
@@ -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/RawQueryFragment.d.ts

@@ -61,6 +61,12 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
  * ```
  *
+ * Named parameters are supported via an object of parameters, use `:name` for values and `:name:` for identifiers:
+ *
+ * ```ts
+ * raw('select :col: from geo where city = :city or region = :city', { col: 'city', city: 'Brno' });
+ * ```
+ *
  * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
  *
  * ```ts

package/utils/RawQueryFragment.js

@@ -146,6 +146,12 @@ export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
  * ```
  *
+ * Named parameters are supported via an object of parameters, use `:name` for values and `:name:` for identifiers:
+ *
+ * ```ts
+ * raw('select :col: from geo where city = :city or region = :city', { col: 'city', city: 'Brno' });
+ * ```
+ *
  * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
  *
  * ```ts
@@ -191,13 +197,16 @@ export function raw(sql, params) {
         return Utils.getPrimaryKeyHash(sql);
     }
     if (typeof params === 'object' && !Array.isArray(params)) {
-        const pairs = Object.entries(params);
+        const dict = params;
         const objectParams = [];
-        for (const [key, value] of pairs) {
-            sql = sql.replace(`:${key}:`, '??');
-            sql = sql.replace(`:${key}`, '?');
-            objectParams.push(value);
-        }
+        // single left-to-right scan keeps values in SQL-placeholder order while `::` casts and unknown tokens stay untouched
+        sql = sql.replace(/(?<!:):([$\w]+)(:(?!:))?/g, (match, key, identifier) => {
+            if (!Object.hasOwn(dict, key)) {
+                return match;
+            }
+            objectParams.push(dict[key]);
+            return identifier ? '??' : '?';
+        });
         return new RawQueryFragment(sql, objectParams);
     }
     return new RawQueryFragment(sql, params);

package/utils/RequestContext.d.ts

@@ -17,13 +17,13 @@ export declare class RequestContext {
      * If the handler is async, the return value needs to be awaited.
      * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
      */
-    static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: CreateContextOptions): T;
+    static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: ((name: string) => CreateContextOptions) | CreateContextOptions): T;
     /**
      * Creates new RequestContext instance and runs the code inside its domain.
      * If the handler is async, the return value needs to be awaited.
      * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
      */
-    static enter(em: EntityManager | EntityManager[], options?: CreateContextOptions): void;
+    static enter(em: EntityManager | EntityManager[], options?: ((name: string) => CreateContextOptions) | CreateContextOptions): void;
     /**
      * Returns current RequestContext (if available).
      */

package/utils/RequestContext.js

@@ -50,10 +50,19 @@ export class RequestContext {
     static createContext(em, options = {}) {
         const forks = new Map();
         if (Array.isArray(em)) {
-            em.forEach(em => forks.set(em.name, em.fork({ useContext: true, ...options })));
+            if (typeof options === 'function') {
+                for (const emInstance of em) {
+                    forks.set(emInstance.name, emInstance.fork({ useContext: true, ...options(emInstance.name) }));
+                }
+            }
+            else {
+                for (const emInstance of em) {
+                    forks.set(emInstance.name, emInstance.fork({ useContext: true, ...options }));
+                }
+            }
         }
         else {
-            forks.set(em.name, em.fork({ useContext: true, ...options }));
+            forks.set(em.name, em.fork({ useContext: true, ...(typeof options === 'function' ? options(em.name) : options) }));
         }
         return new RequestContext(forks);
     }

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.1';
+    static #ORM_VERSION = '7.2.0-dev.10';
     /**
      * 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);

package/utils/env-vars.js

@@ -79,6 +79,7 @@ export function loadEnvironmentVars() {
     read2('silent', bool);
     read2('emit');
     read2('snapshot', bool);
+    read2('snapshotOnMigrate', bool);
     read2('snapshotName');
     cleanup(ret, 'migrations');
     ret.schemaGenerator = {};