@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/utils/Cursor.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import type { EntityMetadata, FilterObject, Loaded } from '../typings';
+import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver';
+import { type QueryOrder } from '../enums';
+/**
+ * As an alternative to the offset-based pagination with `limit` and `offset`, we can paginate based on a cursor.
+ * A cursor is an opaque string that defines a specific place in ordered entity graph. You can use `em.findByCursor()`
+ * to access those options. Under the hood, it will call `em.find()` and `em.count()` just like the `em.findAndCount()`
+ * method, but will use the cursor options instead.
+ *
+ * Supports `before`, `after`, `first` and `last` options while disallowing `limit` and `offset`. Explicit `orderBy` option is required.
+ *
+ * Use `first` and `after` for forward pagination, or `last` and `before` for backward pagination.
+ *
+ * - `first` and `last` are numbers and serve as an alternative to `offset`, those options are mutually exclusive, use only one at a time
+ * - `before` and `after` specify the previous cursor value
+ *
+ * ```ts
+ * const currentCursor = await em.findByCursor(User, {}, {
+ *   first: 10,
+ *   after: previousCursor, // can be either string or `Cursor` instance
+ *   orderBy: { id: 'desc' },
+ * });
+ *
+ * // to fetch next page
+ * const nextCursor = await em.findByCursor(User, {}, {
+ *   first: 10,
+ *   after: currentCursor.endCursor, // or currentCursor.endCursor
+ *   orderBy: { id: 'desc' },
+ * });
+ * ```
+ *
+ * The `Cursor` object provides the following interface:
+ *
+ * ```ts
+ * Cursor<User> {
+ *   items: [
+ *     User { ... },
+ *     User { ... },
+ *     User { ... },
+ *     ...
+ *   ],
+ *   totalCount: 50,
+ *   length: 10,
+ *   startCursor: 'WzRd',
+ *   endCursor: 'WzZd',
+ *   hasPrevPage: true,
+ *   hasNextPage: true,
+ * }
+ * ```
+ */
+export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never> {
+    readonly items: Loaded<Entity, Hint, Fields, Excludes>[];
+    readonly totalCount: number;
+    readonly hasPrevPage: boolean;
+    readonly hasNextPage: boolean;
+    private readonly definition;
+    constructor(items: Loaded<Entity, Hint, Fields, Excludes>[], totalCount: number, options: FindByCursorOptions<Entity, Hint, Fields, Excludes>, meta: EntityMetadata<Entity>);
+    get startCursor(): string | null;
+    get endCursor(): string | null;
+    /**
+     * Computes the cursor value for a given entity.
+     */
+    from(entity: Entity | Loaded<Entity, Hint, Fields, Excludes>): string;
+    [Symbol.iterator](): IterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+    get length(): number;
+    /**
+     * Computes the cursor value for given entity and order definition.
+     */
+    static for<Entity extends object>(meta: EntityMetadata<Entity>, entity: FilterObject<Entity>, orderBy: OrderDefinition<Entity>): string;
+    static encode(value: unknown[]): string;
+    static decode(value: string): unknown[];
+    static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [never, QueryOrder][];
+    /** @ignore */
+    [inspect.custom](): string;
+}

