@rentman/rm-core 2.0.6 → 2.0.7

package/dist/src/classes/cache/AbstractCache.d.ts

@@ -1,134 +1,135 @@
-import { RmCore } from '../../core';
-import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../factories';
-import { ChangesDeltaFactory } from '../../factories/ChangesDeltaFactory';
-import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
-import { LinkTreeServiceInterface } from '../../interfaces/LinkTreeServiceInterface';
-import { CollectionEntry, ItemEntry } from '../../models';
-import { EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../types';
-import { ApiFormatter } from '../ApiFormatter';
-import { ApiRequestService } from '../ApiRequestService';
-import { ChangesDelta } from '../ChangesDelta';
-import { ChangesDeltaResult } from '../ChangesDeltaBase';
-import { OnAfterCreateCallback } from '../ChangesProcessor';
-import { CollectionCache } from '../CollectionCache';
-import { CollectionEntryService } from '../CollectionEntryService';
-import { ColumnCache } from '../ColumnCache';
-import { ColumnHandler } from '../ColumnHandler';
-import { ColumnUtil } from '../ColumnUtil';
-import { InternalChangesDelta } from '../InternalChangesDelta';
-import { ItemCache } from '../ItemCache';
-import { ItemEntryService } from '../ItemEntryService';
-import { KeyService } from '../KeyService';
-import { LockService } from '../LockService';
-import { QueryService } from '../QueryService';
-import { RequestBufferManager } from '../RequestBufferManager';
-import { TemplateCache } from '../TemplateCache';
-import { ServerCache } from './server/ServerCache';
-import { ServerCollectionHandler } from './server/ServerCollectionHandler';
-import { ServerItemEntryChanges, ServerItemHandler } from './server/ServerItemHandler';
-import { TransactionCache } from './transaction/TransactionCache';
-import { TransactionCollectionHandler } from './transaction/TransactionCollectionHandler';
-import { TransactionItemEntryChanges, TransactionItemHandler } from './transaction/TransactionItemHandler';
-export declare abstract class AbstractCache {
-    core: RmCore;
-    protected columnCache: ColumnCache;
-    protected requestBufferManager: RequestBufferManager;
-    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    protected queryMatcherFactory: QueryMatcherFactory;
-    protected authInterface: AuthInterface;
-    protected changesDeltaFactory: ChangesDeltaFactory;
-    protected lockService: LockService;
-    protected moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
-    protected collectionResourceFactory: CollectionResourceFactory;
-    protected itemResourceFactory: ItemResourceFactory;
-    protected templateCache: TemplateCache;
-    protected itemCacheFactory: ItemCacheFactory;
-    protected collectionCacheFactory: CollectionCacheFactory;
-    protected errorHandler: ErrorHandlerInterface;
-    protected exceptionHandler: ExceptionHandlerInterface;
-    protected promiseService: PromiseLibraryInterface;
-    protected apiRequestService: ApiRequestService;
-    protected columnExpansionFactory: ColumnExpansionFactory;
-    protected columnHandler: ColumnHandler;
-    protected columnSetFactory: ColumnSetFactory;
-    protected columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    protected columnUtil: ColumnUtil;
-    protected itemEntryFactory: ItemEntryFactory;
-    protected itemEntryService: ItemEntryService;
-    protected keyService: KeyService;
-    protected collectionEntryFactory: CollectionEntryFactory;
-    protected collectionEntryService: CollectionEntryService;
-    protected collectionMatcherFactory: CollectionMatcherFactory;
-    protected queryParserFactory: QueryParserFactory;
-    protected queryService: QueryService;
-    protected apiFormatter: ApiFormatter;
-    protected linkTreeService: LinkTreeServiceInterface;
-    children: TransactionCache[];
-    readonly itemHandler: TransactionItemHandler | ServerItemHandler;
-    readonly collectionHandler: TransactionCollectionHandler | ServerCollectionHandler;
-    parent: AbstractCache | null;
-    protected constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface);
-    createChild(id?: string): TransactionCache;
-    onChildDestroy(cache: TransactionCache): void;
-    /**
-     * @description
-     * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction
-     */
-    getCurrentCollectionEntryCache(): CollectionCache;
-    /**
-     * @description
-     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
-     */
-    getCurrentItemEntryCache(): ItemCache;
-    abstract getServerCache(): ServerCache;
-    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    abstract getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    abstract getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
-    /**
-     * @description
-     * Applies changes from a child transaction to a parent
-     */
-    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
-    /**
-     * @description
-     * Called by a parent transaction, propagates changes downwards to all child caches
-     *
-     * @remarks
-     * - Should only be used by the core
-     *
-     * todo[cache] Should we refetch derived values just like in applyChangesDelta ?
-     *
-     * @internal
-     */
-    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
-    abstract getParent(itemEntry: ItemEntry, fromInitial?: boolean): EntryParentNull;
-    abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
-    abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
-    /**
-     * @description
-     * Because the `itemChanges` object differs between the {@link ServerItemHandler.itemChanges ServerItemHandler} and the {@link TransactionItemHandler.itemChanges TransactionItemHandler} we need a function to normalise those values
-     *
-     * @remarks
-     * - Should only be used by the core
-     *
-     * @internal
-     */
-    abstract getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
-    abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
-    /**
-     * @description
-     * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
-     *
-     * @private
-     */
-    protected _applyChangesDelta(changesDelta: ChangesDelta): {
-        result: ChangesDeltaResult;
-        internalChangesDelta: InternalChangesDelta;
-        rollbackFunctions: Array<(changesDelta: ChangesDelta) => void>;
-    };
-    /**
-     * @description
-     * Ensures that for all updated items in the delta the required derived values are present
-     */
-    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDelta): PromiseInterface<ItemEntry[][]>;
-}
+import { RmCore } from '../../core';
+import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../factories';
+import { ChangesDeltaFactory } from '../../factories/ChangesDeltaFactory';
+import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
+import { LinkTreeServiceInterface } from '../../interfaces/LinkTreeServiceInterface';
+import { CollectionEntry, ItemEntry } from '../../models';
+import { EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../types';
+import { ApiFormatter } from '../ApiFormatter';
+import { ApiRequestService } from '../ApiRequestService';
+import { ChangesDelta } from '../ChangesDelta';
+import { ChangesDeltaResult } from '../ChangesDeltaBase';
+import { OnAfterCreateCallback } from '../ChangesProcessor';
+import { CollectionCache } from '../CollectionCache';
+import { CollectionEntryService } from '../CollectionEntryService';
+import { ColumnCache } from '../ColumnCache';
+import { ColumnHandler } from '../ColumnHandler';
+import { ColumnUtil } from '../ColumnUtil';
+import { InternalChangesDelta } from '../InternalChangesDelta';
+import { ItemCache } from '../ItemCache';
+import { ItemEntryService } from '../ItemEntryService';
+import { KeyService } from '../KeyService';
+import { LockService } from '../LockService';
+import { QueryService } from '../QueryService';
+import { RequestBufferManager } from '../RequestBufferManager';
+import { TemplateCache } from '../TemplateCache';
+import { ServerCache } from './server/ServerCache';
+import { ServerCollectionHandler } from './server/ServerCollectionHandler';
+import { ServerItemEntryChanges, ServerItemHandler } from './server/ServerItemHandler';
+import { TransactionCache } from './transaction/TransactionCache';
+import { TransactionCollectionHandler } from './transaction/TransactionCollectionHandler';
+import { TransactionItemEntryChanges, TransactionItemHandler } from './transaction/TransactionItemHandler';
+export declare abstract class AbstractCache {
+    core: RmCore;
+    protected columnCache: ColumnCache;
+    protected requestBufferManager: RequestBufferManager;
+    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    protected queryMatcherFactory: QueryMatcherFactory;
+    protected authInterface: AuthInterface;
+    protected changesDeltaFactory: ChangesDeltaFactory;
+    protected lockService: LockService;
+    protected moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    protected collectionResourceFactory: CollectionResourceFactory;
+    protected itemResourceFactory: ItemResourceFactory;
+    protected templateCache: TemplateCache;
+    protected itemCacheFactory: ItemCacheFactory;
+    protected collectionCacheFactory: CollectionCacheFactory;
+    protected errorHandler: ErrorHandlerInterface;
+    protected exceptionHandler: ExceptionHandlerInterface;
+    protected promiseService: PromiseLibraryInterface;
+    protected apiRequestService: ApiRequestService;
+    protected columnExpansionFactory: ColumnExpansionFactory;
+    protected columnHandler: ColumnHandler;
+    protected columnSetFactory: ColumnSetFactory;
+    protected columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    protected columnUtil: ColumnUtil;
+    protected itemEntryFactory: ItemEntryFactory;
+    protected itemEntryService: ItemEntryService;
+    protected keyService: KeyService;
+    protected collectionEntryFactory: CollectionEntryFactory;
+    protected collectionEntryService: CollectionEntryService;
+    protected collectionMatcherFactory: CollectionMatcherFactory;
+    protected queryParserFactory: QueryParserFactory;
+    protected queryService: QueryService;
+    protected apiFormatter: ApiFormatter;
+    protected linkTreeService: LinkTreeServiceInterface;
+    children: TransactionCache[];
+    readonly itemHandler: TransactionItemHandler | ServerItemHandler;
+    readonly collectionHandler: TransactionCollectionHandler | ServerCollectionHandler;
+    parent: AbstractCache | null;
+    protected constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface);
+    createChild(id?: string): TransactionCache;
+    onChildDestroy(cache: TransactionCache): void;
+    /**
+     * @description
+     * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction
+     */
+    getCurrentCollectionEntryCache(): CollectionCache;
+    /**
+     * @description
+     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
+     */
+    getCurrentItemEntryCache(): ItemCache;
+    abstract getServerCache(): ServerCache;
+    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    abstract getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    abstract getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
+    /**
+     * @description
+     * Applies changes from a child transaction to a parent
+     */
+    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
+    /**
+     * @description
+     * Called by a parent transaction, propagates changes downwards to all child caches
+     *
+     * @remarks
+     * - Should only be used by the core
+     *
+     * todo[cache] Should we refetch derived values just like in applyChangesDelta ?
+     *
+     * @internal
+     */
+    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
+    abstract getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
+    abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
+    /**
+     * @description
+     * Because the `itemChanges` object differs between the {@link ServerItemHandler.itemChanges ServerItemHandler} and the {@link TransactionItemHandler.itemChanges TransactionItemHandler} we need a function to normalise those values
+     *
+     * @remarks
+     * - Should only be used by the core
+     *
+     * @internal
+     */
+    abstract getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+    abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    protected getParentFromFields<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParentNull;
+    /**
+     * @description
+     * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
+     *
+     * @private
+     */
+    protected _applyChangesDelta(changesDelta: ChangesDelta): {
+        result: ChangesDeltaResult;
+        internalChangesDelta: InternalChangesDelta;
+        rollbackFunctions: Array<(changesDelta: ChangesDelta) => void>;
+    };
+    /**
+     * @description
+     * Ensures that for all updated items in the delta the required derived values are present
+     */
+    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDelta): PromiseInterface<ItemEntry[][]>;
+}

