@mikro-orm/core 7.0.0-dev.321 → 7.0.0-dev.322

package/unit-of-work/CommitOrderCalculator.js

@@ -17,26 +17,26 @@ export var NodeState;
  */
 export class CommitOrderCalculator {
     /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
-    nodes = new Map();
+    #nodes = new Map();
     /** Volatile variable holding calculated nodes during sorting process. */
-    sortedNodeList = [];
+    #sortedNodeList = [];
     /**
      * Checks for node existence in graph.
      */
     hasNode(hash) {
-        return this.nodes.has(hash);
+        return this.#nodes.has(hash);
     }
     /**
      * Adds a new node to the graph, assigning its hash.
      */
     addNode(hash) {
-        this.nodes.set(hash, { hash, state: 0 /* NodeState.NOT_VISITED */, dependencies: new Map() });
+        this.#nodes.set(hash, { hash, state: 0 /* NodeState.NOT_VISITED */, dependencies: new Map() });
     }
     /**
      * Adds a new dependency (edge) to the graph using their hashes.
      */
     addDependency(from, to, weight) {
-        this.nodes.get(from).dependencies.set(to, { from, to, weight });
+        this.#nodes.get(from).dependencies.set(to, { from, to, weight });
     }
     discoverProperty(prop, entityName) {
         const toOneOwner = (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
@@ -57,15 +57,15 @@ export class CommitOrderCalculator {
      * @internal Highly performance-sensitive method.
      */
     sort() {
-        for (const vertex of this.nodes.values()) {
+        for (const vertex of this.#nodes.values()) {
             if (vertex.state !== 0 /* NodeState.NOT_VISITED */) {
                 continue;
             }
             this.visit(vertex);
         }
-        const sortedList = this.sortedNodeList.reverse();
-        this.nodes = new Map();
-        this.sortedNodeList = [];
+        const sortedList = this.#sortedNodeList.reverse();
+        this.#nodes = new Map();
+        this.#sortedNodeList = [];
         return sortedList;
     }
     /**
@@ -76,7 +76,7 @@ export class CommitOrderCalculator {
     visit(node) {
         node.state = 1 /* NodeState.IN_PROGRESS */;
         for (const edge of node.dependencies.values()) {
-            const target = this.nodes.get(edge.to);
+            const target = this.#nodes.get(edge.to);
             switch (target.state) {
                 case 2 /* NodeState.VISITED */:
                     break; // Do nothing, since node was already visited
@@ -89,7 +89,7 @@ export class CommitOrderCalculator {
         }
         if (node.state !== 2 /* NodeState.VISITED */) {
             node.state = 2 /* NodeState.VISITED */;
-            this.sortedNodeList.push(node.hash);
+            this.#sortedNodeList.push(node.hash);
         }
     }
     /**
@@ -100,12 +100,12 @@ export class CommitOrderCalculator {
             return;
         }
         for (const edge of target.dependencies.values()) {
-            const targetNode = this.nodes.get(edge.to);
+            const targetNode = this.#nodes.get(edge.to);
             if (targetNode.state === 0 /* NodeState.NOT_VISITED */) {
                 this.visit(targetNode);
             }
         }
         target.state = 2 /* NodeState.VISITED */;
-        this.sortedNodeList.push(target.hash);
+        this.#sortedNodeList.push(target.hash);
     }
 }

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

@@ -1,10 +1,7 @@
 import type { AnyEntity, EntityMetadata } from '../typings.js';
 export declare class IdentityMap {
-    private readonly defaultSchema?;
-    constructor(defaultSchema?: string | undefined);
-    private readonly registry;
-    /** Tracks alternate key hashes for each entity so we can clean them up on delete */
-    private readonly alternateKeys;
+    #private;
+    constructor(defaultSchema?: string);
     store<T>(item: T): void;
     /**
      * Stores an entity under an alternate key (non-PK property).

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`.
      */