@rentman/rm-core 5.0.1 → 6.0.0

package/dist/types/classes/ApiResponseProcessor.d.ts

@@ -1,9 +1,9 @@
 import { ApiFormatter } from '../classes';
 import { FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
-export declare class ApiResponseProcessor {
+export declare class ApiResponseProcessor<RequestItemType extends ItemType = any> {
     apiFormatter: ApiFormatter;
     response: any;
-    itemType: ItemType;
+    itemType: RequestItemType;
     columns: ItemTypeMap<ResponseColumn[]>;
     links: ItemTypeMap<ItemId[]>;
     cacheable: boolean;

package/dist/types/classes/CollectionEntryService.d.ts

@@ -1,7 +1,8 @@
 import { QueryService } from '../classes';
 import { QueryParserFactory } from '../factories';
-import { CollectionEntryOptions, ItemEntry } from '../models';
-import { CollectionOptionsInterface, CollectionQuery, EntryParentNull, ItemId, ItemType } from '../types';
+import { ItemEntry } from '../models';
+import { CollectionOptions, CollectionOptionsInterface } from '../models/CollectionOptions';
+import { ApiQuery, CollectionQuery, EntryParentNull, ItemId, ItemType } from '../types';
 export declare class CollectionEntryService {
     private queryParserFactory;
     private queryService;
@@ -9,10 +10,10 @@ export declare class CollectionEntryService {
     createUnfoundLocalCollectionError(itemType: ItemType): {
         message: string;
     };
-    cloneOptions(options: CollectionEntryOptions, parent: EntryParentNull): CollectionEntryOptions;
-    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionEntryOptions;
-    cloneQueryParams<T extends object>(parameters: T): T;
-    createQuery(options: CollectionEntryOptions): CollectionQuery;
+    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any>;
+    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions;
+    createQuery(query: ApiQuery): CollectionQuery;
+    createQueryFromOptions(options: CollectionOptions): CollectionQuery;
     getIdArray(itemEntries: Array<ItemEntry<any>>, accumulator?: ItemId[]): ItemId[];
     /**
      * @description

package/dist/types/classes/CollectionMatcherBase.d.ts

@@ -1,6 +1,7 @@
-import { AbstractCache, FieldMap, ItemType } from '../';
+import { AbstractCache, CollectionQuery, FieldMap, ItemType, QueryService } from '../';
 import { QueryMatcherFactory } from '../factories/';
-import { CollectionEntry, ItemEntry } from '../models';
+import { ItemEntry } from '../models';
+import { GroupedCollectionMatcherResult } from './cache/CollectionMatcherCachedQueryProcessor';
 import { InternalChangesDelta } from './InternalChangesDelta';
 export declare type CollectionMatcherMatches<ItemTypeType extends ItemType = ItemType> = {
     [itemId: number]: {
@@ -8,19 +9,13 @@ export declare type CollectionMatcherMatches<ItemTypeType extends ItemType = Ite
         isMatch: boolean | 'maybe';
     };
 };
-export declare class CollectionMatcherBase {
+export declare abstract class CollectionMatcherBase {
+    protected queryService: QueryService;
     protected queryMatcherFactory: QueryMatcherFactory;
     protected transaction: AbstractCache;
-    private getCollectionEntries;
-    protected map: {
-        [collectionEntryId: number]: {
-            collection: CollectionEntry;
-            matches: CollectionMatcherMatches;
-        };
-    };
-    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
+    protected constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
     expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
     processDelta(internalChangesDelta: InternalChangesDelta): this;
-    protected hasFittingItems(matches: CollectionMatcherMatches): boolean;
-    protected _expand(itemEntry: ItemEntry, matchFunction: (collectionEntry: CollectionEntry) => boolean | 'maybe'): this;
+    protected groupItemEntries<ItemTypeType extends ItemType>(matches: CollectionMatcherMatches<ItemTypeType>): GroupedCollectionMatcherResult<ItemTypeType>;
+    protected abstract _expand<ItemTypeType extends ItemType = string>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
 }

package/dist/types/classes/CollectionMatcherCachedCollectionProcessor.d.ts

@@ -0,0 +1,31 @@
+import { QueryMatcherFactory } from '../factories';
+import { PromiseLibraryInterface } from '../interfaces';
+import { CollectionResource, ItemEntry } from '../models';
+import { CollectionQuery, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { AbstractCache } from './cache/AbstractCache';
+import { ChangesDeltaBase } from './ChangesDeltaBase';
+import { CollectionMatcherBase, CollectionMatcherMatches } from './CollectionMatcherBase';
+import { QueryService } from './QueryService';
+/**
+ * @description
+ * Processes all {@link CollectionResource CollectionResources} and adds/removes item entries that do/don't fit the query
+ */
+export declare class CollectionMatcherCachedCollectionProcessor extends CollectionMatcherBase {
+    private apiRequestService;
+    private promiseService;
+    private getCollections;
+    protected map: {
+        [itemTypeAndQueryString: string]: {
+            itemType: ItemType;
+            query: CollectionQuery;
+            collectionResources: CollectionResource[];
+            matches: CollectionMatcherMatches;
+        };
+    };
+    constructor(apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollections: (itemType: ItemType) => {
+        [queryString: string]: CollectionResource[];
+    });
+    __removeFromAndAddToCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
+    protected _expand<ItemTypeType extends ItemType = string>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+}

package/dist/types/classes/CollectionResourceService.d.ts

@@ -1,6 +1,7 @@
-import { CollectionResourceOptions, CollectionResourceOptionsInterface, ItemResource } from '../models';
+import { CollectionOptions, ItemResource } from '../models';
+import { CollectionOptionsInterface } from '../models/CollectionOptions';
 import { ItemId, ItemType } from '../types';
 export declare class CollectionResourceService {
-    processOptions<ItemTypeType extends ItemType>(options: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResourceOptions<ItemTypeType>;
-    getIdArray(itemResources: Array<ItemResource<any>>): ItemId[];
+    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions<ItemTypeType>;
+    getIdArray(itemResources: ItemResource[]): ItemId[];
 }

package/dist/types/classes/ColumnSet.d.ts

@@ -29,8 +29,7 @@ export declare class ColumnSet<ItemTypeType extends ItemType = any> {
         main: string[];
         derived: string[];
     };
-    expandRequestColumns(columns: ApiRequestColumns): void;
-    isSupersetOf(columns: ApiRequestColumns): boolean;
+    isSupersetOf(columnsToCompare: ApiRequestColumns): boolean;
     private getMergedColumnSet;
     mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
     mergeResponseColumns(responseColumns: ResponseColumnItemTypeMap): ResponseColumnItemTypeMap;

package/dist/types/classes/ColumnSubsetCache.d.ts

@@ -1,8 +1,10 @@
-import { ColumnSet } from '../classes';
+import { ColumnSet, ColumnUtil } from '../classes';
 import { ApiRequestColumns, ItemType } from '../types';
 export declare class ColumnSubsetCache<ItemTypeType extends ItemType> {
+    private columnUtil;
     requestColumns: ApiRequestColumns;
     private cache;
-    constructor(requestColumns: ApiRequestColumns);
+    constructor(columnUtil: ColumnUtil, requestColumns: ApiRequestColumns);
     run(columnSet: ColumnSet<ItemTypeType>): boolean;
+    runWithRequestColumns(cachedRequestColumns: ApiRequestColumns): boolean;
 }

package/dist/types/classes/KeyService.d.ts

@@ -1,6 +1,7 @@
 import { ItemId, StateKey } from '../types';
 export declare class KeyService {
-    separator: string;
+    private separator;
+    private idCounter;
     constructor();
     getSingleKey(itemType: string, itemId: number | string): string;
     getCssKey(...args: any[]): string;

package/dist/types/classes/{QueryLocalLinkedToParser.d.ts → QueryLinkedToParser.d.ts}

@@ -1,17 +1,16 @@
 import { ApiQuery, ItemType } from '../types';
-import { KeyService } from './KeyService';
 import { COMPARATORS_TYPE } from './QueryParser';
 import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare class QueryLocalLinkedToParser extends QueryParserBase<boolean> {
-    private keyService;
-    constructor(keyService: KeyService, query: ApiQuery);
+export declare class QueryLinkedToParser extends QueryParserBase<boolean> {
+    private callback;
+    constructor(callback: (linkedTo: ItemType, query: ApiQuery) => boolean, query: ApiQuery);
     protected parseEmptyQuery(): boolean;
     protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): boolean;
     protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): boolean;
     protected parseSearchQuery(_value: any, _not: boolean): boolean;
     protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
     protected parseSimpleQuery(_key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
-    protected parseLinkedToQuery(_linkedTo: any, query?: ApiQuery, _reverse?: boolean, not?: boolean): boolean;
+    protected parseLinkedToQuery(linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, not?: boolean): boolean;
     protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
     private parseConditions;
 }

package/dist/types/classes/QueryLocallyMatchableParser.d.ts

@@ -0,0 +1,19 @@
+import { ApiQuery, ItemType } from '../types';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+/**
+ * @description
+ * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
+ */
+export declare class QueryLocallyMatchableParser extends QueryParserBase<boolean> {
+    constructor(query: ApiQuery);
+    protected parseEmptyQuery(): boolean;
+    protected parseSubQuery(_key: string, _subQuery: object, _not?: boolean): boolean;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): boolean;
+    protected parseSearchQuery(_value: any, _not: boolean): boolean;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
+    protected parseSimpleQuery(_key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
+    protected parseLinkedToQuery(_linkedTo: ItemType, _query?: ApiQuery, _reverse?: boolean, _not?: boolean): boolean;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
+    private parseConditions;
+}

package/dist/types/classes/QueryMatcher.d.ts

@@ -7,6 +7,10 @@ export declare class QueryMatcher {
     parent: EntryParentNull;
     constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
     private compareValues;
+    /**
+     * @remark
+     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
+     */
     matchQuery(query: ApiQuery): boolean | 'maybe';
     private matchLinkedToQuery;
     private matchComplexQuery;

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

@@ -7,8 +7,7 @@ export declare enum CONSTANTS {
 }
 export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
 export declare class QueryParser extends QueryParserBase<[object, string]> {
-    private parameters;
-    constructor(query: ApiQuery, parameters: object);
+    constructor(query: ApiQuery);
     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];

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

@@ -19,11 +19,11 @@ export declare abstract class QueryParserBase<ReturnType extends any> {
     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;
+    protected abstract parseSubQuery(key: string, subQuery: object, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSearchQuery(value: any, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
 }

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

@@ -0,0 +1,16 @@
+import { ApiQuery, ItemIdConversionMap, ItemType } from '../types';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryParserIdUpdater extends QueryParserBase<void> {
+    private itemIdConversionMap;
+    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
+    protected parseEmptyQuery(): void;
+    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): void;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): void;
+    protected parseSearchQuery(_value: any, _not: boolean): void;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): void;
+    protected parseSimpleQuery(_key: string, value: any, _comparator: COMPARATORS_TYPE, _not: boolean, queryPart: ApiQuery): void;
+    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): void;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): void;
+    private parseConditions;
+}

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

@@ -1,9 +1,10 @@
-import { ApiQuery, EntryParentNull, ItemId } from '../types';
+import { ApiQuery, EntryParentNull, ItemId, ItemType } from '../types';
 import { KeyService } from './KeyService';
 import { COMPARATORS } from './QueryParserBase';
 export declare class QueryService {
     private keyService;
     constructor(keyService: KeyService);
+    containsLinkedTo(query: ApiQuery, matchItemType: ItemType, matchItemId: ItemId): boolean;
     containsLocalLinkedTo(query: ApiQuery): boolean;
     addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
     addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;

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

@@ -4,8 +4,8 @@ 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 {
+export declare type RequestBufferResponse<ItemTypeType extends ItemType = any> = ApiResponseProcessor<ItemTypeType>;
+export declare class RequestBuffer<ItemTypeType extends ItemType = any> {
     private promiseLibrary;
     private apiRequestService;
     private requestColumnExpansionFactory;
@@ -16,13 +16,13 @@ export declare class RequestBuffer {
     private requestColumnExpansion;
     private singleItemIds;
     private queries;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemType);
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemTypeType);
     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>;
+    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     private hasMultipleQueries;
     private getFirstQueryString;
 }

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

@@ -21,4 +21,5 @@ export declare class RequestBufferManager {
     fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
     requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     private constructBuffer;
+    private _constructBuffer;
 }

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

@@ -1,4 +1,4 @@
-import { ColumnSet, ColumnUtil } from '../classes';
+import { ColumnSet, ColumnUtil, RequestColumnMergeResult } from '../classes';
 import { ApiRequestColumns, ItemType } from '../types';
 declare type RequestColumnMap = {
     [itemType: string]: ApiRequestColumns;
@@ -8,7 +8,7 @@ export declare class RequestColumnExpansion {
     private columns;
     private columnSetIdMap;
     constructor(columnUtil: ColumnUtil);
-    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): void;
+    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): RequestColumnMergeResult;
     expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
     get(): RequestColumnMap;
 }

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

@@ -1,11 +1,17 @@
 import { ApiFormatter, ApiRequestService } from '../classes';
-import { RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
+import { QueryMatcherFactory, RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionMatchResult, ItemType, SocketMessage } from '../types';
+import { ItemType, SocketMessage } from '../types';
+import { CachedQueryItem } from './cache/CachedQueryHandlerBase';
 import { RequestBufferManager } from './RequestBufferManager';
-export declare type SocketCollectionMap<ItemTypeType extends ItemType> = {
-    [itemId: number]: CollectionMatchResult<ItemTypeType>;
+export declare type CachedQueryMatchingResult<ItemTypeType extends ItemType> = {
+    fitting: Array<CachedQueryItem<ItemTypeType>>;
+    notfitting: Array<CachedQueryItem<ItemTypeType>>;
+    maybe: Array<CachedQueryItem<ItemTypeType>>;
+};
+export declare type CachedQueryMatchingResultItemIdMap<ItemTypeType extends ItemType> = {
+    [itemId: number]: CachedQueryMatchingResult<ItemTypeType>;
 };
 export declare class SocketMessageHandler {
     private requestBufferManager;
@@ -16,10 +22,12 @@ export declare class SocketMessageHandler {
     private promiseService;
     private requestColumnExpansionFactory;
     private apiRequestService;
-    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
+    private queryMatcherFactory;
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory);
     onMessageReceived(message: SocketMessage): any;
     private formatMessageValues;
-    private createCollectionMap;
+    private createQueriesWithFittingItemsMap;
+    private getCachedQueriesByFittingItem;
     private getRequestColumns;
     private processMessage;
     private processFunctionChangesResolve;

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

@@ -1,46 +1,48 @@
 import { RmCore } from '../../core';
 import { AbstractCacheDependencyInterface } from '../../interfaces';
-import { CollectionEntry, ItemEntry } from '../../models';
-import { EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../types';
+import { ItemEntry } from '../../models';
+import { ApiRequestColumn, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../types';
 import { ChangesDelta } from '../ChangesDelta';
 import { ChangesDeltaResult } from '../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../ChangesProcessor';
-import { CollectionCache } from '../CollectionCache';
 import { InternalChangesDelta } from '../InternalChangesDelta';
 import { ItemCache } from '../ItemCache';
+import { CachedQueryItem } from './CachedQueryHandlerBase';
+import { ItemHandlerBase } from './ItemHandlerBase';
 import { ServerCache } from './server/ServerCache';
-import { ServerCollectionHandler } from './server/ServerCollectionHandler';
-import { ServerItemEntryChanges, ServerItemHandler } from './server/ServerItemHandler';
+import { ServerCachedQueryHandler } from './server/ServerCachedQueryHandler';
+import { ServerItemEntryChanges } from './server/ServerItemHandler';
 import { TransactionCache } from './transaction/TransactionCache';
-import { TransactionCollectionHandler } from './transaction/TransactionCollectionHandler';
-import { TransactionItemEntryChanges, TransactionItemHandler } from './transaction/TransactionItemHandler';
+import { TransactionCachedQueryHandler } from './transaction/TransactionCachedQueryHandler';
+import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
 import { TransactionValidatorFactory } from './transaction/TransactionValidator';
 export declare abstract class AbstractCache {
-    protected dependencies: AbstractCacheDependencyInterface;
+    dependencies: AbstractCacheDependencyInterface;
     core: RmCore;
     children: TransactionCache[];
-    readonly itemHandler: TransactionItemHandler | ServerItemHandler;
-    readonly collectionHandler: TransactionCollectionHandler | ServerCollectionHandler;
+    readonly itemHandler: ItemHandlerBase;
+    readonly cachedQueryHandler: TransactionCachedQueryHandler | ServerCachedQueryHandler;
     parent: AbstractCache | null;
     protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
+    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
-    abstract getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
     /**
      * @description
-     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
+     * Expands the items in the collections with the passed columns
+     *
+     * todo[limit] move to TransactionCache ?
      */
-    abstract getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
+    abstract expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     /**
      * @description
-     * Returns this transaction and all parents
+     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
      */
-    getTransactionChain(): AbstractCache[];
+    abstract getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
     /**
      * @description
-     * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction
+     * Returns this transaction and all parents
      */
-    getCurrentCollectionEntryCache(): CollectionCache;
+    getTransactionChain(): AbstractCache[];
     /**
      * @description
      * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
@@ -49,7 +51,6 @@ export declare abstract class AbstractCache {
     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

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

@@ -0,0 +1,73 @@
+import { RequestColumnExpansionFactory } from '../../factories';
+import { Deferred, PromiseLibraryInterface } from '../../interfaces';
+import { ItemEntry } from '../../models';
+import { CollectionOptions } from '../../models/CollectionOptions';
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ItemId, ItemType, ParentIdMap, PromiseInterface } from '../../types';
+import { CollectionEntryService } from '../CollectionEntryService';
+import { ColumnSubsetCache } from '../ColumnSubsetCache';
+import { ColumnUtil } from '../ColumnUtil';
+import { AbstractCache } from './AbstractCache';
+export declare type CachedQueryItem<ItemTypeType extends ItemType = any> = {
+    itemType: ItemTypeType;
+    query: CollectionQuery;
+    items: Array<ItemEntry<ItemTypeType>>;
+    requestColumns: ApiRequestColumns;
+    deferred: Deferred<CachedQueryItem<ItemTypeType>>;
+    promise: PromiseInterface<CachedQueryItem<ItemTypeType>>;
+};
+export declare abstract class CachedQueryHandlerBase {
+    protected collectionEntryService: CollectionEntryService;
+    protected columnUtil: ColumnUtil;
+    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    protected promiseService: PromiseLibraryInterface;
+    protected transaction: AbstractCache;
+    /**
+     * @description
+     * Items (per ItemType) that fit in a query
+     *
+     * @remark
+     * Contains the requestColumns so that new items can include these columns (saving requests when they match)
+     */
+    cachedQueries: {
+        [itemType: string]: {
+            [queryString: string]: CachedQueryItem;
+        };
+    };
+    protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, promiseService: PromiseLibraryInterface, transaction: AbstractCache);
+    setCachedQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
+    getCachedQueryItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string): undefined | Array<ItemEntry<ItemTypeType>>;
+    getCachedQueryObjectsByItemType(itemType: ItemType): CachedQueryItem[];
+    initCachedQuery<ItemTypeType extends ItemType = string>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
+    /**
+     * @description
+     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
+     */
+    abstract __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     */
+    abstract __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     */
+    abstract __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    /**
+     * @description
+     * Adds the passed {@link ItemEntry ItemEntries} to the Transaction's query cache,
+     * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
+     */
+    protected __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
+    /**
+     * @description
+     * Removes the passed {@link ItemId ItemIds} from the Transaction's query cache
+     */
+    __removeItemEntriesFromCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemEntry<ItemTypeType>>;
+    /**
+     * @description
+     * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CollectionMatcherCachedCollectionProcessor CollectionMatcher} 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(itemType: ItemType, options: CollectionOptions, query: ApiQuery): void;
+}

package/dist/types/classes/cache/CollectionMatcherCachedQueryProcessor.d.ts

@@ -0,0 +1,35 @@
+import { QueryMatcherFactory } from '../../factories';
+import { PromiseLibraryInterface } from '../../interfaces';
+import { ItemEntry } from '../../models';
+import { CollectionQuery, ItemType, PromiseInterface } from '../../types';
+import { ApiRequestService } from '../ApiRequestService';
+import { ChangesDeltaBase } from '../ChangesDeltaBase';
+import { CollectionMatcherBase, CollectionMatcherMatches } from '../CollectionMatcherBase';
+import { QueryService } from '../QueryService';
+import { AbstractCache } from './AbstractCache';
+import { CachedQueryItem } from './CachedQueryHandlerBase';
+export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
+    fitting: Array<ItemEntry<ItemTypeType>>;
+    notFitting: Array<ItemEntry<ItemTypeType>>;
+    maybe: Array<ItemEntry<ItemTypeType>>;
+};
+/**
+ * @description
+ * Processes all cached queries and adds/removes item entries that do/don't fit the query
+ */
+export declare class CollectionMatcherCachedQueryProcessor extends CollectionMatcherBase {
+    private apiRequestService;
+    private promiseService;
+    private getQueries;
+    protected map: {
+        [itemTypeAndQueryString: string]: {
+            itemType: ItemType;
+            query: CollectionQuery;
+            matches: CollectionMatcherMatches;
+            cachedQuery: CachedQueryItem;
+        };
+    };
+    constructor(apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getQueries: (itemType: ItemType) => CachedQueryItem[]);
+    __removeFromAndAddToCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
+    protected _expand<ItemTypeType extends ItemType = string>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+}

package/dist/types/classes/cache/ItemHandlerBase.d.ts

@@ -32,8 +32,6 @@ export declare abstract class ItemHandlerBase {
     /**
      * @description
      * Fetches the ItemEntries for the given query, does not look in the cache, since we don't know which ItemIds belong to the query !
-     *
-     * todo: We could store collections by their query string, and then see if the query is already cached
      */
     abstract fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
@@ -50,7 +48,7 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Processes the passed {@link ChangesDeltaItemUpdateDelta update delta} on the transaction, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed
      */
-    abstract processItemEntryChanges(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): void;
+    abstract processItemEntryChanges<ItemTypeType extends ItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): FieldMap<ItemTypeType> | null;
     /**
      * @description
      * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
@@ -85,11 +83,11 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}
      */
-    protected createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
      * Gets the value of the given column, will look into the current delta before attempting to read itemChanges
      */
     protected getItemIdByColumn<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
-    protected expandColumnsWithCollectionColumns(itemType: ItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
+    protected expandColumnsWithCachedQueryColumns(itemType: ItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
 }