@rentman/rm-core 0.0.0-RM4-44763

package/dist/types/src/classes/QueryParserIdUpdater.d.ts

@@ -0,0 +1,16 @@
+import { ApiFields, ApiItemType, ApiQueryOperator, ItemApiFields } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryWithConditions, ItemIdConversionMap, QueryParserBase } from '../internal';
+type ReturnType = boolean;
+export declare class QueryParserIdUpdater extends QueryParserBase<ReturnType> {
+    private itemIdConversionMap;
+    constructor(itemIdConversionMap: ItemIdConversionMap);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(_key: keyof ItemApiFields<MainItemType>, _itemType: SubItemType, _field: keyof ItemApiFields<SubItemType>, query: ApiQuery<SubItemType>, _not: boolean, subQueryDepth: number): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseComparatorQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(_key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value'], _comparator: ApiQueryConditionComparator<ItemTypeType, ColumnId>['comparator'], queryPart: ApiQueryConditionComparator<ItemTypeType, ColumnId>): ReturnType;
+    protected parseInQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(_key: ApiQueryConditionIn<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionIn<ItemTypeType, ColumnId>['value'], _not: boolean): ReturnType;
+    protected parseLinkedToQuery<SubItemType extends ApiItemType>(_linkedTo: ApiQueryConditionLinkedTo<SubItemType>['linkedTo'], query: Exclude<ApiQueryConditionLinkedTo<SubItemType>['query'], undefined>, _reverse: boolean, _not: boolean, subQueryDepth: number): ReturnType;
+    protected parseComplexQuery<ItemTypeType extends ApiItemType>(conditions: ApiQueryWithConditions<ItemTypeType>['conditions'], _operator: Extract<ApiQueryOperator, 'AND' | 'OR'>, _not: boolean, subQueryDepth: number): ReturnType;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, EntryParentNull } from '../internal';
+export declare class QueryService {
+    containsLocalId<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>): boolean;
+    addAndCondition<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>, condition: ApiQuery<ItemTypeType>): ApiQuery<ItemTypeType>;
+    addOrCondition<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>, condition: ApiQuery<ItemTypeType>): ApiQuery<ItemTypeType>;
+    addParentCondition<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>, parent: EntryParentNull): ApiQuery<ItemTypeType>;
+    createNotIn<ItemTypeType extends ApiItemType>(idArray: ItemId[]): ApiQuery<ItemTypeType>;
+    isEmptyQuery<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>): boolean;
+}

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

@@ -0,0 +1,13 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, CollectionQuery, RequestBufferBase, RequestBufferOptions, RequestBufferResult, RequestColumnExpansionFactory, RequestColumnsTuple } from '../../internal';
+export declare class RequestBuffer<ItemTypeType extends ApiItemType> extends RequestBufferBase<ItemTypeType> {
+    private readonly contents;
+    static constructWithSingleItems<ConstructorItemTypeType extends ApiItemType>(apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemType: ConstructorItemTypeType, itemIds: ItemId<ConstructorItemTypeType>[], requestColumns: ApiRequestColumns<ConstructorItemTypeType>, options: RequestBufferOptions<ConstructorItemTypeType>): RequestBuffer<ConstructorItemTypeType>;
+    static constructWithQuery<ConstructorItemTypeType extends ApiItemType>(apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemType: ConstructorItemTypeType, query: CollectionQuery<ConstructorItemTypeType, true>, requestColumnsTuple: RequestColumnsTuple<ConstructorItemTypeType>, options: RequestBufferOptions<ConstructorItemTypeType>): RequestBuffer<ConstructorItemTypeType>;
+    addSingleItems(itemIds: ItemId[], requestColumns: ApiRequestColumns<ItemTypeType>, forceFlush: boolean): this | null;
+    addQuery(query: CollectionQuery<ItemTypeType>, requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, options: RequestBufferOptions<ItemTypeType>): this | null;
+    protected executeQuery(): Promise<RequestBufferResult<ItemTypeType>>;
+    private _addSingleItems;
+    private _addQuery;
+    private createAggregateQuery;
+}

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