package/utils/Cursor.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = void 0;
+const util_1 = require("util");
+const Utils_1 = require("./Utils");
+const enums_1 = require("../enums");
+const Reference_1 = require("../entity/Reference");
+const wrap_1 = require("../entity/wrap");
+const RawQueryFragment_1 = require("../utils/RawQueryFragment");
+const errors_1 = require("../errors");
+/**
+ * As an alternative to the offset-based pagination with `limit` and `offset`, we can paginate based on a cursor.
+ * A cursor is an opaque string that defines a specific place in ordered entity graph. You can use `em.findByCursor()`
+ * to access those options. Under the hood, it will call `em.find()` and `em.count()` just like the `em.findAndCount()`
+ * method, but will use the cursor options instead.
+ *
+ * Supports `before`, `after`, `first` and `last` options while disallowing `limit` and `offset`. Explicit `orderBy` option is required.
+ *
+ * Use `first` and `after` for forward pagination, or `last` and `before` for backward pagination.
+ *
+ * - `first` and `last` are numbers and serve as an alternative to `offset`, those options are mutually exclusive, use only one at a time
+ * - `before` and `after` specify the previous cursor value
+ *
+ * ```ts
+ * const currentCursor = await em.findByCursor(User, {}, {
+ *   first: 10,
+ *   after: previousCursor, // can be either string or `Cursor` instance
+ *   orderBy: { id: 'desc' },
+ * });
+ *
+ * // to fetch next page
+ * const nextCursor = await em.findByCursor(User, {}, {
+ *   first: 10,
+ *   after: currentCursor.endCursor, // or currentCursor.endCursor
+ *   orderBy: { id: 'desc' },
+ * });
+ * ```
+ *
+ * The `Cursor` object provides the following interface:
+ *
+ * ```ts
+ * Cursor<User> {
+ *   items: [
+ *     User { ... },
+ *     User { ... },
+ *     User { ... },
+ *     ...
+ *   ],
+ *   totalCount: 50,
+ *   length: 10,
+ *   startCursor: 'WzRd',
+ *   endCursor: 'WzZd',
+ *   hasPrevPage: true,
+ *   hasNextPage: true,
+ * }
+ * ```
+ */
+class Cursor {
+    items;
+    totalCount;
+    hasPrevPage;
+    hasNextPage;
+    definition;
+    constructor(items, totalCount, options, meta) {
+        this.items = items;
+        this.totalCount = totalCount;
+        const { first, last, before, after, orderBy, overfetch } = options;
+        const limit = first || last;
+        const isLast = !first && !!last;
+        const hasMorePages = !!overfetch && limit != null && items.length > limit;
+        this.hasPrevPage = before || after ? true : (isLast && hasMorePages);
+        this.hasNextPage = !(isLast && !before && !after) && hasMorePages;
+        if (hasMorePages) {
+            if (isLast) {
+                items.shift();
+            }
+            else {
+                items.pop();
+            }
+        }
+        this.definition = Cursor.getDefinition(meta, orderBy);
+    }
+    get startCursor() {
+        if (this.items.length === 0) {
+            return null;
+        }
+        return this.from(this.items[0]);
+    }
+    get endCursor() {
+        if (this.items.length === 0) {
+            return null;
+        }
+        return this.from(this.items[this.items.length - 1]);
+    }
+    /**
+     * Computes the cursor value for a given entity.
+     */
+    from(entity) {
+        const processEntity = (entity, prop, direction, object = false) => {
+            if (Utils_1.Utils.isPlainObject(direction)) {
+                const value = Utils_1.Utils.keys(direction).reduce((o, key) => {
+                    Object.assign(o, processEntity(Reference_1.Reference.unwrapReference(entity[prop]), key, direction[key], true));
+                    return o;
+                }, {});
+                return ({ [prop]: value });
+            }
+            if (entity[prop] == null) {
+                throw errors_1.CursorError.entityNotPopulated(entity, prop);
+            }
+            let value = entity[prop];
+            if (Utils_1.Utils.isEntity(value, true)) {
+                value = (0, wrap_1.helper)(value).getPrimaryKey();
+            }
+            if (object) {
+                return ({ [prop]: value });
+            }
+            return value;
+        };
+        const value = this.definition.map(([key, direction]) => processEntity(entity, key, direction));
+        return Cursor.encode(value);
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.items) {
+            yield item;
+        }
+    }
+    get length() {
+        return this.items.length;
+    }
+    /**
+     * Computes the cursor value for given entity and order definition.
+     */
+    static for(meta, entity, orderBy) {
+        const definition = this.getDefinition(meta, orderBy);
+        return Cursor.encode(definition.map(([key]) => entity[key]));
+    }
+    static encode(value) {
+        return Buffer.from(JSON.stringify(value)).toString('base64url');
+    }
+    static decode(value) {
+        return JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+    }
+    static getDefinition(meta, orderBy) {
+        return Utils_1.Utils.asArray(orderBy).flatMap(order => {
+            const ret = [];
+            for (const key of Utils_1.Utils.keys(order)) {
+                if (RawQueryFragment_1.RawQueryFragment.isKnownFragment(key)) {
+                    ret.push([key, order[key]]);
+                    continue;
+                }
+                const prop = meta.properties[key];
+                if (!prop || !([enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner))) {
+                    continue;
+                }
+                ret.push([prop.name, order[prop.name]]);
+            }
+            return ret;
+        });
+    }
+    /* istanbul ignore next */
+    /** @ignore */
+    [util_1.inspect.custom]() {
+        const type = this.items[0]?.constructor.name;
+        const { items, startCursor, endCursor, hasPrevPage, hasNextPage, totalCount, length } = this;
+        const options = (0, util_1.inspect)({ startCursor, endCursor, totalCount, hasPrevPage, hasNextPage, items, length }, { depth: 0 });
+        return `Cursor${type ? `<${type}>` : ''} ${options.replace('items: [Array]', 'items: [...]')}`;
+    }
+}
+exports.Cursor = Cursor;

