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

package/unit-of-work/ChangeSetPersister.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSetPersister = void 0;
+const entity_1 = require("../entity");
+const ChangeSet_1 = require("./ChangeSet");
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+class ChangeSetPersister {
+    driver;
+    metadata;
+    hydrator;
+    factory;
+    validator;
+    config;
+    platform;
+    comparator;
+    constructor(driver, metadata, hydrator, factory, validator, config) {
+        this.driver = driver;
+        this.metadata = metadata;
+        this.hydrator = hydrator;
+        this.factory = factory;
+        this.validator = validator;
+        this.config = config;
+        this.platform = this.driver.getPlatform();
+        this.comparator = this.config.getComparator(this.metadata);
+    }
+    async executeInserts(changeSets, options, withSchema) {
+        if (!withSchema) {
+            return this.runForEachSchema(changeSets, 'executeInserts', options);
+        }
+        const meta = this.metadata.find(changeSets[0].name);
+        changeSets.forEach(changeSet => this.processProperties(changeSet));
+        if (changeSets.length > 1 && this.config.get('useBatchInserts', this.platform.usesBatchInserts())) {
+            return this.persistNewEntities(meta, changeSets, options);
+        }
+        for (const changeSet of changeSets) {
+            await this.persistNewEntity(meta, changeSet, options);
+        }
+    }
+    async executeUpdates(changeSets, batched, options, withSchema) {
+        if (!withSchema) {
+            return this.runForEachSchema(changeSets, 'executeUpdates', options, batched);
+        }
+        const meta = this.metadata.find(changeSets[0].name);
+        changeSets.forEach(changeSet => this.processProperties(changeSet));
+        if (batched && changeSets.length > 1 && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
+            return this.persistManagedEntities(meta, changeSets, options);
+        }
+        for (const changeSet of changeSets) {
+            await this.persistManagedEntity(changeSet, options);
+        }
+    }
+    async executeDeletes(changeSets, options, withSchema) {
+        if (!withSchema) {
+            return this.runForEachSchema(changeSets, 'executeDeletes', options);
+        }
+        const size = this.config.get('batchSize');
+        const meta = changeSets[0].meta;
+        const pk = utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        for (let i = 0; i < changeSets.length; i += size) {
+            const chunk = changeSets.slice(i, i + size);
+            const pks = chunk.map(cs => cs.getPrimaryKey());
+            options = this.propagateSchemaFromMetadata(meta, options);
+            await this.driver.nativeDelete(meta.className, { [pk]: { $in: pks } }, options);
+        }
+    }
+    async runForEachSchema(changeSets, method, options, ...args) {
+        const groups = new Map();
+        changeSets.forEach(cs => {
+            const group = groups.get(cs.schema) ?? [];
+            group.push(cs);
+            groups.set(cs.schema, group);
+        });
+        for (const [key, group] of groups.entries()) {
+            options = { ...options, schema: key };
+            // @ts-ignore
+            await this[method](group, ...args, options, true);
+        }
+    }
+    processProperties(changeSet) {
+        const meta = this.metadata.find(changeSet.name);
+        for (const prop of meta.relations) {
+            this.processProperty(changeSet, prop);
+        }
+        if (changeSet.type === ChangeSet_1.ChangeSetType.CREATE && this.config.get('validateRequired')) {
+            this.validator.validateRequired(changeSet.entity);
+        }
+    }
+    async persistNewEntity(meta, changeSet, options) {
+        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        options = this.propagateSchemaFromMetadata(meta, options, {
+            convertCustomTypes: false,
+        });
+        const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
+        if (!wrapped.hasPrimaryKey()) {
+            this.mapPrimaryKey(meta, res.insertId, changeSet);
+        }
+        this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
+        this.markAsPopulated(changeSet, meta);
+        wrapped.__initialized = true;
+        wrapped.__managed = true;
+        if (!this.platform.usesReturningStatement()) {
+            await this.reloadVersionValues(meta, [changeSet], options);
+        }
+        changeSet.persisted = true;
+    }
+    async persistNewEntities(meta, changeSets, options) {
+        const size = this.config.get('batchSize');
+        for (let i = 0; i < changeSets.length; i += size) {
+            const chunk = changeSets.slice(i, i + size);
+            await this.persistNewEntitiesBatch(meta, chunk, options);
+            if (!this.platform.usesReturningStatement()) {
+                await this.reloadVersionValues(meta, chunk, options);
+            }
+        }
+    }
+    propagateSchemaFromMetadata(meta, options, additionalOptions) {
+        return {
+            ...options,
+            ...additionalOptions,
+            schema: options?.schema ?? meta.schema,
+        };
+    }
+    async persistNewEntitiesBatch(meta, changeSets, options) {
+        options = this.propagateSchemaFromMetadata(meta, options, {
+            convertCustomTypes: false,
+            processCollections: false,
+        });
+        const res = await this.driver.nativeInsertMany(meta.className, changeSets.map(cs => cs.payload), options);
+        for (let i = 0; i < changeSets.length; i++) {
+            const changeSet = changeSets[i];
+            const wrapped = (0, entity_1.helper)(changeSet.entity);
+            if (!wrapped.hasPrimaryKey()) {
+                const field = meta.getPrimaryProps()[0].fieldNames[0];
+                this.mapPrimaryKey(meta, res.rows[i][field], changeSet);
+            }
+            if (res.rows) {
+                this.mapReturnedValues(changeSet.entity, changeSet.payload, res.rows[i], meta);
+            }
+            this.markAsPopulated(changeSet, meta);
+            wrapped.__initialized = true;
+            wrapped.__managed = true;
+            changeSet.persisted = true;
+        }
+    }
+    async persistManagedEntity(changeSet, options) {
+        const meta = this.metadata.find(changeSet.name);
+        const res = await this.updateEntity(meta, changeSet, options);
+        this.checkOptimisticLock(meta, changeSet, res);
+        this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
+        await this.reloadVersionValues(meta, [changeSet], options);
+        changeSet.persisted = true;
+    }
+    async persistManagedEntities(meta, changeSets, options) {
+        const size = this.config.get('batchSize');
+        for (let i = 0; i < changeSets.length; i += size) {
+            const chunk = changeSets.slice(i, i + size);
+            await this.persistManagedEntitiesBatch(meta, chunk, options);
+            await this.reloadVersionValues(meta, chunk, options);
+        }
+    }
+    checkConcurrencyKeys(meta, changeSet, cond) {
+        const tmp = [];
+        cond = utils_1.Utils.isPlainObject(cond) ? cond : { [meta.primaryKeys[0]]: cond };
+        for (const key of meta.concurrencyCheckKeys) {
+            cond[key] = changeSet.originalEntity[key];
+            if (changeSet.payload[key]) {
+                tmp.push(key);
+            }
+        }
+        if (tmp.length === 0 && meta.concurrencyCheckKeys.size > 0) {
+            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+        }
+    }
+    async persistManagedEntitiesBatch(meta, changeSets, options) {
+        await this.checkOptimisticLocks(meta, changeSets, options);
+        options = this.propagateSchemaFromMetadata(meta, options, {
+            convertCustomTypes: false,
+            processCollections: false,
+        });
+        const cond = changeSets.map(cs => cs.getPrimaryKey(true));
+        changeSets.forEach((changeSet, idx) => {
+            this.checkConcurrencyKeys(meta, changeSet, cond[idx]);
+        });
+        const res = await this.driver.nativeUpdateMany(meta.className, cond, changeSets.map(cs => cs.payload), options);
+        changeSets.forEach((changeSet, idx) => {
+            if (res.rows) {
+                this.mapReturnedValues(changeSet.entity, changeSet.payload, res.rows[idx], meta);
+            }
+            changeSet.persisted = true;
+        });
+    }
+    mapPrimaryKey(meta, value, changeSet) {
+        const prop = meta.properties[meta.primaryKeys[0]];
+        const insertId = prop.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
+        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        if (!wrapped.hasPrimaryKey()) {
+            wrapped.setPrimaryKey(insertId);
+        }
+        // some drivers might be returning bigint PKs as numbers when the number is small enough,
+        // but we need to have it as string so comparison works in change set tracking, so instead
+        // of using the raw value from db, we convert it back to the db value explicitly
+        value = prop.customType ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' }) : value;
+        changeSet.payload[wrapped.__meta.primaryKeys[0]] = value;
+        wrapped.__identifier?.setValue(value);
+    }
+    /**
+     * Sets populate flag to new entities so they are serialized like if they were loaded from the db
+     */
+    markAsPopulated(changeSet, meta) {
+        (0, entity_1.helper)(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
+        if (!this.config.get('populateAfterFlush')) {
+            return;
+        }
+        (0, entity_1.helper)(changeSet.entity).populated();
+        meta.relations.forEach(prop => {
+            const value = changeSet.entity[prop.name];
+            if (utils_1.Utils.isEntity(value, true)) {
+                value.__helper.populated();
+            }
+            else if (utils_1.Utils.isCollection(value)) {
+                value.populated();
+            }
+        });
+    }
+    async updateEntity(meta, changeSet, options) {
+        const cond = changeSet.getPrimaryKey(true);
+        options = this.propagateSchemaFromMetadata(meta, options, {
+            convertCustomTypes: false,
+        });
+        if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
+            return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+        }
+        if (meta.versionProperty) {
+            cond[meta.versionProperty] = this.platform.quoteVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+        }
+        this.checkConcurrencyKeys(meta, changeSet, cond);
+        return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+    }
+    async checkOptimisticLocks(meta, changeSets, options) {
+        if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
+            return;
+        }
+        // skip entity references as they don't have version values loaded
+        changeSets = changeSets.filter(cs => (0, entity_1.helper)(cs.entity).__initialized);
+        const $or = changeSets.map(cs => {
+            const cond = utils_1.Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
+            if (meta.versionProperty) {
+                // @ts-ignore
+                cond[meta.versionProperty] = this.platform.quoteVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            }
+            return cond;
+        });
+        const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
+        options = this.propagateSchemaFromMetadata(meta, options, {
+            fields: primaryKeys,
+        });
+        const res = await this.driver.find(meta.root.className, { $or }, options);
+        if (res.length !== changeSets.length) {
+            const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
+            const entity = changeSets.find(cs => {
+                return !res.some(row => compare(utils_1.Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
+            }).entity;
+            throw errors_1.OptimisticLockError.lockFailed(entity);
+        }
+    }
+    checkOptimisticLock(meta, changeSet, res) {
+        if ((meta.versionProperty || meta.concurrencyCheckKeys.size > 0) && res && !res.affectedRows) {
+            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+        }
+    }
+    /**
+     * This method also handles reloading of database default values for inserts and raw property updates,
+     * so we use a single query in case of both versioning and default values is used.
+     */
+    async reloadVersionValues(meta, changeSets, options) {
+        const reloadProps = meta.versionProperty && !this.platform.usesReturningStatement() ? [meta.properties[meta.versionProperty]] : [];
+        if (changeSets[0].type === ChangeSet_1.ChangeSetType.CREATE) {
+            // do not reload things that already had a runtime value
+            meta.props
+                .filter(prop => prop.persist !== false && (prop.autoincrement || prop.generated || prop.defaultRaw))
+                .filter(prop => (changeSets[0].entity[prop.name] == null && prop.defaultRaw !== 'null') || utils_1.Utils.isRawSql(changeSets[0].entity[prop.name]))
+                .forEach(prop => reloadProps.push(prop));
+        }
+        if (changeSets[0].type === ChangeSet_1.ChangeSetType.UPDATE) {
+            const returning = new Set();
+            changeSets.forEach(cs => {
+                utils_1.Utils.keys(cs.payload).forEach(k => {
+                    if (utils_1.Utils.isRawSql(cs.payload[k]) && utils_1.Utils.isRawSql(cs.entity[k])) {
+                        returning.add(meta.properties[k]);
+                    }
+                });
+            });
+            // reload generated columns
+            if (!this.platform.usesReturningStatement()) {
+                meta.props
+                    .filter(prop => prop.generated && !prop.primary)
+                    .forEach(prop => reloadProps.push(prop));
+                reloadProps.push(...returning);
+            }
+        }
+        if (reloadProps.length === 0) {
+            return;
+        }
+        reloadProps.unshift(...meta.getPrimaryProps());
+        const pk = utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pks = changeSets.map(cs => {
+            const val = (0, entity_1.helper)(cs.entity).getPrimaryKey(true);
+            if (utils_1.Utils.isPlainObject(val)) {
+                return utils_1.Utils.getCompositeKeyValue(val, meta, false, this.platform);
+            }
+            return val;
+        });
+        options = this.propagateSchemaFromMetadata(meta, options, {
+            fields: utils_1.Utils.unique(reloadProps.map(prop => prop.name)),
+        });
+        const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
+        const map = new Map();
+        data.forEach(item => map.set(utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        for (const changeSet of changeSets) {
+            const data = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+            this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
+            Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
+        }
+    }
+    processProperty(changeSet, prop) {
+        const meta = this.metadata.find(changeSet.name);
+        const value = changeSet.payload[prop.name]; // for inline embeddables
+        if (value instanceof entity_1.EntityIdentifier) {
+            changeSet.payload[prop.name] = value.getValue();
+            return;
+        }
+        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
+            changeSet.payload[prop.name] = value.map(val => val instanceof entity_1.EntityIdentifier ? val.getValue() : val);
+            return;
+        }
+        if (prop.name in changeSet.payload) {
+            return;
+        }
+        const values = utils_1.Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
+        values.forEach(([value, indexes]) => {
+            if (value instanceof entity_1.EntityIdentifier) {
+                utils_1.Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
+            }
+        });
+    }
+    /**
+     * Maps values returned via `returning` statement (postgres) or the inserted id (other sql drivers).
+     * No need to handle composite keys here as they need to be set upfront.
+     * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
+     */
+    mapReturnedValues(entity, payload, row, meta) {
+        if (this.platform.usesReturningStatement() && row && utils_1.Utils.hasObjectKeys(row)) {
+            const mapped = this.comparator.mapResult(meta.className, row);
+            this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
+            Object.assign(payload, mapped); // merge to the changeset payload, so it gets saved to the entity snapshot
+        }
+    }
+}
+exports.ChangeSetPersister = ChangeSetPersister;

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

@@ -0,0 +1,62 @@
+import type { Dictionary, EntityProperty } from '../typings';
+export declare const enum NodeState {
+    NOT_VISITED = 0,
+    IN_PROGRESS = 1,
+    VISITED = 2
+}
+export interface Node {
+    hash: string;
+    state: NodeState;
+    dependencies: Dictionary<Edge>;
+}
+export interface Edge {
+    from: string;
+    to: string;
+    weight: number;
+}
+/**
+ * CommitOrderCalculator implements topological sorting, which is an ordering
+ * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
+ * using a depth-first searching (DFS) to traverse the graph built in memory.
+ * This algorithm have a linear running time based on nodes (V) and dependency
+ * between the nodes (E), resulting in a computational complexity of O(V + E).
+ *
+ * Based on https://github.com/doctrine/orm/blob/master/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php
+ * @internal
+ */
+export declare class CommitOrderCalculator {
+    /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
+    private nodes;
+    /** Volatile variable holding calculated nodes during sorting process. */
+    private sortedNodeList;
+    /**
+     * Checks for node existence in graph.
+     */
+    hasNode(hash: string): boolean;
+    /**
+     * Adds a new node to the graph, assigning its hash.
+     */
+    addNode(hash: string): void;
+    /**
+     * Adds a new dependency (edge) to the graph using their hashes.
+     */
+    addDependency(from: string, to: string, weight: number): void;
+    discoverProperty(prop: EntityProperty, entityName: string): 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(): string[];
+    /**
+     * 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;
+}

package/unit-of-work/CommitOrderCalculator.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitOrderCalculator = exports.NodeState = void 0;
+const enums_1 = require("../enums");
+var NodeState;
+(function (NodeState) {
+    NodeState[NodeState["NOT_VISITED"] = 0] = "NOT_VISITED";
+    NodeState[NodeState["IN_PROGRESS"] = 1] = "IN_PROGRESS";
+    NodeState[NodeState["VISITED"] = 2] = "VISITED";
+})(NodeState || (exports.NodeState = NodeState = {}));
+/**
+ * CommitOrderCalculator implements topological sorting, which is an ordering
+ * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
+ * using a depth-first searching (DFS) to traverse the graph built in memory.
+ * This algorithm have a linear running time based on nodes (V) and dependency
+ * between the nodes (E), resulting in a computational complexity of O(V + E).
+ *
+ * Based on https://github.com/doctrine/orm/blob/master/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php
+ * @internal
+ */
+class CommitOrderCalculator {
+    /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
+    nodes = {};
+    /** Volatile variable holding calculated nodes during sorting process. */
+    sortedNodeList = [];
+    /**
+     * Checks for node existence in graph.
+     */
+    hasNode(hash) {
+        return hash in this.nodes;
+    }
+    /**
+     * Adds a new node to the graph, assigning its hash.
+     */
+    addNode(hash) {
+        this.nodes[hash] = { hash, state: 0 /* NodeState.NOT_VISITED */, dependencies: {} };
+    }
+    /**
+     * Adds a new dependency (edge) to the graph using their hashes.
+     */
+    addDependency(from, to, weight) {
+        this.nodes[from].dependencies[to] = { from, to, weight };
+    }
+    discoverProperty(prop, entityName) {
+        const toOneOwner = (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE;
+        const toManyOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
+        if (!toOneOwner && !toManyOwner) {
+            return;
+        }
+        const propertyType = prop.targetMeta?.root.className;
+        if (!propertyType || !this.hasNode(propertyType)) {
+            return;
+        }
+        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 Object.values(this.nodes)) {
+            if (vertex.state !== 0 /* NodeState.NOT_VISITED */) {
+                continue;
+            }
+            this.visit(vertex);
+        }
+        const sortedList = this.sortedNodeList.reverse();
+        this.nodes = {};
+        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 Object.values(node.dependencies)) {
+            const target = this.nodes[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[node.hash] || target.dependencies[node.hash].weight >= edge.weight) {
+            return;
+        }
+        for (const edge of Object.values(target.dependencies)) {
+            const targetNode = this.nodes[edge.to];
+            if (targetNode.state === 0 /* NodeState.NOT_VISITED */) {
+                this.visit(targetNode);
+            }
+        }
+        target.state = 2 /* NodeState.VISITED */;
+        this.sortedNodeList.push(target.hash);
+    }
+}
+exports.CommitOrderCalculator = CommitOrderCalculator;

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

@@ -0,0 +1,17 @@
+import type { AnyEntity, EntityMetadata } from '../typings';
+export declare class IdentityMap {
+    private readonly registry;
+    store<T>(item: T): 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;
+}

package/unit-of-work/IdentityMap.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityMap = void 0;
+const Utils_1 = require("../utils/Utils");
+class IdentityMap {
+    registry = new Map();
+    store(item) {
+        this.getStore(item.__meta.root).set(this.getPkHash(item), item);
+    }
+    delete(item) {
+        this.getStore(item.__meta.root).delete(this.getPkHash(item));
+    }
+    getByHash(meta, hash) {
+        const store = this.getStore(meta);
+        return store.has(hash) ? store.get(hash) : undefined;
+    }
+    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;
+    }
+    clear() {
+        this.registry.clear();
+    }
+    values() {
+        const ret = [];
+        for (const store of this.registry.values()) {
+            ret.push(...store.values());
+        }
+        return ret;
+    }
+    *[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 pk = wrapped.getPrimaryKey(true);
+        if (pk == null) {
+            return pk;
+        }
+        let hash;
+        if (meta.simplePK) {
+            hash = '' + item[meta.primaryKeys[0]];
+        }
+        else {
+            const pks = Utils_1.Utils.getOrderedPrimaryKeys(pk, meta);
+            hash = Utils_1.Utils.getPrimaryKeyHash(pks);
+        }
+        const schema = wrapped.__schema || meta.root.schema;
+        if (schema) {
+            return schema + ':' + hash;
+        }
+        return hash;
+    }
+}
+exports.IdentityMap = IdentityMap;