@@ -0,0 +1,37 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestColumns, ApiRequestLimit, ApiRequestService, ApiResponseProcessor, CollectionQuery, Deferred, RequestColumnExpansion, RequestColumnExpansionFactory, RequestColumnsTuple } from '../../internal';
+export interface RequestBufferOptions<ItemTypeType extends ApiItemType> {
+    /**
+     * By default, flushing is prevented while requests are suspended. This prevents conflicts while saving. Enable to
+     * ignore  request suspension, which could introduce an additional delay.
+     */
+    forceFlush: boolean;
+    /**
+     * Time that should expire before the back-end request is executed, in milliseconds. Set to `0` to execute request
+     * immediately. 150 milliseconds by default.
+     */
+    flushTimeout: number;
+    limit: ApiRequestLimit<ItemTypeType> | undefined;
+}
+export declare const defaultRequestBufferOptions: Readonly<RequestBufferOptions<any>>;
+export interface RequestBufferResult<ItemTypeType extends ApiItemType> {
+    requestColumns: ApiRequestColumnMap;
+    response: ApiResponseProcessor<ItemTypeType>;
+    nonLocallyMatchableQueryString: string | null;
+}
+export declare abstract class RequestBufferBase<ItemTypeType extends ApiItemType> {
+    protected readonly apiRequestService: ApiRequestService;
+    readonly itemType: ItemTypeType;
+    readonly options: Readonly<RequestBufferOptions<ItemTypeType>>;
+    protected readonly deferred: Deferred<RequestBufferResult<ItemTypeType>>;
+    protected readonly requestColumnExpansion: RequestColumnExpansion;
+    readonly createdDate: number;
+    protected constructor(apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemType: ItemTypeType, options: Readonly<RequestBufferOptions<ItemTypeType>>);
+    abstract addSingleItems(itemIds: ItemId[], requestColumns: ApiRequestColumns<ItemTypeType>, forceFlush: boolean): this | null;
+    abstract addQuery(query: CollectionQuery<ItemTypeType>, requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, options: RequestBufferOptions<ItemTypeType>): this | null;
+    flush(onBufferFlushed?: (result: RequestBufferResult<any>) => Promise<any>): Promise<RequestBufferResult<ItemTypeType>>;
+    getPromise(): Promise<RequestBufferResult<ItemTypeType>>;
+    protected abstract executeQuery(): Promise<RequestBufferResult<ItemTypeType>>;
+    protected acceptsRequestColumns(requestColumns: ApiRequestColumns<ItemTypeType>): boolean;
+    protected compareApiRequestLimit(limitA: ApiRequestLimit | undefined, limitB: ApiRequestLimit | undefined): boolean;
+}

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

@@ -0,0 +1,24 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, CollectionQuery, RequestBufferOptions, RequestBufferResult, RequestColumnExpansionFactory, RequestColumnsTuple } from '../../internal';
+export declare class RequestBufferManager {
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private onBufferFlushed?;
+    private pendingBufferMap;
+    /**
+     * Because we're not saving multiple transactions simultaneously, we can get by with a simple flag here.
+     */
+    private requestsSuspended;
+    constructor(apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, onBufferFlushed?: ((result: RequestBufferResult<any>) => Promise<any>) | undefined);
+    /**
+     * We could make this extra safe by waiting for responses to arrive for requests that are in-flight.
+     * However, this comes at a performance cost, as we have to wait longer before saving our changes.
+     */
+    suspendRequests(): void;
+    continueRequests(): void;
+    fetchByIds<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemIds: ItemId[], requestColumns: ApiRequestColumns<ItemTypeType>, partialOptions?: Partial<RequestBufferOptions<ItemTypeType>>): Promise<RequestBufferResult<ItemTypeType>>;
+    fetchByQuery<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, query: CollectionQuery<ItemTypeType>, requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, partialOptions?: Partial<RequestBufferOptions<ItemTypeType>>): Promise<RequestBufferResult<ItemTypeType>>;
+    private processOptions;
+    private addBuffer;
+    private flushPendingBuffers;
+}

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

