@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/unit-of-work/IdentityMap.js

@@ -1,40 +1,67 @@
 export class IdentityMap {
-    defaultSchema;
+    #defaultSchema;
+    #registry = new Map();
+    /** Tracks alternate key hashes for each entity so we can clean them up on delete */
+    #alternateKeys = new WeakMap();
     constructor(defaultSchema) {
-        this.defaultSchema = defaultSchema;
+        this.#defaultSchema = defaultSchema;
     }
-    registry = new Map();
     store(item) {
         this.getStore(item.__meta.root).set(this.getPkHash(item), item);
     }
+    /**
+     * Stores an entity under an alternate key (non-PK property).
+     * This allows looking up entities by unique properties that are not the primary key.
+     */
+    storeByKey(item, key, value, schema) {
+        const hash = this.getKeyHash(key, value, schema);
+        this.getStore(item.__meta.root).set(hash, item);
+        // Track this alternate key so we can clean it up when the entity is deleted
+        let keys = this.#alternateKeys.get(item);
+        if (!keys) {
+            keys = new Set();
+            this.#alternateKeys.set(item, keys);
+        }
+        keys.add(hash);
+    }
     delete(item) {
-        this.getStore(item.__meta.root).delete(this.getPkHash(item));
+        const meta = item.__meta.root;
+        const store = this.getStore(meta);
+        store.delete(this.getPkHash(item));
+        // Also delete any alternate key entries for this entity
+        const altKeys = this.#alternateKeys.get(item);
+        if (altKeys) {
+            for (const hash of altKeys) {
+                store.delete(hash);
+            }
+            this.#alternateKeys.delete(item);
+        }
     }
     getByHash(meta, hash) {
         const store = this.getStore(meta);
         return store.has(hash) ? store.get(hash) : undefined;
     }
     getStore(meta) {
-        const store = this.registry.get(meta.class);
+        const store = this.#registry.get(meta.class);
         if (store) {
             return store;
         }
         const newStore = new Map();
-        this.registry.set(meta.class, newStore);
+        this.#registry.set(meta.class, newStore);
         return newStore;
     }
     clear() {
-        this.registry.clear();
+        this.#registry.clear();
     }
     values() {
         const ret = [];
-        for (const store of this.registry.values()) {
+        for (const store of this.#registry.values()) {
             ret.push(...store.values());
         }
         return ret;
     }
     *[Symbol.iterator]() {
-        for (const store of this.registry.values()) {
+        for (const store of this.#registry.values()) {
             for (const item of store.values()) {
                 yield item;
             }
@@ -42,7 +69,7 @@ export class IdentityMap {
     }
     keys() {
         const ret = [];
-        for (const [cls, store] of this.registry) {
+        for (const [cls, store] of this.#registry) {
             ret.push(...[...store.keys()].map(hash => `${cls.name}-${hash}`));
         }
         return ret;
@@ -52,18 +79,29 @@ export class IdentityMap {
      */
     get(hash) {
         const [name, id] = hash.split('-', 2);
-        const cls = [...this.registry.keys()].find(k => k.name === name);
+        const cls = [...this.#registry.keys()].find(k => k.name === name);
         if (!cls) {
             return undefined;
         }
-        const store = this.registry.get(cls);
+        const store = this.#registry.get(cls);
         return store.has(id) ? store.get(id) : undefined;
     }
     getPkHash(item) {
         const wrapped = item.__helper;
         const meta = wrapped.__meta;
         const hash = wrapped.getSerializedPrimaryKey();
-        const schema = wrapped.__schema ?? meta.root.schema ?? this.defaultSchema;
+        const schema = wrapped.__schema ?? meta.root.schema ?? this.#defaultSchema;
+        if (schema) {
+            return schema + ':' + hash;
+        }
+        return hash;
+    }
+    /**
+     * Creates a hash for an alternate key lookup.
+     * Format: `[key]value` or `schema:[key]value`
+     */
+    getKeyHash(key, value, schema) {
+        const hash = `[${key}]${value}`;
         if (schema) {
             return schema + ':' + hash;
         }

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

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings.js';
+import type { AnyEntity, EntityData, EntityMetadata, EntityName, EntityProperty, FilterQuery, Primary } from '../typings.js';
 import { Collection } from '../entity/Collection.js';
 import { Reference } from '../entity/Reference.js';
 import { ChangeSet, ChangeSetType } from './ChangeSet.js';
@@ -7,27 +7,15 @@ import type { EntityManager } from '../EntityManager.js';
 import { IdentityMap } from './IdentityMap.js';
 import type { LockOptions } from '../drivers/IDatabaseDriver.js';
 export declare class UnitOfWork {
-    private readonly em;
-    /** map of references to managed entities */
-    private readonly identityMap;
-    private readonly persistStack;
-    private readonly removeStack;
-    private readonly orphanRemoveStack;
-    private readonly changeSets;
-    private readonly collectionUpdates;
-    private readonly extraUpdates;
-    private readonly metadata;
-    private readonly platform;
-    private readonly eventManager;
-    private readonly comparator;
-    private readonly changeSetComputer;
-    private readonly changeSetPersister;
-    private readonly queuedActions;
-    private readonly loadedEntities;
-    private readonly flushQueue;
-    private working;
+    #private;
     constructor(em: EntityManager);
     merge<T extends object>(entity: T, visited?: Set<AnyEntity>): void;
+    /**
+     * Entity data can wary in its shape, e.g. we might get a deep relation graph with joined strategy, but for diffing,
+     * we need to normalize the shape, so relation values are only raw FKs. This method handles that.
+     * @internal
+     */
+    normalizeEntityData<T extends object>(meta: EntityMetadata<T>, data: EntityData<T>): void;
     /**
      * @internal
      */
@@ -36,11 +24,28 @@ export declare class UnitOfWork {
      * @internal
      */
     dispatchOnLoadEvent(): Promise<void>;
+    /**
+     * @internal
+     */
+    unmarkAsLoaded(entity: AnyEntity): void;
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
-    tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
+    getById<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
+    /**
+     * Returns entity from the identity map by an alternate key (non-PK property).
+     * @param convertCustomTypes - If true, the value is in database format and will be converted to JS format for lookup.
+     *                             If false (default), the value is assumed to be in JS format already.
+     */
+    getByKey<T extends object>(entityName: EntityName<T>, key: string, value: unknown, schema?: string, convertCustomTypes?: boolean): T | undefined;
+    /**
+     * Stores an entity in the identity map under an alternate key (non-PK property).
+     * Also sets the property value on the entity.
+     * @param convertCustomTypes - If true, the value is in database format and will be converted to JS format.
+     *                             If false (default), the value is assumed to be in JS format already.
+     */
+    storeByKey<T extends object>(entity: T, key: string, value: unknown, schema?: string, convertCustomTypes?: boolean): void;
+    tryGetById<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.
      */
@@ -53,7 +58,13 @@ export declare class UnitOfWork {
     getRemoveStack(): Set<AnyEntity>;
     getChangeSets(): ChangeSet<AnyEntity>[];
     getCollectionUpdates(): Collection<AnyEntity>[];
-    getExtraUpdates(): Set<[AnyEntity, string | string[], (AnyEntity | AnyEntity[] | Reference<any> | Collection<any>), ChangeSet<any> | undefined, ChangeSetType]>;
+    getExtraUpdates(): Set<[
+        AnyEntity,
+        string | string[],
+        AnyEntity | AnyEntity[] | Reference<any> | Collection<any>,
+        ChangeSet<any> | undefined,
+        ChangeSetType
+    ]>;
     shouldAutoFlush<T extends object>(meta: EntityMetadata<T>): boolean;
     clearActionsQueue(): void;
     computeChangeSet<T extends object>(entity: T, type?: ChangeSetType): void;
@@ -77,6 +88,11 @@ export declare class UnitOfWork {
     getOrphanRemoveStack(): Set<AnyEntity>;
     getChangeSetPersister(): ChangeSetPersister;
     private findNewEntities;
+    /**
+     * For TPT inheritance, creates separate changesets for each table in the hierarchy.
+     * Uses the same entity instance for all changesets - only the metadata and payload differ.
+     */
+    private createTPTChangeSets;
     /**
      * Returns `true` when the change set should be skipped as it will be empty after the extra update.
      */