@mikro-orm/core 7.0.0-dev.65 → 7.0.0-dev.67

package/EntityManager.js

@@ -627,7 +627,7 @@ export class EntityManager {
         where = await em.processWhere(entityName, where, options, 'read');
         em.validator.validateEmptyWhere(where);
         em.checkLockRequirements(options.lockMode, meta);
-        const isOptimisticLocking = !Utils.isDefined(options.lockMode) || options.lockMode === LockMode.OPTIMISTIC;
+        const isOptimisticLocking = options.lockMode == null || options.lockMode === LockMode.OPTIMISTIC;
         if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
             return em.lockAndPopulate(meta, entity, where, options);
         }
@@ -1711,7 +1711,7 @@ export class EntityManager {
                     options.flags.push(QueryFlag.INFER_POPULATE);
                     return [];
                 }
-                if (Utils.isString(field)) {
+                if (typeof field === 'string') {
                     return [{ field, strategy: options.strategy }];
                 }
                 return [field];
@@ -1818,7 +1818,7 @@ export class EntityManager {
         config ??= this.config.get('resultCache').global;
         if (config) {
             const em = this.getContext();
-            const expiration = Array.isArray(config) ? config[1] : (Utils.isNumber(config) ? config : undefined);
+            const expiration = Array.isArray(config) ? config[1] : (typeof config === 'number' ? config : undefined);
             await em.resultCache.set(key.key, data instanceof Function ? data() : data, '', expiration);
         }
     }

package/entity/Collection.d.ts

@@ -1,5 +1,5 @@
-import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Populate } from '../typings.js';
-import { ArrayCollection } from './ArrayCollection.js';
+import { inspect } from 'node:util';
+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 { CountOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
@@ -9,10 +9,18 @@ export interface MatchingOptions<T extends object, P extends string = never> ext
     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)
@@ -41,57 +49,117 @@ export declare class Collection<T extends object, O extends object = object> ext
     toJSON<TT extends T>(): EntityDTO<TT>[];
     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>)[]): 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;
+    /** @ignore */
+    [inspect.custom](depth?: number): string;
 }
 export interface InitCollectionOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends EntityLoaderOptions<T, F, E> {
     dataloader?: boolean;