@@ -0,0 +1,18 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestService, CollectionQuery, RequestBufferBase, RequestBufferOptions, RequestBufferResult, RequestColumnExpansionFactory, RequestColumnsTuple } from '../../internal';
+export declare class SingleQueryRequestBuffer<ItemTypeType extends ApiItemType> extends RequestBufferBase<ItemTypeType> {
+    /**
+     * When we store a query that cannot be matched locally, we cannot store any other queries because we depend on the
+     * response to figure out what items match.
+     */
+    private readonly contents;
+    constructor(apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemType: ItemTypeType, 
+    /**
+     * When we store a query that cannot be matched locally, we cannot store any other queries because we depend on the
+     * response to figure out what items match.
+     */
+    contents: CollectionQuery<ItemTypeType>, requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, options: RequestBufferOptions<ItemTypeType>);
+    addSingleItems(): null;
+    addQuery(query: CollectionQuery<ItemTypeType>, requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, options: RequestBufferOptions<ItemTypeType>): this | null;
+    protected executeQuery(): Promise<RequestBufferResult<ItemTypeType>>;
+}

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

@@ -0,0 +1,11 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestColumns, ColumnSet, RequestColumnsTuple } from '../internal';
+export declare class RequestColumnExpansion {
+    private columns;
+    private columnSetIdMap;
+    private requestColumnSetIdMap;
+    expandWithRequestColumnsTuple(itemType: ApiItemType, requestColumnsTuple: RequestColumnsTuple): void;
+    expandWithColumnSet(columnSet: ColumnSet<any>): void;
+    expandWithRequestColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>): void;
+    get(): ApiRequestColumnMap;
+}

package/dist/types/src/classes/RequestColumnsOperationsCache.d.ts

@@ -0,0 +1,45 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestColumnArray, ApiRequestColumns, ColumnCache, ColumnSet, RequestColumnsTuple } from '../internal';
+type RequestColumnSetMergeResult<ItemTypeType extends ApiItemType = any> = {
+    merged: RequestColumnsTuple<ItemTypeType>;
+    difference: RequestColumnsTuple<ItemTypeType>;
+};
+type AggregateColumnsTuple<ItemTypeType extends ApiItemType = any> = {
+    readonly object: ApiRequestColumnArray<ItemTypeType>;
+    readonly string: string;
+};
+/**
+ * @description This class caches the results of frequently performed operations on request columns:
+ * - Merging;
+ * - Testing whether all columns of one column set are present in another (which is mainly done by merging and checking
+ * the difference);
+ * - Creating hashes (IDs) for sets of request columns.
+ */
+export declare class RequestColumnsOperationsCache<ItemTypeType extends ApiItemType> {
+    readonly itemType: ItemTypeType;
+    private columnCache;
+    private readonly requestColumnsTuple;
+    private aggregateColumnsTuple?;
+    private expandedRequestColumnsTuple?;
+    private columnsMergedWithTupleMap;
+    private expandedColumnsMergedWithTupleMap;
+    private setContainsAllColumnsMap;
+    private setContainsAllExpandedColumnsMap;
+    constructor(itemType: ItemTypeType, columnCache: ColumnCache, requestColumns: ApiRequestColumns<ItemTypeType>);
+    getRequestColumnsTuple(transactionCache: AbstractCache): RequestColumnsTuple<ItemTypeType>;
+    getAggregateColumns(): AggregateColumnsTuple;
+    hasAggregateColumns(): boolean;
+    /**
+     *
+     * @param requestColumnsTuple
+     * @param transactionCache - When in the server cache, we'll include the columns required for delete
+     * relations and the query matcher in the operation.
+     */
+    getColumnsMergedWithTuple(requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, transactionCache: AbstractCache): RequestColumnSetMergeResult<ItemTypeType>;
+    tupleContainsAllColumns(requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, transactionCache: AbstractCache): boolean;
+    setContainsAllColumns(columnSet: ColumnSet<ItemTypeType>, transactionCache: AbstractCache): boolean;
+    private mergeColumnsWithTuple;
+    private extractAggregateColumns;
+    private createRequestColumnsTuple;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestService, ChangesDeltaFactory, ChangesDeltaResult, ColumnCache, ErrorHandlerInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, SocketMessage, TransactionCacheFactory } from '../internal';
+export declare class SocketMessageHandler {
+    private changesDeltaFactory;
+    private columnCache;
+    private errorHandler;
+    private requestColumnExpansionFactory;
+    private transactionCacheFactory;
+    private requestColumnsOperationsCacheFactory;
+    private readonly logPrefix;
+    private readonly requestBufferManager;
+    constructor(changesDeltaFactory: ChangesDeltaFactory, columnCache: ColumnCache, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, transactionCacheFactory: TransactionCacheFactory, apiRequestService: ApiRequestService, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory);
+    onMessagesReceived(messages: SocketMessage<any>[], flushTimeout?: number): Promise<ChangesDeltaResult>;
+    refreshItemsOfType(itemType: ApiItemType): Promise<void>;
+    private handleDelete;
+    private logFetchedItems;
+    private processSocketMessageValues;
+    private aggregateCachedRequestColumns;
+    private getMergedQueryGraphTuple;
+    private matchSocketMessageItems;
+    /**
+     * @description
+     * When an item is created or updated, we should check if it fits in any of the cached queries (using the values provided by the socket message)
+     * If we think it fits (or maybe) we should fetch the complete item with the superset of columns (the socket message might not have all values)
+     */
+    private processMessage;
+    private processRequests;
+}

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

