@mikro-orm/core 7.0.2-dev.9 → 7.0.2

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

@@ -1,19 +1,19 @@
 import type { EntityProperty } from '../typings.js';
 export declare const enum NodeState {
-    NOT_VISITED = 0,
-    IN_PROGRESS = 1,
-    VISITED = 2
+  NOT_VISITED = 0,
+  IN_PROGRESS = 1,
+  VISITED = 2,
 }
 type Hash = number;
 export interface Node {
-    hash: Hash;
-    state: NodeState;
-    dependencies: Map<Hash, Edge>;
+  hash: Hash;
+  state: NodeState;
+  dependencies: Map<Hash, Edge>;
 }
 export interface Edge {
-    from: Hash;
-    to: Hash;
-    weight: number;
+  from: Hash;
+  to: Hash;
+  weight: number;
 }
 /**
  * CommitOrderCalculator implements topological sorting, which is an ordering
@@ -26,36 +26,36 @@ export interface Edge {
  * @internal
  */
 export declare class CommitOrderCalculator {
-    #private;
-    /**
-     * Checks for node existence in graph.
-     */
-    hasNode(hash: Hash): boolean;
-    /**
-     * Adds a new node to the graph, assigning its hash.
-     */
-    addNode(hash: Hash): void;
-    /**
-     * Adds a new dependency (edge) to the graph using their hashes.
-     */
-    addDependency(from: Hash, to: Hash, weight: number): void;
-    discoverProperty(prop: EntityProperty, entityName: Hash): void;
-    /**
-     * Return a valid order list of all current nodes.
-     * The desired topological sorting is the reverse post order of these searches.
-     *
-     * @internal Highly performance-sensitive method.
-     */
-    sort(): Hash[];
-    /**
-     * Visit a given node definition for reordering.
-     *
-     * @internal Highly performance-sensitive method.
-     */
-    private visit;
-    /**
-     * Visits all target's dependencies if in cycle with given node
-     */
-    private visitOpenNode;
+  #private;
+  /**
+   * Checks for node existence in graph.
+   */
+  hasNode(hash: Hash): boolean;
+  /**
+   * Adds a new node to the graph, assigning its hash.
+   */
+  addNode(hash: Hash): void;
+  /**
+   * Adds a new dependency (edge) to the graph using their hashes.
+   */
+  addDependency(from: Hash, to: Hash, weight: number): void;
+  discoverProperty(prop: EntityProperty, entityName: Hash): void;
+  /**
+   * Return a valid order list of all current nodes.
+   * The desired topological sorting is the reverse post order of these searches.
+   *
+   * @internal Highly performance-sensitive method.
+   */
+  sort(): Hash[];
+  /**
+   * Visit a given node definition for reordering.
+   *
+   * @internal Highly performance-sensitive method.
+   */
+  private visit;
+  /**
+   * Visits all target's dependencies if in cycle with given node
+   */
+  private visitOpenNode;
 }
 export {};

package/unit-of-work/CommitOrderCalculator.js

