@rentman/rm-core 1.9.0 → 2.0.0

package/dist/src/classes/LockService.d.ts

@@ -1,7 +1,7 @@
-import { KeyService } from '../classes';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestService, KeyService } from '../classes';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } from '../models';
-import { ItemId, ItemMap, PromiseInterface } from '../types';
+import { ItemId, PromiseInterface } from '../types';
 export declare type LockToken = {
     isForeign: false;
     id: number;
@@ -15,12 +15,10 @@ export declare class LockService {
     private errorHandler;
     private keyService;
     private promiseService;
-    lockItems: ItemMap<LockToken>;
-    promises: ItemMap<PromiseInterface<LockToken>>;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    private getValue;
-    private setValue;
-    getLocks(): this['lockItems'];
+    private lockItems;
+    private promises;
+    constructor(apiRequestService: ApiRequestService, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    getLocks(): LockService['lockItems'];
     hasLock(lockTokenId: ItemId): boolean;
     isLocked(itemEntry: ItemEntry<any>): boolean;
     getMessage(itemEntry: ItemEntry<any>): undefined | string;
@@ -29,4 +27,6 @@ export declare class LockService {
     requestLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
     deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
     clearLock(itemEntry: ItemEntry<any>): boolean;
+    private getValue;
+    private setValue;
 }

package/dist/src/classes/ModuleChangesCompilation.d.ts

@@ -1,18 +1,15 @@
-import { CollectionCache, ItemCache } from '../classes';
-import { ItemEntry } from '../models';
 import { ApiRequestItemMap, ItemId, ItemType } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
 export declare type ModuleChangesCompilationResult = {
     itemType: ItemType;
     itemId: ItemId;
     items: ApiRequestItemMap;
 };
-export declare class ModuleChangesCompilation<RootItemEntryItemTypeType extends ItemType> {
-    private rootItemEntry;
-    private singleItemCache;
-    private collectionCache;
+export declare class ModuleChangesCompilation {
+    private transaction;
     parentMap: any;
     destination: ApiRequestItemMap;
-    constructor(rootItemEntry: ItemEntry<RootItemEntryItemTypeType>, singleItemCache: ItemCache, collectionCache: CollectionCache);
+    constructor(transaction: TransactionCache);
     process(): ModuleChangesCompilationResult;
     private createParentMap;
     private processItems;

package/dist/src/classes/QueryColumnExtractor.d.ts

@@ -0,0 +1,20 @@
+import { ApiQuery, ApiRequestColumn, ItemType } from '../types';
+import { ColumnUtil } from './ColumnUtil';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryColumnExtractor extends QueryParserBase<ApiRequestColumn[]> {
+    private columnUtil;
+    private itemType;
+    constructor(columnUtil: ColumnUtil, itemType: ItemType, query: ApiQuery);
+    protected parseEmptyQuery(): never[];
+    protected parseSubQuery(key: string, subQuery: object, _not?: boolean): {
+        [x: string]: ApiRequestColumn[];
+    }[];
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): never[];
+    protected parseSearchQuery(_value: any, _not: boolean): never[];
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): never[];
+    protected parseSimpleQuery(key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): string[];
+    protected parseLinkedToQuery(linkedTo: any, _query?: ApiQuery, _reverse?: boolean, _not?: boolean): ApiRequestColumn[];
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): any;
+    private parseConditions;
+}

package/dist/src/classes/QueryParser.d.ts

@@ -1,34 +1,25 @@
 import { ApiQuery } from '../types';
-export declare enum OPERATORS {
-    OR = "OR",
-    AND = "AND"
-}
-export declare type OPERATORS_TYPE = 'OR' | 'AND' | 'or' | 'and' | OPERATORS;
-export declare enum COMPARATORS {
-    EQUALS = "=",
-    NOT_EQUALS = "!=",
-    LESS_THAN = "<",
-    MORE_THAN = ">",
-    LESS_OR_EQUAL_THAN = "<=",
-    EQUAL_OR_MORE_THAN = ">=",
-    IN = "IN"
+import { COMPARATORS, OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare enum CONSTANTS {
+    OBJ = 0,
+    STR = 1,
+    SEP = ":"
 }
 export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
-export declare class QueryParser {
-    query: ApiQuery;
-    parameters: any;
-    constructor(query: ApiQuery, parameters?: object);
-    private compareParsedQueries;
-    parse(query?: ApiQuery): [object, string];
-    private parseSubQuery;
-    private parseSubFieldQuery;
-    private parseSearchQuery;
-    private parseCustomQuery;
-    private parseCustomParameters;
-    private parseSimpleQuery;
-    private parseLinkedToQuery;
-    private parseComplexQuery;
+export declare class QueryParser extends QueryParserBase<[object, string]> {
+    private parameters;
+    constructor(query: ApiQuery, parameters: object);
+    protected parseEmptyQuery(): [object, string];
+    protected parseSubQuery(key: string, subQuery: object, not?: boolean): [object, string];
+    protected parseSubFieldQuery(key: string | undefined, itemType: string | undefined, field: string | undefined, query: ApiQuery, not?: boolean): [object, string];
+    protected parseSearchQuery(value: any, not?: boolean): [object, string];
+    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): [object, string];
+    protected parseCustomParameters(parameters: any): [object, string];
+    protected parseSimpleQuery(key: string, value: any, comparator?: COMPARATORS_TYPE, not?: boolean): [object, string];
+    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): [object, string];
+    protected parseComplexQuery(conditions: any[], operator?: OPERATORS_TYPE, not?: boolean): [object, string];
     private parseConditions;
     private formatValue;
     private processValue;
+    private compareParsedQueries;
 }

package/dist/src/classes/QueryParserBase.d.ts

@@ -0,0 +1,29 @@
+import { ApiQuery, ItemType } from '../types';
+export declare enum OPERATORS {
+    OR = "OR",
+    AND = "AND"
+}
+export declare type OPERATORS_TYPE = 'OR' | 'AND' | 'or' | 'and' | OPERATORS;
+export declare enum COMPARATORS {
+    EQUALS = "=",
+    NOT_EQUALS = "!=",
+    LESS_THAN = "<",
+    MORE_THAN = ">",
+    LESS_OR_EQUAL_THAN = "<=",
+    EQUAL_OR_MORE_THAN = ">=",
+    IN = "IN"
+}
+export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
+export declare abstract class QueryParserBase<ReturnType extends any> {
+    protected query: ApiQuery;
+    protected constructor(query: ApiQuery);
+    parse(query?: ApiQuery): ReturnType;
+    protected abstract parseEmptyQuery(): ReturnType;
+    protected abstract parseSubQuery(key: string, subQuery: object, not: boolean): ReturnType;
+    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean): ReturnType;
+    protected abstract parseSearchQuery(value: any, not: boolean): ReturnType;
+    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean): ReturnType;
+    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not?: boolean): ReturnType;
+    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean): ReturnType;
+    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean): ReturnType;
+}