@@ -0,0 +1,61 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumnArrayMap, ApiRequestService, ColumnHandler, ColumnSetFactory, EntryParentNull, ItemEntryService, LinkTreeServiceInterface, RequestColumnExpansionFactory, RequestParameters, Template } from '../internal';
+export declare class TemplateCache {
+    private apiRequestService;
+    private columnHandler;
+    private columnSetFactory;
+    private requestColumnExpansionFactory;
+    private linkTreeService;
+    private itemEntryService;
+    private pendingTemplateBufferMap;
+    private templateResponses;
+    constructor(apiRequestService: ApiRequestService, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, linkTreeService: LinkTreeServiceInterface, itemEntryService: ItemEntryService);
+    /**
+     * @description
+     * Fetches a {@link Template template}, use {@link ItemCreateService.createItemsFromValues createItemsFromValues} to easily create new items from a set of values.
+     * The best way to process the template's values is to call {@link ItemCreateService.processTemplate processTemplate}
+     *
+     * @param itemType The {@link ApiItemType 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 templateRequestColumns 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 ApiItemType 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.getFields(),
+     *                      template.columns,
+     *                      parent,
+     *                  );
+     *              }
+     *
+     *              return transaction.applyChangesDelta(changesDelta);
+     *          );
+     *  ```
+     */
+    fetchTemplate<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: Partial<RequestParameters<ItemTypeType>>, templateRequestColumns?: ApiRequestColumnArrayMap, entryParentOrParentItemType?: EntryParentNull | ApiItemType): Promise<Template<ItemTypeType>>;
+    private expandWithLinkedItemTypesDefaultColumns;
+    private fetchTemplateById;
+    private constructTemplateBuffer;
+    private expandWithDefaultRequestColumns;
+}

package/dist/types/src/classes/Util.d.ts

