@mikro-orm/core 7.0.8 → 7.0.9-dev.0

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

@@ -1,12 +1,4 @@
-import type {
-  AnyEntity,
-  EntityData,
-  EntityMetadata,
-  EntityName,
-  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';
@@ -16,178 +8,146 @@ import { IdentityMap } from './IdentityMap.js';
 import type { LockOptions } from '../drivers/IDatabaseDriver.js';
 /** Implements the Unit of Work pattern: tracks entity changes, computes change sets, and flushes them to the database. */
 export declare class UnitOfWork {
-  #private;
-  constructor(em: EntityManager);
-  /** Merges an entity into the identity map, taking a snapshot of its current state. */
-  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
-   */
-  register<T extends object>(entity: T, data?: EntityData<T>, options?: RegisterOptions): T;
-  /**
-   * @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: 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;
-  /** Attempts to extract a primary key from the where condition and look up the entity in the identity map. */
-  tryGetById<T extends object>(
-    entityName: EntityName<T>,
-    where: FilterQuery<T>,
-    schema?: string,
-    strict?: boolean,
-  ): T | null;
-  /**
-   * Returns map of all managed entities.
-   */
-  getIdentityMap(): IdentityMap;
-  /**
-   * Returns stored snapshot of entity state that is used for change set computation.
-   */
-  getOriginalEntityData<T extends object>(entity: T): EntityData<T> | undefined;
-  /** Returns the set of entities scheduled for persistence. */
-  getPersistStack(): Set<AnyEntity>;
-  /** Returns the set of entities scheduled for removal. */
-  getRemoveStack(): Set<AnyEntity>;
-  /** Returns all computed change sets for the current flush. */
-  getChangeSets(): ChangeSet<AnyEntity>[];
-  /** Returns all M:N collections that need synchronization. */
-  getCollectionUpdates(): Collection<AnyEntity>[];
-  /** Returns extra updates needed for relations that could not be resolved in the initial pass. */
-  getExtraUpdates(): Set<
-    [
-      AnyEntity,
-      string | string[],
-      AnyEntity | AnyEntity[] | Reference<any> | Collection<any>,
-      ChangeSet<any> | undefined,
-      ChangeSetType,
-    ]
-  >;
-  /** Checks whether an auto-flush is needed before querying the given entity type. */
-  shouldAutoFlush<T extends object>(meta: EntityMetadata<T>): boolean;
-  /** Clears the queue of entity types that triggered auto-flush detection. */
-  clearActionsQueue(): void;
-  /** Computes and registers a change set for the given entity. */
-  computeChangeSet<T extends object>(entity: T, type?: ChangeSetType): void;
-  /** Recomputes and merges the change set for an already-tracked entity. */
-  recomputeSingleChangeSet<T extends object>(entity: T): void;
-  /** Marks an entity for persistence, cascading to related entities. */
-  persist<T extends object>(
-    entity: T,
-    visited?: Set<AnyEntity>,
-    options?: {
-      checkRemoveStack?: boolean;
-      cascade?: boolean;
-    },
-  ): void;
-  /** Marks an entity for removal, cascading to related entities. */
-  remove<T extends object>(
-    entity: T,
-    visited?: Set<AnyEntity>,
-    options?: {
-      cascade?: boolean;
-    },
-  ): void;
-  /** Flushes all pending changes to the database within a transaction. */
-  commit(): Promise<void>;
-  private doCommit;
-  lock<T extends object>(entity: T, options: LockOptions): Promise<void>;
-  clear(): void;
-  unsetIdentity(entity: AnyEntity): void;
-  computeChangeSets(): void;
-  scheduleExtraUpdate<T extends object>(changeSet: ChangeSet<T>, props: EntityProperty<T>[]): void;
-  scheduleOrphanRemoval(entity?: AnyEntity, visited?: Set<AnyEntity>): void;
-  cancelOrphanRemoval(entity: AnyEntity, visited?: Set<AnyEntity>): void;
-  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.
-   */
-  private checkUniqueProps;
-  private expandUniqueProps;
-  private initIdentifier;
-  private processReference;
-  private processToOneReference;
-  private processToManyReference;
-  private runHooks;
-  private postCommitCleanup;
-  private cascade;
-  private cascadeReference;
-  private isCollectionSelfReferenced;
-  private shouldCascade;
-  private lockPessimistic;
-  private lockOptimistic;
-  private fixMissingReference;
-  private persistToDatabase;
-  private commitCreateChangeSets;
-  private findExtraUpdates;
-  private findEarlyUpdates;
-  private commitUpdateChangeSets;
-  private commitDeleteChangeSets;
-  private commitExtraUpdates;
-  private commitCollectionUpdates;
-  private filterCollectionUpdates;
-  /**
-   * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
-   */
-  private getChangeSetGroups;
-  private getCommitOrder;
-  private resetTransaction;
-  /**
-   * Takes snapshots of all processed collections
-   */
-  private takeCollectionSnapshots;
+    #private;
+    constructor(em: EntityManager);
+    /** Merges an entity into the identity map, taking a snapshot of its current state. */
+    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
+     */
+    register<T extends object>(entity: T, data?: EntityData<T>, options?: RegisterOptions): T;
+    /**
+     * @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: 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;
+    /** Attempts to extract a primary key from the where condition and look up the entity in the identity map. */
+    tryGetById<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
+    /**
+     * Returns map of all managed entities.
+     */
+    getIdentityMap(): IdentityMap;
+    /**
+     * Returns stored snapshot of entity state that is used for change set computation.
+     */
+    getOriginalEntityData<T extends object>(entity: T): EntityData<T> | undefined;
+    /** Returns the set of entities scheduled for persistence. */
+    getPersistStack(): Set<AnyEntity>;
+    /** Returns the set of entities scheduled for removal. */
+    getRemoveStack(): Set<AnyEntity>;
+    /** Returns all computed change sets for the current flush. */
+    getChangeSets(): ChangeSet<AnyEntity>[];
+    /** Returns all M:N collections that need synchronization. */
+    getCollectionUpdates(): Collection<AnyEntity>[];
+    /** Returns extra updates needed for relations that could not be resolved in the initial pass. */
+    getExtraUpdates(): Set<[
+        AnyEntity,
+        string | string[],
+        AnyEntity | AnyEntity[] | Reference<any> | Collection<any>,
+        ChangeSet<any> | undefined,
+        ChangeSetType
+    ]>;
+    /** Checks whether an auto-flush is needed before querying the given entity type. */
+    shouldAutoFlush<T extends object>(meta: EntityMetadata<T>): boolean;
+    /** Clears the queue of entity types that triggered auto-flush detection. */
+    clearActionsQueue(): void;
+    /** Computes and registers a change set for the given entity. */
+    computeChangeSet<T extends object>(entity: T, type?: ChangeSetType): void;
+    /** Recomputes and merges the change set for an already-tracked entity. */
+    recomputeSingleChangeSet<T extends object>(entity: T): void;
+    /** Marks an entity for persistence, cascading to related entities. */
+    persist<T extends object>(entity: T, visited?: Set<AnyEntity>, options?: {
+        checkRemoveStack?: boolean;
+        cascade?: boolean;
+    }): void;
+    /** Marks an entity for removal, cascading to related entities. */
+    remove<T extends object>(entity: T, visited?: Set<AnyEntity>, options?: {
+        cascade?: boolean;
+    }): void;
+    /** Flushes all pending changes to the database within a transaction. */
+    commit(): Promise<void>;
+    private doCommit;
+    lock<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    clear(): void;
+    unsetIdentity(entity: AnyEntity): void;
+    computeChangeSets(): void;
+    scheduleExtraUpdate<T extends object>(changeSet: ChangeSet<T>, props: EntityProperty<T>[]): void;
+    scheduleOrphanRemoval(entity?: AnyEntity, visited?: Set<AnyEntity>): void;
+    cancelOrphanRemoval(entity: AnyEntity, visited?: Set<AnyEntity>): void;
+    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.
+     */
+    private checkUniqueProps;
+    private expandUniqueProps;
+    private initIdentifier;
+    private processReference;
+    private processToOneReference;
+    private processToManyReference;
+    private runHooks;
+    private postCommitCleanup;
+    private cascade;
+    private cascadeReference;
+    private isCollectionSelfReferenced;
+    private shouldCascade;
+    private lockPessimistic;
+    private lockOptimistic;
+    private fixMissingReference;
+    private persistToDatabase;
+    private commitCreateChangeSets;
+    private findExtraUpdates;
+    private findEarlyUpdates;
+    private commitUpdateChangeSets;
+    private commitDeleteChangeSets;
+    private commitExtraUpdates;
+    private commitCollectionUpdates;
+    private filterCollectionUpdates;
+    /**
+     * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
+     */
+    private getChangeSetGroups;
+    private getCommitOrder;
+    private resetTransaction;
+    /**
+     * Takes snapshots of all processed collections
+     */
+    private takeCollectionSnapshots;
 }
 export interface RegisterOptions {
-  refresh?: boolean;
-  newEntity?: boolean;
-  loaded?: boolean;
+    refresh?: boolean;
+    newEntity?: boolean;
+    loaded?: boolean;
 }