@mikro-orm/core 7.0.0-rc.2 → 7.0.0

package/unit-of-work/IdentityMap.js

@@ -1,11 +1,11 @@
 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();
-    /** Tracks alternate key hashes for each entity so we can clean them up on delete */
-    alternateKeys = new WeakMap();
     store(item) {
         this.getStore(item.__meta.root).set(this.getPkHash(item), item);
     }
@@ -17,10 +17,10 @@ export class IdentityMap {
         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);
+        let keys = this.#alternateKeys.get(item);
         if (!keys) {
             keys = new Set();
-            this.alternateKeys.set(item, keys);
+            this.#alternateKeys.set(item, keys);
         }
         keys.add(hash);
     }
@@ -29,12 +29,12 @@ export class IdentityMap {
         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);
+        const altKeys = this.#alternateKeys.get(item);
         if (altKeys) {
             for (const hash of altKeys) {
                 store.delete(hash);
             }
-            this.alternateKeys.delete(item);
+            this.#alternateKeys.delete(item);
         }
     }
     getByHash(meta, hash) {
@@ -42,26 +42,26 @@ export class IdentityMap {
         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;
             }
@@ -69,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;
@@ -79,18 +79,18 @@ 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;
         }

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

@@ -7,25 +7,7 @@ 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;
     /**
@@ -42,6 +24,10 @@ 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`.
      */
@@ -72,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;