@mikro-orm/core/utils/EntityComparator.d.ts

TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.

import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
import type { Platform } from '../platforms/Platform.js';
import type { Configuration } from './Configuration.js';
type Comparator<T> = (a: T, b: T, options?: {
    includeInverseSides?: boolean;
}) => EntityData<T>;
type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
type PkGetter<T> = (entity: T) => Primary<T>;
type PkSerializer<T> = (entity: T) => string;
type CompositeKeyPart = string | CompositeKeyPart[];
/** @internal Generates and caches JIT-compiled functions for comparing, snapshotting, and mapping entity data. */
export declare class EntityComparator {
    #private;
    constructor(metadata: IMetadataStorage, platform: Platform, config?: Configuration);
    /**
     * Computes difference between two entities.
     */
    diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
        includeInverseSides?: boolean;
    }): EntityData<T>;
    /** Returns true if two entity snapshots are identical (no differences). */
    matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
    /**
     * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
     * References will be mapped to primary keys, collections to arrays of primary keys.
     */
    prepareEntity<T extends object>(entity: T): EntityData<T>;
    /**
     * Maps database columns to properties.
     */
    mapResult<T>(meta: EntityMetadata<T>, result: EntityDictionary<T>): EntityData<T>;
    /**
     * @internal Highly performance-sensitive method.
     */
    getPkGetter<T>(meta: EntityMetadata<T>): PkGetter<T>;
    /**
     * @internal Highly performance-sensitive method.
     */
    getPkGetterConverted<T>(meta: EntityMetadata<T>): PkGetter<T>;
    /**
     * @internal Highly performance-sensitive method.
     */
    getPkSerializer<T>(meta: EntityMetadata<T>): PkSerializer<T>;
    /**
     * @internal Highly performance-sensitive method.
     */
    getSnapshotGenerator<T>(entityName: EntityName<T>): SnapshotGenerator<T>;
    /**
     * @internal
     */
    propName(name: string, parent?: string): string;
    /**
     * @internal respects nested composite keys, e.g. `[1, [2, 3]]`
     */
    createCompositeKeyArray(prop: EntityProperty, parents?: EntityProperty[]): string;
    /**
     * @internal
     */
    formatCompositeKeyPart(part: CompositeKeyPart): string;
    /**
     * @internal Highly performance-sensitive method.
     */
    getResultMapper<T>(meta: EntityMetadata<T>): ResultMapper<T>;
    private getPropertyCondition;
    private getEmbeddedArrayPropertySnapshot;
    /**
     * we need to serialize only object embeddables, and only the top level ones, so root object embeddable
     * properties and first child nested object embeddables with inlined parent
     */
    private shouldSerialize;
    private getEmbeddedPropertySnapshot;
    private getInlineEmbeddedNullLines;
    private registerCustomType;
    private getPropertySnapshot;
    /**
     * @internal Highly performance-sensitive method.
     */
    getEntityComparator<T extends object>(entityName: EntityName<T>): Comparator<T>;
    private getGenericComparator;
    private getPropertyComparator;
    private wrap;
    private safeKey;
    /**
     * Sets the toArray helper in the context if not already set.
     * Used for converting composite PKs to arrays.
     */
    private setToArrayHelper;
    /**
     * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
     */
    static isComparable<T>(prop: EntityProperty<T>, root: EntityMetadata): boolean;
}
export {};