@mikro-orm/core 7.0.0-dev.2 → 7.0.0-dev.200

package/unit-of-work/ChangeSetPersister.js

@@ -3,25 +3,25 @@ import { helper } from '../entity/wrap.js';
 import { ChangeSetType } from './ChangeSet.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
 import { Utils } from '../utils/Utils.js';
-import { OptimisticLockError } from '../errors.js';
+import { OptimisticLockError, ValidationError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetPersister {
     driver;
     metadata;
     hydrator;
     factory;
-    validator;
     config;
+    em;
     platform;
     comparator;
     usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, validator, config) {
+    constructor(driver, metadata, hydrator, factory, config, em) {
         this.driver = driver;
         this.metadata = metadata;
         this.hydrator = hydrator;
         this.factory = factory;
-        this.validator = validator;
         this.config = config;
+        this.em = em;
         this.platform = this.driver.getPlatform();
         this.comparator = this.config.getComparator(this.metadata);
         this.usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
@@ -30,7 +30,7 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeInserts', options);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
         if (changeSets.length > 1 && this.config.get('useBatchInserts', this.platform.usesBatchInserts())) {
             return this.persistNewEntities(meta, changeSets, options);
@@ -43,9 +43,12 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeUpdates', options, batched);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
-        if (batched && changeSets.length > 1 && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
+        // For STI with conflicting fieldNames (renamedFrom properties), we can't batch mixed child types
+        const hasSTIConflicts = meta.root.props.some(p => p.renamedFrom);
+        const hasMixedTypes = hasSTIConflicts && changeSets.some(cs => cs.meta.class !== meta.class);
+        if (batched && changeSets.length > 1 && !hasMixedTypes && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
         }
         for (const changeSet of changeSets) {
@@ -62,8 +65,8 @@ export class ChangeSetPersister {
         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.root.className, { [pk]: { $in: pks } }, options);
+            options = this.prepareOptions(meta, options);
+            await this.driver.nativeDelete(meta.root.class, { [pk]: { $in: pks } }, options);
         }
     }
     async runForEachSchema(changeSets, method, options, ...args) {
@@ -79,21 +82,41 @@ export class ChangeSetPersister {
             await this[method](group, ...args, options, true);
         }
     }
+    validateRequired(entity) {
+        const wrapped = helper(entity);
+        for (const prop of wrapped.__meta.props) {
+            if (!prop.nullable &&
+                !prop.autoincrement &&
+                !prop.default &&
+                !prop.defaultRaw &&
+                !prop.onCreate &&
+                !prop.generated &&
+                !prop.embedded &&
+                ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
+                prop.name !== wrapped.__meta.root.discriminatorColumn &&
+                prop.type !== 'ObjectId' &&
+                prop.persist !== false &&
+                entity[prop.name] == null) {
+                throw ValidationError.propertyRequired(entity, prop);
+            }
+        }
+    }
     processProperties(changeSet) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
         if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
-            this.validator.validateRequired(changeSet.entity);
+            this.validateRequired(changeSet.entity);
         }
     }
     async persistNewEntity(meta, changeSet, options) {
         const wrapped = helper(changeSet.entity);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
+        // Use changeSet's own meta for STI entities to get correct field mappings
+        const res = await this.driver.nativeInsertMany(changeSet.meta.class, [changeSet.payload], options);
         if (!wrapped.hasPrimaryKey()) {
             this.mapPrimaryKey(meta, res.insertId, changeSet);
         }
@@ -116,19 +139,21 @@ export class ChangeSetPersister {
             }
         }
     }
-    propagateSchemaFromMetadata(meta, options, additionalOptions) {
+    prepareOptions(meta, options, additionalOptions) {
+        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
         return {
             ...options,
             ...additionalOptions,
             schema: options?.schema ?? meta.schema,
+            loggerContext,
         };
     }
     async persistNewEntitiesBatch(meta, changeSets, options) {
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, changeSets.map(cs => cs.payload), options);
+        const res = await this.driver.nativeInsertMany(meta.class, changeSets.map(cs => cs.payload), options);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
             const wrapped = helper(changeSet.entity);
@@ -146,7 +171,7 @@ export class ChangeSetPersister {
         }
     }
     async persistManagedEntity(changeSet, options) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const res = await this.updateEntity(meta, changeSet, options);
         this.checkOptimisticLock(meta, changeSet, res);
         this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
@@ -175,7 +200,7 @@ export class ChangeSetPersister {
     }
     async persistManagedEntitiesBatch(meta, changeSets, options) {
         await this.checkOptimisticLocks(meta, changeSets, options);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -187,7 +212,7 @@ export class ChangeSetPersister {
             cond.push(where);
             payload.push(changeSet.payload);
         }
-        const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
+        const res = await this.driver.nativeUpdateMany(meta.class, cond, payload, options);
         const map = new Map();
         res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
@@ -210,7 +235,9 @@ export class ChangeSetPersister {
         // 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);
+        if (wrapped.__identifier && !Array.isArray(wrapped.__identifier)) {
+            wrapped.__identifier.setValue(value);
+        }
     }
     /**
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
@@ -233,17 +260,17 @@ export class ChangeSetPersister {
     }
     async updateEntity(meta, changeSet, options) {
         const cond = changeSet.getPrimaryKey(true);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(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);
+            return this.driver.nativeUpdate(changeSet.meta.class, 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);
+        return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
@@ -260,10 +287,10 @@ export class ChangeSetPersister {
             return cond;
         });
         const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
-        const res = await this.driver.find(meta.root.className, { $or }, options);
+        const res = await this.driver.find(meta.root.class, { $or }, options);
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
@@ -284,11 +311,22 @@ export class ChangeSetPersister {
     async reloadVersionValues(meta, changeSets, options) {
         const reloadProps = meta.versionProperty && !this.usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
         if (changeSets[0].type === 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') || isRaw(changeSets[0].entity[prop.name]))
-                .forEach(prop => reloadProps.push(prop));
+            for (const prop of meta.props) {
+                if (prop.persist === false) {
+                    continue;
+                }
+                if (isRaw(changeSets[0].entity[prop.name])) {
+                    reloadProps.push(prop);
+                    continue;
+                }
+                // do not reload things that already had a runtime value
+                if (changeSets[0].entity[prop.name] != null || prop.defaultRaw === 'null') {
+                    continue;
+                }
+                if (prop.autoincrement || prop.generated || prop.defaultRaw) {
+                    reloadProps.push(prop);
+                }
+            }
         }
         if (changeSets[0].type === ChangeSetType.UPDATE) {
             const returning = new Set();
@@ -319,12 +357,12 @@ export class ChangeSetPersister {
             }
             return val;
         });
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
-        const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
+        const data = await this.driver.find(meta.class, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
@@ -332,12 +370,16 @@ export class ChangeSetPersister {
         }
     }
     processProperty(changeSet, prop) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const value = changeSet.payload[prop.name]; // for inline embeddables
         if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
             return;
         }
+        if (Array.isArray(value) && value.every(item => item instanceof EntityIdentifier)) {
+            changeSet.payload[prop.name] = value.map(item => item.getValue());
+            return;
+        }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
             changeSet.payload[prop.name] = value.map(val => val instanceof EntityIdentifier ? val.getValue() : val);
             return;
@@ -361,7 +403,7 @@ export class ChangeSetPersister {
         if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
-        const mapped = this.comparator.mapResult(meta.className, row);
+        const mapped = this.comparator.mapResult(meta, row);
         if (entity) {
             this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
         }

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

@@ -1,17 +1,18 @@
-import type { Dictionary, EntityProperty } from '../typings.js';
+import type { EntityProperty } from '../typings.js';
 export declare const enum NodeState {
     NOT_VISITED = 0,
     IN_PROGRESS = 1,
     VISITED = 2
 }
+type Hash = number;
 export interface Node {
-    hash: string;
+    hash: Hash;
     state: NodeState;
-    dependencies: Dictionary<Edge>;
+    dependencies: Map<Hash, Edge>;
 }
 export interface Edge {
-    from: string;
-    to: string;
+    from: Hash;
+    to: Hash;
     weight: number;
 }
 /**
@@ -32,23 +33,23 @@ export declare class CommitOrderCalculator {
     /**
      * Checks for node existence in graph.
      */
-    hasNode(hash: string): boolean;
+    hasNode(hash: Hash): boolean;
     /**
      * Adds a new node to the graph, assigning its hash.
      */
-    addNode(hash: string): void;
+    addNode(hash: Hash): 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;
+    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(): string[];
+    sort(): Hash[];
     /**
      * Visit a given node definition for reordering.
      *
@@ -60,3 +61,4 @@ export declare class CommitOrderCalculator {
      */
     private visitOpenNode;
 }
+export {};

package/unit-of-work/CommitOrderCalculator.js

@@ -17,26 +17,26 @@ export var NodeState;
  */
 export class CommitOrderCalculator {
     /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
-    nodes = {};
+    nodes = new Map();
     /** Volatile variable holding calculated nodes during sorting process. */
     sortedNodeList = [];
     /**
      * Checks for node existence in graph.
      */
     hasNode(hash) {
-        return hash in this.nodes;
+        return this.nodes.has(hash);
     }
     /**
      * Adds a new node to the graph, assigning its hash.
      */
     addNode(hash) {
-        this.nodes[hash] = { hash, state: 0 /* NodeState.NOT_VISITED */, dependencies: {} };
+        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[from].dependencies[to] = { 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;
@@ -44,8 +44,8 @@ export class CommitOrderCalculator {
         if (!toOneOwner && !toManyOwner) {
             return;
         }
-        const propertyType = prop.targetMeta?.root.className;
-        if (!propertyType || !this.hasNode(propertyType)) {
+        const propertyType = prop.targetMeta?.root._id;
+        if (propertyType == null || !this.hasNode(propertyType)) {
             return;
         }
         this.addDependency(propertyType, entityName, prop.nullable || prop.persist === false ? 0 : 1);
@@ -57,14 +57,14 @@ export class CommitOrderCalculator {
      * @internal Highly performance-sensitive method.
      */
     sort() {
-        for (const vertex of Object.values(this.nodes)) {
+        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 = {};
+        this.nodes = new Map();
         this.sortedNodeList = [];
         return sortedList;
     }
@@ -75,8 +75,8 @@ export class CommitOrderCalculator {
      */
     visit(node) {
         node.state = 1 /* NodeState.IN_PROGRESS */;
-        for (const edge of Object.values(node.dependencies)) {
-            const target = this.nodes[edge.to];
+        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 */:
@@ -94,11 +94,11 @@ export class CommitOrderCalculator {
      * 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) {
+        if (!target.dependencies.has(node.hash) || target.dependencies.get(node.hash).weight >= edge.weight) {
             return;
         }
-        for (const edge of Object.values(target.dependencies)) {
-            const targetNode = this.nodes[edge.to];
+        for (const edge of target.dependencies.values()) {
+            const targetNode = this.nodes.get(edge.to);
             if (targetNode.state === 0 /* NodeState.NOT_VISITED */) {
                 this.visit(targetNode);
             }

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

@@ -3,7 +3,14 @@ export declare class IdentityMap {
     private readonly defaultSchema?;
     constructor(defaultSchema?: string | undefined);
     private readonly registry;
+    /** Tracks alternate key hashes for each entity so we can clean them up on delete */
+    private readonly alternateKeys;
     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;
     delete<T>(item: T): void;
     getByHash<T>(meta: EntityMetadata<T>, hash: string): T | undefined;
     getStore<T>(meta: EntityMetadata<T>): Map<string, T>;
@@ -16,4 +23,9 @@ export declare class IdentityMap {
      */
     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

@@ -4,11 +4,38 @@ export class IdentityMap {
         this.defaultSchema = defaultSchema;
     }
     registry = new Map();
+    /** Tracks alternate key hashes for each entity so we can clean them up on delete */
+    alternateKeys = new WeakMap();
     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);
+        }
+        keys.add(hash);
+    }
     delete(item) {
-        this.getStore(item.__meta.root).delete(this.getPkHash(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);
+        }
     }
     getByHash(meta, hash) {
         const store = this.getStore(meta);
@@ -69,4 +96,15 @@ export class IdentityMap {
         }
         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;
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityData, EntityMetadata, 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';
@@ -28,6 +28,12 @@ export declare class UnitOfWork {
     private working;
     constructor(em: EntityManager);
     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
      */
@@ -39,8 +45,21 @@ export declare class UnitOfWork {
     /**
      * 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: string, id: Primary<T> | Primary<T>[], schema?: string): T | undefined;
-    tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
+    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;
+    tryGetById<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.
      */
@@ -103,6 +122,7 @@ export declare class UnitOfWork {
     private commitDeleteChangeSets;
     private commitExtraUpdates;
     private commitCollectionUpdates;
+    private filterCollectionUpdates;
     /**
      * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
      */