@@ -0,0 +1,36 @@
+export declare function findIndex<T>(haystack: T[], callback: (item: T) => boolean): number;
+export declare function shallowMerge(object: any, defaults: any): any;
+export declare function hasProperties(object: any): boolean;
+export declare function getFirstProperty<T = string>(object: any): T | null;
+export declare function inArray(needle: any, haystack: any): boolean;
+export declare function pathExists(source: any, path: string[]): boolean;
+export declare function createPath<T>(object: any, path: (number | string)[], defaults: any[], overwriteDestination?: boolean): T;
+export declare function getPath(object: Record<string, any>, path: (number | string)[], create?: boolean): any;
+export declare function extend(dst: any, ...args: any[]): any;
+export declare function merge(dst: any, ...args: any[]): any;
+export declare function isObject(value: any): boolean;
+export declare function isBlankObject(value: any): boolean;
+export declare function isString(value: any): value is string;
+export declare function isNumber(value: any): value is number;
+export declare function isDate(value: any): boolean;
+export declare const isArray: (arg: any) => arg is any[];
+export declare function isFunction<T>(value: any): value is T;
+export declare function isPromiseLike<T = any>(obj: any): obj is Promise<T>;
+type ResolvedPromiseObject<ObjectType extends Record<string, any>> = {
+    [K in keyof ObjectType]: ObjectType[K] extends Promise<infer PromiseType> ? PromiseType : ObjectType[K];
+};
+export declare function promiseAllObject<ObjectType extends Record<string, any>>(promiseObject: ObjectType): Promise<ResolvedPromiseObject<ObjectType>>;
+export interface Deferred<T> {
+    promise: Promise<T>;
+    resolve(value?: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+}
+export declare function promiseCreateDeferred<T>(): Deferred<T>;
+export declare function isRegExp(value: any): boolean;
+export declare function isBoolean(value: any): value is boolean;
+export declare function isElement(node: any): boolean;
+export declare function isWindow(obj: any): any;
+export declare function isDefined(value: any): boolean;
+export declare function equals(o1: any, o2: any): boolean;
+export declare function copy(source: Record<string, any>, destination?: Record<string, any>, maxDepth?: any): any;
+export {};

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

@@ -0,0 +1,86 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { RmCore } from '../../core';
+import { AbstractCacheDependencyInterface, CachedQueryHandlerBase, CachedQueryItem, ChangesDelta, ChangesDeltaItemCreateDelta, ChildChangesDelta, CollectionQuery, EntryParentNull, FieldMap, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, ServerCache, TransactionCache, TransactionValidatorFactory } from '../../internal';
+export type TransactionOptions = {
+    /**
+     * @description
+     * Sets the TransactionCache to 'transparent' mode, whenever {@link AbstractCache.createChild createChild} is called it will actually be called on the parent
+     */
+    transparent: boolean;
+};
+export declare abstract class AbstractCache {
+    dependencies: AbstractCacheDependencyInterface;
+    core: RmCore;
+    children: TransactionCache[];
+    readonly itemHandler: ItemHandlerBase;
+    readonly cachedQueryHandler: CachedQueryHandlerBase;
+    parent: AbstractCache | null;
+    protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
+    getDescendantsIterator(): IterableIterator<TransactionCache>;
+    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    onChildDestroy(cache: TransactionCache): void;
+    /**
+     * @description
+     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
+     */
+    abstract getCollectionChangesRecursively<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Returns this transaction and all parents
+     */
+    getTransactionChain(includeServerCache: false): TransactionCache[];
+    getTransactionChain(includeServerCache?: true): AbstractCache[];
+    /**
+     * @description
+     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
+     */
+    getCurrentItemEntryCache(): ItemCache;
+    abstract getServerCache(): ServerCache;
+    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry;
+    abstract getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType>;
+    abstract containsLocalItemEntryByItemId(itemType: ApiItemType, itemId: ItemEntry['itemId']): boolean;
+    /**
+     * @description
+     * Removes an {@link ItemEntry ItemEntry} from the {@link TransactionCache TransactionCache} which means that
+     * changes on this entry will no longer be tracked.
+     *
+     * @returns The deleted item changes.
+     */
+    clearItemEntry<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Gets an already cached {@link ItemEntry ItemEntry} and the changes of this specific transaction for that entry
+     */
+    getLocalItemEntryChangesTuple<ItemTypeType extends ApiItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
+    /**
+     * @description
+     * Applies changes from a child transaction to a parent
+     */
+    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): Promise<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(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): Promise<void>;
+    getParent(itemEntry: ItemEntry<any>, fromInitial?: boolean): EntryParentNull;
+    protected getParentFromFields<ItemTypeType extends ApiItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields?: FieldMap<ItemTypeType>): EntryParentNull;
+    /**
+     * Processes a created item from a changes delta.
+     * @returns `null` if the item already exists on this transaction, the created item entry otherwise.
+     */
+    protected processCreatedItem<ItemTypeType extends ApiItemType>(tuple: ChangesDeltaItemCreateDelta<ItemTypeType>, sourceChangesDelta: ChangesDelta): ItemEntry<ItemTypeType> | null;
+    /**
+     * @description
+     * Ensures that for all updated items in the delta the required derived values are present
+     */
+    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDelta | ChildChangesDelta, itemIdConversionMap: ItemIdConversionMap | undefined): Promise<void[]>;
+    protected handleCascadingDeletes(changesDelta: ChangesDelta | ChildChangesDelta | ParentChangesDelta): void;
+    private cascadeDeleteByItemType;
+}

package/dist/types/src/classes/cache/CachedQueryHandlerBase.d.ts

