@mikro-orm/core 7.0.2 → 7.0.3-dev.1

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,97 +16,96 @@ 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);
-  }
-  /**
-   * 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;
+    /** 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);
     }
-    const propertyType = prop.targetMeta?.root._id;
-    if (propertyType == null || !this.hasNode(propertyType)) {
-      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() });
     }
-    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);
+    /**
+     * 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 });
     }
-    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);
-      }
+    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);
     }
-    if (node.state !== 2 /* NodeState.VISITED */) {
-      node.state = 2 /* NodeState.VISITED */;
-      this.#sortedNodeList.push(node.hash);
+    /**
+     * 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;
     }
-  }
-  /**
-   * 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;
+    /**
+     * 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);
+        }
     }
-    for (const edge of target.dependencies.values()) {
-      const targetNode = this.#nodes.get(edge.to);
-      if (targetNode.state === 0 /* NodeState.NOT_VISITED */) {
-        this.visit(targetNode);
-      }
+    /**
+     * 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);
     }
-    target.state = 2 /* NodeState.VISITED */;
-    this.#sortedNodeList.push(target.hash);
-  }
 }

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

@@ -1,35 +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);
-  /** 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;
+    #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,117 +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;
-  }
-  /** 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);
+    #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;
     }
-    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 in the identity map under its primary key hash. */
+    store(item) {
+        this.getStore(item.__meta.root).set(this.getPkHash(item), item);
     }
-  }
-  /** 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;
+    /**
+     * 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);
     }
-    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());
+    /** 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);
+        }
     }
-    return ret;
-  }
-  *[Symbol.iterator]() {
-    for (const store of this.#registry.values()) {
-      for (const item of store.values()) {
-        yield item;
-      }
+    /** 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 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}`));
+    /** 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;
+        }
+        const newStore = new Map();
+        this.#registry.set(meta.class, newStore);
+        return newStore;
     }
-    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;
+    clear() {
+        this.#registry.clear();
     }
-    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;
+    /** Returns all entities currently in the identity map. */
+    values() {
+        const ret = [];
+        for (const store of this.#registry.values()) {
+            ret.push(...store.values());
+        }
+        return ret;
     }
-    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;
+    *[Symbol.iterator]() {
+        for (const store of this.#registry.values()) {
+            for (const item of store.values()) {
+                yield item;
+            }
+        }
+    }
+    /** 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}`));
+        }
+        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;
-  }
 }