package/dist/src/classes/QueryService.d.ts

@@ -1,5 +1,5 @@
 import { ApiQuery, EntryParentNull, ItemId } from '../types';
-import { COMPARATORS } from './QueryParser';
+import { COMPARATORS } from './QueryParserBase';
 export declare class QueryService {
     constructor();
     addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;

package/dist/src/classes/RequestBuffer.d.ts

@@ -0,0 +1,25 @@
+import { RequestColumnExpansionFactory } from '../factories';
+import { PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ApiResponseProcessor } from './ApiResponseProcessor';
+import { ServerCache } from './cache/server/ServerCache';
+export declare type RequestBufferResponse = ApiResponseProcessor;
+export declare class RequestBuffer {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private serverCache;
+    private itemType;
+    private deferred;
+    private requestColumnExpansion;
+    private singleItemIds;
+    private queries;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, serverCache: ServerCache, itemType: ItemType);
+    containsId(itemId: ItemId): boolean;
+    containsQuery(queryString: string): boolean;
+    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    flush(): PromiseInterface<RequestBufferResponse>;
+    getPromise(): PromiseInterface<RequestBufferResponse>;
+}

package/dist/src/classes/RequestBufferManager.d.ts

@@ -0,0 +1,31 @@
+import { RequestColumnExpansionFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ApiResponseProcessor } from './ApiResponseProcessor';
+import { ServerCache } from './cache/server/ServerCache';
+import { KeyService } from './KeyService';
+import { RequestBufferResponse } from './RequestBuffer';
+export declare class RequestBufferManager {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private keyService;
+    private errorHandler;
+    private pendingBufferMap;
+    private pendingTrueBufferMap;
+    private pendingQueryBufferMap;
+    private pendingTemplateBufferMap;
+    private serverCache;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, errorHandler: ErrorHandlerInterface);
+    setServerCache(serverCache: ServerCache): void;
+    containsId(itemType: ItemType, itemId: ItemId): boolean;
+    containsQuery(itemType: ItemType, queryString: string): boolean;
+    fetchByIds(itemType: ItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchById(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
+    requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByLocalId(itemType: ItemType, itemId?: ItemId | string, templateOptions?: any): PromiseInterface<ApiResponseProcessor>;
+    private constructBuffer;
+    private constructTemplateBuffer;
+}

package/dist/src/classes/RequestColumnExpansion.d.ts

@@ -8,6 +8,7 @@ export declare class RequestColumnExpansion {
     private columns;
     private columnSetIdMap;
     constructor(columnUtil: ColumnUtil);
+    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): void;
     expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
     get(): RequestColumnMap;
 }