package/dist/src/classes/cache/CollectionHandlerBase.d.ts

@@ -1,64 +1,64 @@
-import { CollectionCacheFactory, RequestColumnExpansionFactory } from '../../factories';
-import { CollectionEntry, CollectionEntryOptions, ItemEntry } from '../../models';
-import { ApiQuery, ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, PromiseInterface, QueryCallback } from '../../types';
-import { CollectionCache } from '../CollectionCache';
-import { CollectionEntryService } from '../CollectionEntryService';
-import { CollectionMatcher } from '../CollectionMatcher';
-import { ColumnUtil } from '../ColumnUtil';
-import { AbstractCache } from './AbstractCache';
-export declare abstract class CollectionHandlerBase {
-    protected collectionEntryService: CollectionEntryService;
-    protected columnUtil: ColumnUtil;
-    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    protected transaction: AbstractCache;
-    entries: CollectionCache;
-    collectionChanges: {
-        [collectionEntryId: number]: ItemEntry[];
-    };
-    protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionCacheFactory: CollectionCacheFactory, transaction: AbstractCache);
-    /**
-     * @description
-     * Creates a new {@link CollectionEntry CollectionEntry} and stores it in this transaction's {@link CollectionCache CollectionCache}
-     */
-    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
-    /**
-     * @description
-     * Creates a {@link CollectionMatcher CollectionMatcher} with the transaction's collections
-     */
-    abstract getCollectionMatcher(): CollectionMatcher;
-    /**
-     * @description
-     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
-     */
-    abstract fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches collections linked to the passed parents
-     */
-    abstract fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
-    /**
-     * @description
-     * Expands the items in the collections with the passed columns
-     */
-    abstract expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    /**
-     * @description
-     * Extends the collections' {@link CollectionEntry.queryParams queryParams} and {@link CollectionEntry.query queries} and fetches the {@link ItemEntry ItemEntries} with the new queries
-     */
-    abstract extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    /**
-     * @description
-     * Adds the passed {@link ItemEntry ItemEntries} to the collection's changes on the transaction,
-     * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
-     */
-    protected _addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean, isCalledAfterSocketUpdate: boolean): void;
-    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
-    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[], isCalledAfterSocketUpdate?: boolean): void | never[];
-    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
-    /**
-     * @description
-     * Expands the option's {@link CollectionEntryOptions.columns columns} with the columns required for the {@link CollectionMatcher CollectionMatcher} to function.
-     * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionEntryOptions.queryColumns queryColumns} should also be taken into account
-     */
-    protected expandColumnsWithQueryColumns(itemType: ItemType, options: CollectionEntryOptions, query?: ApiQuery): void;
-}
+import { CollectionCacheFactory, RequestColumnExpansionFactory } from '../../factories';
+import { CollectionEntry, CollectionEntryOptions, ItemEntry } from '../../models';
+import { ApiQuery, ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, PromiseInterface, QueryCallback } from '../../types';
+import { CollectionCache } from '../CollectionCache';
+import { CollectionEntryService } from '../CollectionEntryService';
+import { CollectionMatcher } from '../CollectionMatcher';
+import { ColumnUtil } from '../ColumnUtil';
+import { AbstractCache } from './AbstractCache';
+export declare abstract class CollectionHandlerBase {
+    protected collectionEntryService: CollectionEntryService;
+    protected columnUtil: ColumnUtil;
+    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    protected transaction: AbstractCache;
+    entries: CollectionCache;
+    collectionChanges: {
+        [collectionEntryId: number]: ItemEntry[];
+    };
+    protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionCacheFactory: CollectionCacheFactory, transaction: AbstractCache);
+    /**
+     * @description
+     * Creates a new {@link CollectionEntry CollectionEntry} and stores it in this transaction's {@link CollectionCache CollectionCache}
+     */
+    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
+    /**
+     * @description
+     * Creates a {@link CollectionMatcher CollectionMatcher} with the transaction's collections
+     */
+    abstract getCollectionMatcher(): CollectionMatcher;
+    /**
+     * @description
+     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
+     */
+    abstract fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     */
+    abstract fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
+    /**
+     * @description
+     * Expands the items in the collections with the passed columns
+     */
+    abstract expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    /**
+     * @description
+     * Extends the collections' {@link CollectionEntry.queryParams queryParams} and {@link CollectionEntry.query queries} and fetches the {@link ItemEntry ItemEntries} with the new queries
+     */
+    abstract extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
+    /**
+     * @description
+     * Adds the passed {@link ItemEntry ItemEntries} to the collection's changes on the transaction,
+     * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
+     */
+    protected _addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean, isCalledAfterSocketUpdate: boolean): void;
+    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
+    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[], isCalledAfterSocketUpdate?: boolean): void | never[];
+    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
+    /**
+     * @description
+     * Expands the option's {@link CollectionEntryOptions.columns columns} with the columns required for the {@link CollectionMatcher CollectionMatcher} to function.
+     * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionEntryOptions.queryColumns queryColumns} should also be taken into account
+     */
+    protected expandColumnsWithQueryColumns(itemType: ItemType, options: CollectionEntryOptions, query?: ApiQuery): void;
+}