@@ -0,0 +1,145 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { GraphQueryParserFactory } from '../../factories/GraphQueryParserFactory';
+import { AbstractCache, ApiQuery, ApiRequestColumns, ApiRequestService, CachedQueryItem, CachedQueryOptions, CachedQueryOptionsWithColumns, ChangesDeltaBase, CollectionOptions, CollectionQuery, CollectionResourceOrder, ErrorHandlerInterface, ItemEntry, LinkTreeServiceInterface, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, MatchingResultsAccumulatorTuple, ParentChangesDelta, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, RequestColumnsTuple } from '../../internal';
+import { RootQueryNode } from '../matcher/RootQueryNode';
+export interface LinkCollectionBatchQueryTuple<ItemTypeType extends ApiItemType> {
+    batchQuery: CollectionQuery<ItemTypeType>;
+    batchQueryGraph?: RootQueryNode<ItemTypeType>;
+}
+export interface ParentCachedQueryItemTuple<ItemTypeType extends ApiItemType> {
+    readonly cachedQueryItem: CachedQueryItem<ItemTypeType>;
+    readonly options: CollectionOptions<ItemTypeType>;
+    children: CachedQueryItemsItemTypeTuple<ApiItemType>[] | null;
+}
+export interface CachedQueryItemTuple<ItemTypeType extends ApiItemType> extends ParentCachedQueryItemTuple<ItemTypeType> {
+    children: null;
+}
+export interface CachedQueryItemsItemTypeTuple<ItemTypeType extends ApiItemType> {
+    itemType: ItemTypeType;
+    cachedQueryItemTuples: ParentCachedQueryItemTuple<ItemTypeType>[];
+}
+export interface CachedQueryHandlerCollectionTuple<ItemTypeType extends ApiItemType> {
+    cachedQueryItem?: CachedQueryItem<ItemTypeType>;
+}
+type RequireOnly<ObjectType, Keys extends keyof ObjectType> = ObjectType & {
+    [Key in Keys]-?: ObjectType[Key];
+};
+export declare abstract class CachedQueryHandlerBase {
+    protected dependencies: {
+        apiRequestService: ApiRequestService;
+        errorHandler: ErrorHandlerInterface;
+        graphQueryParserFactory: GraphQueryParserFactory;
+        linkTreeService: LinkTreeServiceInterface;
+        queryService: QueryService;
+        requestColumnExpansionFactory: RequestColumnExpansionFactory;
+        requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    };
+    protected transaction: AbstractCache;
+    protected collections: {
+        [ItemType in ApiItemType]?: {
+            [queryString: string]: CachedQueryHandlerCollectionTuple<ItemType> | undefined;
+        };
+    };
+    protected constructor(dependencies: {
+        apiRequestService: ApiRequestService;
+        errorHandler: ErrorHandlerInterface;
+        graphQueryParserFactory: GraphQueryParserFactory;
+        linkTreeService: LinkTreeServiceInterface;
+        queryService: QueryService;
+        requestColumnExpansionFactory: RequestColumnExpansionFactory;
+        requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    }, transaction: AbstractCache);
+    createQuery<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>): CollectionQuery<ItemTypeType>;
+    /**
+     * Works out the effect the changes found in `parentChangesDelta` will have on the cached queries / collections on
+     * the current transaction. This method does not update the collections themselves. A call to
+     * {@link applyMatchingResultsToCachedQueries} or {@link applyMatchingResultsToCollections} will be required.
+     *
+     * Note that this method also resolves `maybe` matches.
+     *
+     * @param processEmptyUpdates - Processes empty updates. See: {@link ItemMatcherBase.matchEmptyItemsInUpdatedChangesDelta}.
+     */
+    matchItemsToCollectionQueries(parentChangesDelta: ParentChangesDelta, limitToItemTypes: Iterable<ApiItemType> | undefined, processEmptyUpdates: boolean): Promise<MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>>;
+    applyMatchingResultsToCachedQueries(matchingResultsAccumulatorMap: MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>): void;
+    /**
+     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
+     */
+    setCachedQuery<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>, requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, itemEntries: ItemEntry<ItemTypeType>[], queryGraph?: RootQueryNode<ItemTypeType>): CachedQueryItem<ItemTypeType>;
+    /**
+     * @description
+     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
+     */
+    __fetchCachedQueryItem<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptionsWithColumns<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    getCachedQueryItemsByItemType<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType): CachedQueryItem<ItemTypeType>[];
+    cloneCachedQuery<ItemTypeType extends ApiItemType>(cachedQueryItem: CachedQueryItem<ItemTypeType>, resolve?: boolean): CachedQueryItem<ItemTypeType>;
+    clearCachedQueryItem(itemType: ApiItemType, queryString: string): void;
+    /**
+     * Clears cached queries in the form of:
+     *  - {linkedTo: [itemType], query: {id: [itemId]}};
+     *  - {[linkField]: [itemId]}.
+     *
+     *  This should catch most cached queries when deleting a parent item.
+     */
+    clearLinkedCachedQueryItems(itemEntry: ItemEntry): void;
+    getCachedQueryItem<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * Merges all query graphs for the given item type on the transaction. This allows changed items to be matched to
+     * all queries simultaneously.
+     * @param queryResults - When a set of items is already known to match a certain query, we can add a comparator node
+     * for the item IDs to the end result. This can be beneficial for queries that can not be locally matched.
+     */
+    getMergedQueryGraph<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryResults?: {
+        [queryString: string]: Set<ItemId<ItemTypeType>>;
+    }): RootQueryNode<ItemTypeType> | null;
+    getCachedQueryItemIterator(): Generator<CachedQueryItem>;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     */
+    abstract __fetchItemEntriesByQueryData<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>, linkCollectionBatchQueryTuple?: LinkCollectionBatchQueryTuple<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    abstract __maybeExpandCachedQuery<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, batchedLinkedToQuery?: CollectionQuery<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    queryIsCacheable<ItemTypeType extends ApiItemType>(options: CachedQueryOptions<ItemTypeType>, query: CollectionQuery<ItemTypeType>): boolean;
+    protected createQueryFromOptions<ItemTypeType extends ApiItemType>(options: CachedQueryOptions<ItemTypeType>): CollectionQuery<ItemTypeType>;
+    /**
+     * @description
+     * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CacheSyncer CacheSyncer} to function.
+     * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionOptions.queryColumns queryColumns} should also be taken into account
+     */
+    expandColumnsWithQueryColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: {
+        columns: ApiRequestColumns<ItemTypeType>;
+        order?: CollectionResourceOrder<ItemTypeType>;
+    }, query: ApiQuery<ItemTypeType>): void;
+    protected getOrCreateCollectionTuple<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): CachedQueryHandlerCollectionTuple<ItemTypeType>;
+    /**
+     * Because this method is only called after a cached query (or collection resource) has been removed from the cache,
+     * we're assuming the tuple is present.
+     */
+    protected clearCollectionTupleIfEmpty<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): void;
+    /**
+     * We're returning a set because multiple cached queries / collection resources might share the same query graph.
+     * When using child collections, the query graph could already be a graph that matches multiple cached queries.
+     * Collection resources often have the same query graph as the cached query.
+     */
+    protected getQueryGraphsForItemType<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Set<RootQueryNode<ItemTypeType>>;
+    /**
+     * We're returning a set here to avoid duplicate collection query objects. When, for a specific query, both a cached
+     * query and a collection resource exist, the collection query will be the same for both.
+     */
+    protected getCollectionQueries<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): Set<CollectionQuery<ItemTypeType>>;
+    /**
+     * Handles `maybe` matches for the query identified by the `itemType` and `queryString`.
+     *
+     * @param matchingResultsTuple - A matching results tuple containing matched, non-matched and `maybe` item entries.
+     * The properties containing matched and non-matched item entries are modified to include the `maybe` item entries.
+     * The `maybe` property is kept, for now. (It is not read after this point.)
+     * @param changesDelta - When doing a back-end request for `maybeMatchedItemEntries`, the resulting item IDs are
+     * stored in this changes delta.
+     */
+    protected processMaybeMatches<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, matchingResultsTuple: RequireOnly<MatchingResultsAccumulatorTuple<any>, 'maybe'>, changesDelta: ChangesDeltaBase): Promise<void>;
+    /**
+     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
+     */
+    protected constructCachedQuery<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>, itemEntries: ItemEntry<ItemTypeType>[], requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, queryGraph?: RootQueryNode<ItemTypeType>): CachedQueryItem<ItemTypeType>;
+    private createQueryGraph;
+}
+export {};