package/dist/src/classes/SocketMessageHandler.d.ts

@@ -1,41 +1,30 @@
-import { ApiFormatter, CollectionHandler, ItemHandler } from '../classes';
-import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ApiRequestColumns, ApiResponse, CollectionMatchResult, FieldMap, FunctionChangesResolveSocketMessage, GroupedExtendedCollectionMatchResult, ItemId, ItemType, PromiseInterface, ResponseColumn, SocketMessage } from '../types';
+import { ApiFormatter } from '../classes';
+import { RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
+import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionMatchResult, ItemType, SocketMessage } from '../types';
+import { RequestBufferManager } from './RequestBufferManager';
 export declare type SocketCollectionMap<ItemTypeType extends ItemType> = {
     [itemId: number]: CollectionMatchResult<ItemTypeType>;
 };
 export declare class SocketMessageHandler {
+    private requestBufferManager;
+    private changesDeltaFactory;
     private apiFormatter;
-    private apiRequestService;
-    private collectionHandler;
-    private columnExpansionFactory;
-    private columnSetFactory;
     private errorHandler;
-    private itemEntryFactory;
-    private itemHandler;
-    private localCacheManager;
+    private transactionCacheFactory;
     private promiseService;
     private requestColumnExpansionFactory;
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemHandler: ItemHandler, localCacheManager: LocalCacheManagerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
     onMessageReceived(message: SocketMessage): any;
-    formatMessageValues(values: any, columns: ResponseColumn[]): FieldMap;
-    createCollectionMap<ItemTypeType extends ItemType>(itemType: ItemTypeType, items: {
-        [itemId: number]: any;
-    }, columns: ResponseColumn[]): SocketCollectionMap<ItemTypeType>;
-    groupByCollectionId<ItemTypeType extends ItemType>(itemType: ItemTypeType, collectionMap: SocketCollectionMap<ItemTypeType>): GroupedExtendedCollectionMatchResult<ItemTypeType>;
-    getRequestColumns<ItemTypeType extends ItemType>(itemType: ItemTypeType, collectionMap: SocketCollectionMap<ItemTypeType>): {
-        [itemType: string]: ApiRequestColumns;
-    };
-    deferEntry<T extends ItemEntry<any>>(itemEntry: T): T | PromiseInterface<T>;
-    processMessage<T extends SocketMessage['body']>(body: T): PromiseInterface<GroupedExtendedCollectionMatchResult<T['itemType']>>;
-    processFunctionChangesResolve<T extends SocketMessage['body']>(body: T): PromiseInterface<void>;
-    handleResponse<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestIds: ItemId[], requestColumns: ApiRequestColumns, response: ApiResponse, collectionMap: SocketCollectionMap<ItemTypeType>): GroupedExtendedCollectionMatchResult<ItemTypeType>;
+    private formatMessageValues;
+    private createCollectionMap;
+    private getRequestColumns;
+    private processMessage;
+    private processFunctionChangesResolve;
     private isFunctionChangesResolveMessage;