package/dist/src/classes/cache/CollectionMatcherCacheProcessor.d.ts

@@ -1,26 +1,26 @@
-import { QueryMatcherFactory } from '../../factories';
-import { CollectionEntry, ItemEntry } from '../../models';
-import { ItemId, ItemType } from '../../types';
-import { ApiRequestService } from '../ApiRequestService';
-import { CollectionMatcher } from '../CollectionMatcher';
-import { AbstractCache } from './AbstractCache';
-export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
-    fitting: Array<ItemEntry<ItemTypeType>>;
-    notFitting: ItemId[];
-    maybe: Array<ItemEntry<ItemTypeType>>;
-};
-/**
- * @description
- * Processes a delta and adds the items to the right collections, this is the ONLY class that should change collection items
- *
- * ------
- *
- * @remark
- * The CollectionMatcherCacheProcessor is allowed to directly access/modify the transaction because it's ONLY called from applyChangesFromParent
- */
-export declare class CollectionMatcherCacheProcessor extends CollectionMatcher {
-    private apiRequestService;
-    constructor(apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
-    removeFromAndAddToCollections(isCalledAfterSocketUpdate?: boolean): void;
-    private groupItemEntries;
-}
+import { QueryMatcherFactory } from '../../factories';
+import { CollectionEntry, ItemEntry } from '../../models';
+import { ItemId, ItemType } from '../../types';
+import { ApiRequestService } from '../ApiRequestService';
+import { CollectionMatcher } from '../CollectionMatcher';
+import { AbstractCache } from './AbstractCache';
+export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
+    fitting: Array<ItemEntry<ItemTypeType>>;
+    notFitting: ItemId[];
+    maybe: Array<ItemEntry<ItemTypeType>>;
+};
+/**
+ * @description
+ * Processes a delta and adds the items to the right collections, this is the ONLY class that should change collection items
+ *
+ * ------
+ *
+ * @remark
+ * The CollectionMatcherCacheProcessor is allowed to directly access/modify the transaction because it's ONLY called from applyChangesFromParent
+ */
+export declare class CollectionMatcherCacheProcessor extends CollectionMatcher {
+    private apiRequestService;
+    constructor(apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
+    removeFromAndAddToCollections(isCalledAfterSocketUpdate?: boolean): void;
+    private groupItemEntries;
+}