package/utils/DataloaderUtils.d.ts

@@ -0,0 +1,43 @@
+import type { Primary, Ref } from '../typings';
+import { Collection, type InitCollectionOptions } from '../entity/Collection';
+import { type EntityManager } from '../EntityManager';
+import type DataLoader from 'dataloader';
+import { DataloaderType } from '../enums';
+import { type LoadReferenceOptions } from '../entity/Reference';
+export declare class DataloaderUtils {
+    /**
+     * Groups identified references by entity and returns a Map with the
+     * class name as the index and the corresponging primary keys as the value.
+     */
+    static groupPrimaryKeysByEntityAndOpts(refsWithOpts: readonly [Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?][]): Map<string, Set<Primary<any>>>;
+    /**
+     * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
+     * makes one query per entity and maps each input reference to the corresponging result.
+     */
+    static getRefBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
+    /**
+     * Groups collections by entity and returns a Map whose keys are the entity names and whose values are filter Maps
+     * which we can use to narrow down the find query to return just the items of the collections that have been dataloaded.
+     * The entries of the filter Map will be used as the values of an $or operator so we end up with a query per entity.
+     */
+    static groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts: readonly [Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?][]): Map<string, Map<string, Set<Primary<any>>>>;
+    /**
+     * Turn the entity+options map into actual queries.
+     * The keys are the entity names + a strigified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
+     * We must populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s).
+     * Together with the query the promises will also return the key which can be used to narrow down the results pertaining to a certain set of options.
+     */
+    static entitiesAndOptsMapToQueries(entitiesAndOptsMap: Map<string, Map<string, Set<Primary<any>>>>, em: EntityManager): Promise<[string, any[]]>[];
+    /**
+     * Creates a filter which returns the results pertaining to a certain collection.
+     * First checks if the Entity type matches, then retrieves the inverse side of the relationship
+     * where the filtering will be done in order to match the target collection.
+     */
+    static getColFilter<T, S extends T>(collection: Collection<any, object>): (result: T) => result is S;
+    /**
+     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponging result.
+     */
+    static getColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getDataloaderType(dataloaderCfg: DataloaderType | boolean): DataloaderType;
+}

