@mikro-orm/core 7.0.0-dev.9 → 7.0.0-dev.90

package/connections/Connection.js

@@ -1,4 +1,3 @@
-import { URL } from 'node:url';
 import { Utils } from '../utils/Utils.js';
 export class Connection {
     config;
@@ -33,23 +32,35 @@ export class Connection {
             .forEach(k => delete this.options[k]);
     }
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     async ensureConnection() {
         if (!this.connected) {
             await this.connect();
         }
     }
+    async onConnect() {
+        const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        if (this.type === 'write' && schemaGenerator) {
+            if (this.config.get('ensureDatabase')) {
+                const options = this.config.get('ensureDatabase');
+                await schemaGenerator.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+            }
+            if (this.config.get('ensureIndexes')) {
+                await schemaGenerator.ensureIndexes();
+            }
+        }
+    }
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
     async begin(options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async commit(ctx, eventBroadcaster) {
+    async commit(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async rollback(ctx, eventBroadcaster) {
+    async rollback(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
     getConnectionOptions() {
@@ -67,7 +78,7 @@ export class Connection {
             }
         }
         else {
-            const url = new URL(this.config.getClientUrl());
+            const url = new URL(this.config.get('clientUrl'));
             this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
             this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
             this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
@@ -76,15 +87,6 @@ export class Connection {
         }
         return ret;
     }
-    getClientUrl() {
-        const options = this.getConnectionOptions();
-        const url = new URL(this.config.getClientUrl(true));
-        const password = options.password ? ':*****' : '';
-        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
-            ? `?schema=${options.schema}`
-            : '';
-        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
-    }
     setMetadata(metadata) {
         this.metadata = metadata;
     }

package/drivers/DatabaseDriver.d.ts

@@ -1,5 +1,5 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type StreamOptions } from './IDatabaseDriver.js';
+import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
@@ -30,20 +30,25 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
-    connect(): Promise<C>;
-    reconnect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     close(force?: boolean): Promise<void>;
     getPlatform(): Platform;
     setMetadata(metadata: MetadataStorage): void;
     getMetadata(): MetadataStorage;
     getDependencies(): string[];
+    protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;
@@ -55,6 +60,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected getPrimaryKeyFields(entityName: string): string[];
     protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    abstract stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     /**
      * @inheritDoc
      */

package/drivers/DatabaseDriver.js

@@ -31,11 +31,11 @@ export class DatabaseDriver {
         const EntityManagerClass = this.config.get('entityManager', EntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     async findVirtual(entityName, where, options) {
         throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     async countVirtual(entityName, where, options) {
         throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
     }
@@ -47,16 +47,19 @@ export class DatabaseDriver {
     }
     async syncCollections(collections, options) {
         for (const coll of collections) {
+            /* v8 ignore else */
             if (!coll.property.owner) {
                 if (coll.getSnapshot() === undefined) {
                     throw ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
                 }
                 continue;
             }
-            /* v8 ignore next 3 */
-            const pk = coll.property.targetMeta.primaryKeys[0];
-            const data = { [coll.property.name]: coll.getIdentifiers(pk) };
-            await this.nativeUpdate(coll.owner.constructor.name, helper(coll.owner).getPrimaryKey(), data, options);
+            /* v8 ignore next */
+            {
+                const pk = coll.property.targetMeta.primaryKeys[0];
+                const data = { [coll.property.name]: coll.getIdentifiers(pk) };
+                await this.nativeUpdate(coll.owner.constructor.name, helper(coll.owner).getPrimaryKey(), data, options);
+            }
         }
     }
     mapResult(result, meta, populate = []) {
@@ -65,14 +68,14 @@ export class DatabaseDriver {
         }
         return this.comparator.mapResult(meta.className, result);
     }
-    async connect() {
-        await this.connection.connect();
+    async connect(options) {
+        await this.connection.connect(options);
         await Promise.all(this.replicas.map(replica => replica.connect()));
         return this.connection;
     }
-    async reconnect() {
+    async reconnect(options) {
         await this.close(true);
-        await this.connect();
+        await this.connect(options);
         return this.connection;
     }
     getConnection(type = 'write') {
@@ -105,6 +108,15 @@ export class DatabaseDriver {
     getDependencies() {
         return this.dependencies;
     }
+    isPopulated(meta, prop, hint, name) {
+        if (hint.field === prop.name || hint.field === name || hint.all) {
+            return true;
+        }
+        if (prop.embedded && hint.children && meta.properties[prop.embedded[0]].name === hint.field) {
+            return hint.children.some(c => this.isPopulated(meta, prop, c, prop.embedded[1]));
+        }
+        return false;
+    }
     processCursorOptions(meta, options, orderBy) {
         const { first, last, before, after, overfetch } = options;
         const limit = first ?? last;
@@ -244,7 +256,7 @@ export class DatabaseDriver {
         return data;
     }
     inlineEmbeddables(meta, data, where) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (data == null) {
             return;
         }

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings.js';
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -14,9 +14,13 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    connect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     close(force?: boolean): Promise<void>;
-    reconnect(): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     /**
      * Finds selection of entities
@@ -27,6 +31,7 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      */
     findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
@@ -68,6 +73,18 @@ export type OrderDefinition<T> = (QueryOrderMap<T> & {
 export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
+export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
+    /**
+     * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
+     * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
+     * the SQL result, but still mapped to entities, meaning that to-many collections will contain at most
+     * a single item, and you will get duplicate root entities when they have multiple items in the populated
+     * collection.
+     *
+     * @default true
+     */
+    mergeResults?: boolean;
+}
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
 export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
@@ -152,7 +169,7 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
 export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
     includeCount?: I;
 }
-export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }
@@ -166,6 +183,7 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -200,6 +218,8 @@ export interface CountOptions<T extends object, P extends string = never> {
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
@@ -221,6 +241,7 @@ export interface LockOptions extends DriverMethodOptions {
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
+    loggerContext?: LogContext;
 }
 export interface GetReferenceOptions {
     wrapped?: boolean;

package/entity/BaseEntity.d.ts

@@ -6,7 +6,6 @@ import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions } from '../drivers/IDatabaseDriver.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
-    isTouched(): boolean;
     populated(populated?: boolean): void;
     populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;

package/entity/BaseEntity.js

@@ -6,9 +6,6 @@ export class BaseEntity {
     isInitialized() {
         return helper(this).__initialized;
     }
-    isTouched() {
-        return helper(this).__touched;
-    }
     populated(populated = true) {
         helper(this).populated(populated);
     }

package/entity/Collection.d.ts

@@ -1,18 +1,25 @@
-import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Populate } from '../typings.js';
-import { ArrayCollection } from './ArrayCollection.js';
+import type { EntityDTO, EntityKey, EntityProperty, FilterQuery, IPrimaryKey, Loaded, LoadedCollection, Populate, Primary } from '../typings.js';
 import { Reference } from './Reference.js';
 import type { Transaction } from '../connections/Connection.js';
-import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver.js';
+import type { CountOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 export interface MatchingOptions<T extends object, P extends string = never> extends FindOptions<T, P> {
     where?: FilterQuery<T>;
     store?: boolean;
     ctx?: Transaction;
 }
-export declare class Collection<T extends object, O extends object = object> extends ArrayCollection<T, O> {
+export declare class Collection<T extends object, O extends object = object> {
+    readonly owner: O;
+    [k: number]: T;
+    protected readonly items: Set<T>;
+    protected initialized: boolean;
+    protected dirty: boolean;
+    protected partial: boolean;
+    protected snapshot: T[] | undefined;
     private readonly?;
+    protected _count?: number;
+    private _property?;
     private _populated?;
-    private _snapshot?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
@@ -39,59 +46,117 @@ export declare class Collection<T extends object, O extends object = object> ext
      */
     getItems(check?: boolean): T[];
     toJSON<TT extends T>(): EntityDTO<TT>[];
-    add<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): void;
+    add<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): number;
     /**
-     * @inheritDoc
+     * Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity,
+     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
+     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
+     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
      */
-    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): void;
+    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): number;
     contains<TT extends T>(item: TT | Reference<TT>, check?: boolean): boolean;
     count(): number;
     isEmpty(): boolean;
+    shouldPopulate(populated?: boolean): boolean;
+    populated(populated?: boolean | undefined): void;
+    init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
+    private getEntityManager;
+    private createCondition;
+    private createOrderBy;
+    private createManyToManyCondition;
+    private createLoadCountCondition;
+    private checkInitialized;
+    /**
+     * re-orders items after searching with `$in` operator
+     */
+    private reorderItems;
+    private cancelOrphanRemoval;
+    private validateModification;
+    toArray<TT extends T>(): EntityDTO<TT>[];
+    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
+    /**
+     * @internal
+     */
+    addWithoutPropagation(entity: T): void;
+    set(items: Iterable<T | Reference<T>>): void;
+    private compare;
+    /**
+     * @internal
+     */
+    hydrate(items: T[], forcePropagate?: boolean, partial?: boolean): void;
+    /**
+     * Remove all items from the collection. Note that removing items from collection does not necessarily imply deleting the target entity,
+     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
+     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
+     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
+     */
+    removeAll(): void;
+    /**
+     * @internal
+     */
+    removeWithoutPropagation(entity: T): void;
     /**
-     * @inheritDoc
+     * Extracts a slice of the collection items starting at position start to end (exclusive) of the collection.
+     * If end is null it returns all elements from start to the end of the collection.
      */
     slice(start?: number, end?: number): T[];
     /**
-     * @inheritDoc
+     * Tests for the existence of an element that satisfies the given predicate.
      */
     exists(cb: (item: T) => boolean): boolean;
     /**
-     * @inheritDoc
+     * Returns the first element of this collection that satisfies the predicate.
      */
     find(cb: (item: T, index: number) => boolean): T | undefined;
     /**
-     * @inheritDoc
+     * Extracts a subset of the collection items.
      */
     filter(cb: (item: T, index: number) => boolean): T[];
     /**
-     * @inheritDoc
+     * Maps the collection items based on your provided mapper function.
      */
     map<R>(mapper: (item: T, index: number) => R): R[];
     /**
-     * @inheritDoc
+     * Maps the collection items based on your provided mapper function to a single object.
+     */
+    reduce<R>(cb: (obj: R, item: T, index: number) => R, initial?: R): R;
+    /**
+     * Maps the collection items to a dictionary, indexed by the key you specify.
+     * If there are more items with the same key, only the first one will be present.
      */
     indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1): Record<T[K1] & PropertyKey, T>;
     /**
-     * @inheritDoc
+     * Maps the collection items to a dictionary, indexed by the key you specify.
+     * If there are more items with the same key, only the first one will be present.
      */
     indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1, valueKey: K2): Record<T[K1] & PropertyKey, T[K2]>;
-    shouldPopulate(populated?: boolean): boolean;
-    populated(populated?: boolean | undefined): void;
-    init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
-    private getEntityManager;
-    private createCondition;
-    private createOrderBy;
-    private createManyToManyCondition;
-    private createLoadCountCondition;
-    private modify;
-    private checkInitialized;
+    isInitialized(fully?: boolean): boolean;
+    isDirty(): boolean;
+    isPartial(): boolean;
+    setDirty(dirty?: boolean): void;
+    get length(): number;
+    [Symbol.iterator](): IterableIterator<T>;
     /**
-     * re-orders items after searching with `$in` operator
+     * @internal
      */
-    private reorderItems;
-    private cancelOrphanRemoval;
-    private validateItemType;
-    private validateModification;
+    takeSnapshot(forcePropagate?: boolean): void;
+    /**
+     * @internal
+     */
+    getSnapshot(): T[] | undefined;
+    /**
+     * @internal
+     */
+    get property(): EntityProperty;
+    /**
+     * @internal
+     */
+    set property(prop: EntityProperty);
+    protected propagate(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
+    protected propagateToInverseSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
+    protected propagateToOwningSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
+    protected shouldPropagateToCollection(collection: Collection<O, T>, method: 'add' | 'remove' | 'takeSnapshot'): boolean;
+    protected incrementCount(value: number): void;
 }
 export interface InitCollectionOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends EntityLoaderOptions<T, F, E> {
     dataloader?: boolean;