@@ -1,9 +1,9 @@
 import { ReferenceKind } from '../enums.js';
 export var NodeState;
 (function (NodeState) {
-    NodeState[NodeState["NOT_VISITED"] = 0] = "NOT_VISITED";
-    NodeState[NodeState["IN_PROGRESS"] = 1] = "IN_PROGRESS";
-    NodeState[NodeState["VISITED"] = 2] = "VISITED";
+  NodeState[(NodeState['NOT_VISITED'] = 0)] = 'NOT_VISITED';
+  NodeState[(NodeState['IN_PROGRESS'] = 1)] = 'IN_PROGRESS';
+  NodeState[(NodeState['VISITED'] = 2)] = 'VISITED';
 })(NodeState || (NodeState = {}));
 /**
  * CommitOrderCalculator implements topological sorting, which is an ordering
@@ -16,96 +16,97 @@ export var NodeState;
  * @internal
  */
 export class CommitOrderCalculator {
-    /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
-    #nodes = new Map();
-    /** Volatile variable holding calculated nodes during sorting process. */
-    #sortedNodeList = [];
-    /**
-     * Checks for node existence in graph.
-     */
-    hasNode(hash) {
-        return this.#nodes.has(hash);
+  /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
+  #nodes = new Map();
+  /** Volatile variable holding calculated nodes during sorting process. */
+  #sortedNodeList = [];
+  /**
+   * Checks for node existence in graph.
+   */
+  hasNode(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() });
+  }
+  /**
+   * 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 });
+  }
+  discoverProperty(prop, entityName) {
+    const toOneOwner =
+      (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
+    const toManyOwner = prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
+    if (!toOneOwner && !toManyOwner) {
+      return;
     }
-    /**
-     * 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() });
+    const propertyType = prop.targetMeta?.root._id;
+    if (propertyType == null || !this.hasNode(propertyType)) {
+      return;
     }
-    /**
-     * 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.addDependency(propertyType, entityName, prop.nullable || prop.persist === false ? 0 : 1);
+  }
+  /**
+   * Return a valid order list of all current nodes.
+   * The desired topological sorting is the reverse post order of these searches.
+   *
+   * @internal Highly performance-sensitive method.
+   */
+  sort() {
+    for (const vertex of this.#nodes.values()) {
+      if (vertex.state !== 0 /* NodeState.NOT_VISITED */) {
+        continue;
+      }
+      this.visit(vertex);
     }
-    discoverProperty(prop, entityName) {
-        const toOneOwner = (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
-        const toManyOwner = prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
-        if (!toOneOwner && !toManyOwner) {
-            return;
-        }
-        const propertyType = prop.targetMeta?.root._id;
-        if (propertyType == null || !this.hasNode(propertyType)) {
-            return;
-        }
-        this.addDependency(propertyType, entityName, prop.nullable || prop.persist === false ? 0 : 1);
+    const sortedList = this.#sortedNodeList.reverse();
+    this.#nodes = new Map();
+    this.#sortedNodeList = [];
+    return sortedList;
+  }
+  /**
+   * Visit a given node definition for reordering.
+   *
+   * @internal Highly performance-sensitive method.
+   */
+  visit(node) {
+    node.state = 1 /* NodeState.IN_PROGRESS */;
+    for (const edge of node.dependencies.values()) {
+      const target = this.#nodes.get(edge.to);
+      switch (target.state) {
+        case 2 /* NodeState.VISITED */:
+          break; // Do nothing, since node was already visited
+        case 1 /* NodeState.IN_PROGRESS */:
+          this.visitOpenNode(node, target, edge);
+          break;
+        case 0 /* NodeState.NOT_VISITED */:
+          this.visit(target);
+      }
     }
-    /**
-     * Return a valid order list of all current nodes.
-     * The desired topological sorting is the reverse post order of these searches.
-     *
-     * @internal Highly performance-sensitive method.
-     */
-    sort() {
-        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 = [];
-        return sortedList;
+    if (node.state !== 2 /* NodeState.VISITED */) {
+      node.state = 2 /* NodeState.VISITED */;
+      this.#sortedNodeList.push(node.hash);
     }
-    /**
-     * Visit a given node definition for reordering.
-     *
-     * @internal Highly performance-sensitive method.
-     */
-    visit(node) {
-        node.state = 1 /* NodeState.IN_PROGRESS */;
-        for (const edge of node.dependencies.values()) {
-            const target = this.#nodes.get(edge.to);
-            switch (target.state) {
-                case 2 /* NodeState.VISITED */:
-                    break; // Do nothing, since node was already visited
-                case 1 /* NodeState.IN_PROGRESS */:
-                    this.visitOpenNode(node, target, edge);
-                    break;
-                case 0 /* NodeState.NOT_VISITED */:
-                    this.visit(target);
-            }
-        }
-        if (node.state !== 2 /* NodeState.VISITED */) {
-            node.state = 2 /* NodeState.VISITED */;
-            this.#sortedNodeList.push(node.hash);
-        }
+  }
+  /**
+   * Visits all target's dependencies if in cycle with given node
+   */
+  visitOpenNode(node, target, edge) {
+    if (!target.dependencies.has(node.hash) || target.dependencies.get(node.hash).weight >= edge.weight) {
+      return;
     }
-    /**
-     * Visits all target's dependencies if in cycle with given node
-     */
-    visitOpenNode(node, target, edge) {
-        if (!target.dependencies.has(node.hash) || target.dependencies.get(node.hash).weight >= edge.weight) {
-            return;
-        }
-        for (const edge of target.dependencies.values()) {
-            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);
+    for (const edge of target.dependencies.values()) {
+      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);
+  }
 }

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

@@ -1,28 +1,35 @@
 import type { AnyEntity, EntityMetadata } from '../typings.js';
+/** @internal Stores managed entity instances keyed by their primary key hash, ensuring each row is loaded once. */
 export declare class IdentityMap {
-    #private;
-    constructor(defaultSchema?: string);
-    store<T>(item: T): void;
-    /**
-     * 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<T>(item: T, key: string, value: string, schema?: string): void;
-    delete<T>(item: T): void;
-    getByHash<T>(meta: EntityMetadata<T>, hash: string): T | undefined;
-    getStore<T>(meta: EntityMetadata<T>): Map<string, T>;
-    clear(): void;
-    values(): AnyEntity[];
-    [Symbol.iterator](): IterableIterator<AnyEntity>;
-    keys(): string[];
-    /**
-     * For back compatibility only.
-     */
-    get<T>(hash: string): T | undefined;
-    private getPkHash;
-    /**
-     * Creates a hash for an alternate key lookup.
-     * Format: `[key]value` or `schema:[key]value`
-     */
-    getKeyHash(key: string, value: string, schema?: string): string;
+  #private;
+  constructor(defaultSchema?: string);
+  /** Stores an entity in the identity map under its primary key hash. */
+  store<T>(item: T): void;
+  /**
+   * 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<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 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. */
+  getStore<T>(meta: EntityMetadata<T>): Map<string, T>;
+  clear(): void;
+  /** Returns all entities currently in the identity map. */
+  values(): AnyEntity[];
+  [Symbol.iterator](): IterableIterator<AnyEntity>;
+  /** Returns all hash keys currently in the identity map. */
+  keys(): string[];
+  /**
+   * For back compatibility only.
+   */
+  get<T>(hash: string): T | undefined;
+  private getPkHash;
+  /**
+   * Creates a hash for an alternate key lookup.
+   * Format: `[key]value` or `schema:[key]value`
+   */
+  getKeyHash(key: string, value: string, schema?: string): string;
 }

package/unit-of-work/IdentityMap.js

@@ -1,110 +1,117 @@
+/** @internal Stores managed entity instances keyed by their primary key hash, ensuring each row is loaded once. */
 export class IdentityMap {
-    #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;
+  #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;
+  }
+  /** Stores an entity in the identity map under its primary key hash. */
+  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);
     }
-    store(item) {
-        this.getStore(item.__meta.root).set(this.getPkHash(item), item);
+    keys.add(hash);
+  }
+  /** Removes an entity and its alternate key entries from the identity map. */
+  delete(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);
     }
-    /**
-     * 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);
+  }
+  /** Retrieves an entity by its hash key from the identity map. */
+  getByHash(meta, hash) {
+    const store = this.getStore(meta);
+    return store.has(hash) ? store.get(hash) : undefined;
+  }
+  /** Returns (or creates) the per-entity-class store within the identity map. */
+  getStore(meta) {
+    const store = this.#registry.get(meta.class);
+    if (store) {
+      return store;
     }
-    delete(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);
-        }
+    const newStore = new Map();
+    this.#registry.set(meta.class, newStore);
+    return newStore;
+  }
+  clear() {
+    this.#registry.clear();
+  }
+  /** Returns all entities currently in the identity map. */
+  values() {
+    const ret = [];
+    for (const store of this.#registry.values()) {
+      ret.push(...store.values());
     }
-    getByHash(meta, hash) {
-        const store = this.getStore(meta);
-        return store.has(hash) ? store.get(hash) : undefined;
+    return ret;
+  }
+  *[Symbol.iterator]() {
+    for (const store of this.#registry.values()) {
+      for (const item of store.values()) {
+        yield item;
+      }
     }
-    getStore(meta) {
-        const store = this.#registry.get(meta.class);
-        if (store) {
-            return store;
-        }
-        const newStore = new Map();
-        this.#registry.set(meta.class, newStore);
-        return newStore;
+  }
+  /** Returns all hash keys currently in the identity map. */
+  keys() {
+    const ret = [];
+    for (const [cls, store] of this.#registry) {
+      ret.push(...[...store.keys()].map(hash => `${cls.name}-${hash}`));
     }
-    clear() {
-        this.#registry.clear();
+    return ret;
+  }
+  /**
+   * For back compatibility only.
+   */
+  get(hash) {
+    const [name, id] = hash.split('-', 2);
+    const cls = [...this.#registry.keys()].find(k => k.name === name);
+    if (!cls) {
+      return undefined;
     }
-    values() {
-        const ret = [];
-        for (const store of this.#registry.values()) {
-            ret.push(...store.values());
-        }
-        return ret;
+    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;
+    if (schema) {
+      return schema + ':' + hash;
     }
-    *[Symbol.iterator]() {
-        for (const store of this.#registry.values()) {
-            for (const item of store.values()) {
-                yield item;
-            }
-        }
-    }
-    keys() {
-        const ret = [];
-        for (const [cls, store] of this.#registry) {
-            ret.push(...[...store.keys()].map(hash => `${cls.name}-${hash}`));
-        }
-        return ret;
-    }
-    /**
-     * For back compatibility only.
-     */
-    get(hash) {
-        const [name, id] = hash.split('-', 2);
-        const cls = [...this.#registry.keys()].find(k => k.name === name);
-        if (!cls) {
-            return undefined;
-        }
-        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;
-        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;
-        }
-        return 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;
     }
+    return hash;
+  }
 }