package/utils/DataloaderUtils.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataloaderUtils = void 0;
+const Collection_1 = require("../entity/Collection");
+const wrap_1 = require("../entity/wrap");
+const enums_1 = require("../enums");
+class DataloaderUtils {
+    /**
+     * Groups identified references by entity and returns a Map with the
+     * class name as the index and the corresponging primary keys as the value.
+     */
+    static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
+        const map = new Map();
+        for (const [ref, opts] of refsWithOpts) {
+            /* The key is a combination of the className and a stringified version if the load options because we want
+               to map each combination of entities/options into separate find queries in order to return accurate results.
+               This could be further optimized finding the "lowest common denominator" among the different options
+               for each Entity and firing a single query for each Entity instead of Entity+options combination.
+               The former is the approach taken by the out-of-tree "find" dataloader: https://github.com/darkbasic/mikro-orm-dataloaders
+               In real-world scenarios (GraphQL) most of the time you will end up batching the same sets of options anyway,
+               so we end up getting most of the benefits with the much simpler implementation.
+               Also there are scenarios where the single query per entity implementation may end up being slower, for example
+               if the vast majority of the refereces batched for a certain entity  don't have populate options while a few ones have
+               a wildcard populate so you end up doing the additional joins for all the entities.
+               Thus such approach should probably be configurable, if not opt-in.
+               NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
+               to implement this but not necessarily faster.  */
+            const key = `${(0, wrap_1.helper)(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            let primaryKeysSet = map.get(key);
+            if (primaryKeysSet == null) {
+                primaryKeysSet = new Set();
+                map.set(key, primaryKeysSet);
+            }
+            primaryKeysSet.add((0, wrap_1.helper)(ref).getPrimaryKey());
+        }
+        return map;
+    }
+    /**
+     * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
+     * makes one query per entity and maps each input reference to the corresponging result.
+     */
+    static getRefBatchLoadFn(em) {
+        return async (refsWithOpts) => {
+            const groupedIdsMap = DataloaderUtils.groupPrimaryKeysByEntityAndOpts(refsWithOpts);
+            const promises = Array.from(groupedIdsMap).map(([key, idsSet]) => {
+                const className = key.substring(0, key.indexOf('|'));
+                const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
+                return em.find(className, Array.from(idsSet), opts);
+            });
+            await Promise.all(promises);
+            /* Instead of assigning each find result to the original reference we use a shortcut
+              which takes advantage of the already existing Mikro-ORM caching mechanism:
+              when it calls ref.unwrap it will automatically retrieve the entity
+              from the cache (it will hit the cache because of the previous find query).
+              This trick won't be possible for collections where we will be forced to map the results. */
+            return refsWithOpts.map(([ref]) => ref.unwrap());
+        };
+    }
+    /**
+     * Groups collections by entity and returns a Map whose keys are the entity names and whose values are filter Maps
+     * which we can use to narrow down the find query to return just the items of the collections that have been dataloaded.
+     * The entries of the filter Map will be used as the values of an $or operator so we end up with a query per entity.
+     */
+    static groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts) {
+        const entitiesMap = new Map();
+        for (const [col, opts] of collsWithOpts) {
+            /*
+            We first get the entity name of the Collection and together with its options (see groupPrimaryKeysByEntityAndOpts
+            for a full explanation) we use it as the key of the first Map.
+            With that we know that we have to look for entities of this type (and with the same options) in order to fulfill the collection.
+            The value is another Map which we can use to filter the find query to get results pertaining to the collections that have been dataloaded:
+            its keys are the props we are going to filter to and its values are the corresponding PKs.
+            */
+            const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+            let filterMap = entitiesMap.get(key); // We are going to use this map to filter the entities pertaining to the collections that have been dataloaded.
+            if (filterMap == null) {
+                filterMap = new Map();
+                entitiesMap.set(key, filterMap);
+            }
+            // The Collection dataloader relies on the inverse side of the relationship (inversedBy/mappedBy), which is going to be
+            // the key of the filter Map and it's the prop that we use to filter the results pertaining to the Collection.
+            const inversedProp = col.property.inversedBy ?? col.property.mappedBy; // Many to Many vs One to Many
+            let primaryKeys = filterMap.get(inversedProp);
+            if (primaryKeys == null) {
+                primaryKeys = new Set();
+                filterMap.set(inversedProp, primaryKeys);
+            }
+            // This is the PK that in conjunction with the filter Map key (the prop) will lead to this specific Collection
+            primaryKeys.add((0, wrap_1.helper)(col.owner).getPrimaryKey());
+        }
+        return entitiesMap;
+    }
+    /**
+     * Turn the entity+options map into actual queries.
+     * The keys are the entity names + a strigified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
+     * We must populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s).
+     * Together with the query the promises will also return the key which can be used to narrow down the results pertaining to a certain set of options.
+     */
+    static entitiesAndOptsMapToQueries(entitiesAndOptsMap, em) {
+        return Array.from(entitiesAndOptsMap, async ([key, filterMap]) => {
+            const className = key.substring(0, key.indexOf('|'));
+            const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
+            const res = await em.find(className, opts?.where != null && Object.keys(opts.where).length > 0 ?
+                {
+                    $and: [
+                        {
+                            $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                                return ({ [prop]: Array.from(pks) });
+                            }),
+                        },
+                        opts.where,
+                    ],
+                } : {
+                // The entries of the filter Map will be used as the values of the $or operator
+                $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                    return ({ [prop]: Array.from(pks) });
+                }),
+            }, {
+                ...opts,
+                // We need to populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s)
+                populate: [
+                    ...(opts.populate === false ? [] : opts.populate ?? []),
+                    ...(opts.ref ? [':ref'] : []),
+                    ...Array.from(filterMap.keys()).filter(
+                    // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
+                    prop => em.getMetadata(className).properties[prop]?.ref !== true),
+                ],
+            });
+            return [key, res];
+        });
+    }
+    /**
+     * Creates a filter which returns the results pertaining to a certain collection.
+     * First checks if the Entity type matches, then retrieves the inverse side of the relationship
+     * where the filtering will be done in order to match the target collection.
+     */
+    static getColFilter(collection) {
+        return (result) => {
+            // There is no need to check if Entity matches because we already matched the key which is entity+options.
+            // This is the inverse side of the relationship where the filtering will be done in order to match the target collection
+            // Either inversedBy or mappedBy exist because we already checked in groupInversedOrMappedKeysByEntity
+            const refOrCol = result[(collection.property.inversedBy ?? collection.property.mappedBy)];
+            if (refOrCol instanceof Collection_1.Collection) {
+                // The inverse side is a Collection
+                // We keep the result if any of PKs of the inverse side matches the PK of the collection owner
+                for (const item of refOrCol.getItems()) {
+                    if ((0, wrap_1.helper)(item).getSerializedPrimaryKey() === (0, wrap_1.helper)(collection.owner).getSerializedPrimaryKey()) {
+                        return true;
+                    }
+                }
+            }
+            else {
+                // The inverse side is a Reference
+                // We keep the result if the PK of the inverse side matches the PK of the collection owner
+                return (0, wrap_1.helper)(refOrCol).getSerializedPrimaryKey() === (0, wrap_1.helper)(collection.owner).getSerializedPrimaryKey();
+            }
+            return false;
+        };
+    }
+    /**
+     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponging result.
+     */
+    static getColBatchLoadFn(em) {
+        return async (collsWithOpts) => {
+            const entitiesAndOptsMap = DataloaderUtils.groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts);
+            const promises = DataloaderUtils.entitiesAndOptsMapToQueries(entitiesAndOptsMap, em);
+            const resultsMap = new Map(await Promise.all(promises));
+            // We need to filter the results in order to map each input collection
+            // to a subset of each query matching the collection items.
+            return collsWithOpts.map(([col, opts]) => {
+                const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+                const entities = resultsMap.get(key);
+                if (entities == null) {
+                    // Should never happen
+                    /* istanbul ignore next */
+                    throw new Error('Cannot match results');
+                }
+                return entities.filter(DataloaderUtils.getColFilter(col));
+            });
+        };
+    }
+    static getDataloaderType(dataloaderCfg) {
+        switch (dataloaderCfg) {
+            case true:
+                return enums_1.DataloaderType.ALL;
+            case false:
+                return enums_1.DataloaderType.NONE;
+            default:
+                return dataloaderCfg;
+        }
+    }
+}
+exports.DataloaderUtils = DataloaderUtils;

package/utils/EntityComparator.d.ts

@@ -0,0 +1,73 @@
+import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings';
+import type { Platform } from '../platforms';
+type Comparator<T> = (a: T, b: T) => EntityData<T>;
+type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
+type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
+export declare class EntityComparator {
+    private readonly metadata;
+    private readonly platform;
+    private readonly comparators;
+    private readonly mappers;
+    private readonly snapshotGenerators;
+    private readonly pkGetters;
+    private readonly pkGettersConverted;
+    private readonly pkSerializers;
+    private tmpIndex;
+    constructor(metadata: IMetadataStorage, platform: Platform);
+    /**
+     * Computes difference between two entities.
+     */
+    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): EntityData<T>;
+    matching<T>(entityName: string, 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>(entity: T): EntityData<T>;
+    /**
+     * Maps database columns to properties.
+     */
+    mapResult<T>(entityName: string, result: EntityDictionary<T>): EntityData<T>;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getPkGetter<T>(meta: EntityMetadata<T>): any;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getPkGetterConverted<T>(meta: EntityMetadata<T>): any;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getPkSerializer<T>(meta: EntityMetadata<T>): any;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getSnapshotGenerator<T>(entityName: string): SnapshotGenerator<T>;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getResultMapper<T>(entityName: string): 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 getPropertySnapshot;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getEntityComparator<T extends object>(entityName: string): Comparator<T>;
+    private getGenericComparator;
+    private getPropertyComparator;
+    private wrap;
+    private safeKey;
+    /**
+     * 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 {};