-    handleCreate(message: FunctionChangesResolveSocketMessage): PromiseInterface<void>;
-    handleCreate(message: SocketMessage): PromiseInterface<null>;
-    handleUpdate(message: SocketMessage): PromiseInterface<void>;
-    handleDelete<T extends SocketMessage>(message: T): PromiseInterface<void>;
-    handleLinkMove(): PromiseInterface<void>;
+    private handleCreate;
+    private handleUpdate;
+    private handleDelete;
+    private handleLinkMove;
 }

package/dist/src/classes/TemplateCache.d.ts

@@ -0,0 +1,63 @@
+import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { Template } from '../models';
+import { EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { ColumnHandler } from './ColumnHandler';
+import { ColumnUtil } from './ColumnUtil';
+import { RequestBufferManager } from './RequestBufferManager';
+export declare class TemplateCache {
+    private columnUtil;
+    private promiseService;
+    private requestBufferFactory;
+    private columnHandler;
+    private templateFactory;
+    private errorHandler;
+    private requestColumnExpansionFactory;
+    templates: {
+        [itemType: string]: Template<any>;
+    };
+    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, requestBufferFactory: RequestBufferManager, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    /**
+     * @description
+     * Fetches a {@link Template template}
+     *
+     * @param itemType The {@link ItemType ItemType} of the template item
+     * @param itemId Used for caching, multiple concurrent template calls for the same itemId will return the same template
+     * @param templateOptions
+     * @param templateColumns Additional columns to be fetched, will be stored in the template - warning - the Template won't have values for those columns
+     * @param entryParentOrParentItemType An optional {@link EntryParentNull entry parent} or {@link ItemType parent itemType}, if the parent is passed the templateColumns will be expanded with the proper link columns (Through {@link ColumnUtil.getColumnsFromLink ColumnUtil.getColumnsFromLink})
+     *
+     * @example
+     * ```
+     *  const parent: EntryParent = {
+     *      itemType: 'Functie',
+     *      itemId: 10,
+     *  };
+     *
+     *  return core.templateCache
+     *      .fetchTemplate(
+     *          'Planningpersoneel',
+     *          undefined,
+     *          {},
+     *          {},
+     *          parent,
+     *      )
+     *      .then(
+     *          (template: Template<'Planningpersoneel'>) => {
+     *              const changesDelta = transaction.createChangesDelta();
+     *
+     *              for (const itemResource of selectedItems) {
+     *                  changesDelta.setItemCreated(
+     *                      core.keyService.getLocalId(),
+     *                      template.fields,
+     *                      template.columns,
+     *                      parent,
+     *                  );
+     *              }
+     *
+     *              transaction.applyChangesDelta(changesDelta);
+     *          );
+     *  ```
+     */
+    fetchTemplate<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType>>;
+}

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

@@ -0,0 +1,122 @@
+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 { CollectionEntryService } from '../CollectionEntryService';
+import { ColumnCache } from '../ColumnCache';
+import { ColumnHandler } from '../ColumnHandler';
+import { ColumnUtil } from '../ColumnUtil';
+import { InternalChangesDelta } from '../InternalChangesDelta';
+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;
+    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): 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[][]>;
+}

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

@@ -0,0 +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`
+     */
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
+    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[]): void | never[];
+    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): 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

@@ -0,0 +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(): void;
+    private groupItemEntries;
+}