@rentman/rm-core 5.0.1 → 6.0.0

package/dist/types/classes/cache/server/ServerCache.d.ts

@@ -1,15 +1,14 @@
+import { ChangesDelta, InternalChangesDelta, TransactionCache, TransactionValidatorFactory } from '../..';
 import { RmCore } from '../../../core';
-import { ServerCacheDependencyInterface } from '../../../interfaces';
-import { CollectionEntry, ItemEntry } from '../../../models';
-import { ApiRequestColumnMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../../types';
+import { ServerCacheDependencyInterface } from '../../../interfaces/ServerCacheDependencyInterface';
+import { ItemEntry } from '../../../models';
+import { ApiRequestColumn, ApiRequestColumnMap, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../../types';
 import { ApiResponseProcessor } from '../../ApiResponseProcessor';
-import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
-import { InternalChangesDelta } from '../../InternalChangesDelta';
 import { AbstractCache } from '../AbstractCache';
-import { TransactionCache } from '../transaction/TransactionCache';
-import { ServerCollectionHandler } from './ServerCollectionHandler';
+import { CachedQueryItem } from '../CachedQueryHandlerBase';
+import { ServerCachedQueryHandler } from './ServerCachedQueryHandler';
 import { ServerItemEntryChanges, ServerItemHandler } from './ServerItemHandler';
 /**
  * @description
@@ -19,18 +18,20 @@ import { ServerItemEntryChanges, ServerItemHandler } from './ServerItemHandler';
  * It's basically a local representation of the database
  */
 export declare class ServerCache extends AbstractCache {
-    protected dependencies: ServerCacheDependencyInterface;
+    dependencies: ServerCacheDependencyInterface;
     readonly itemHandler: ServerItemHandler;
-    readonly collectionHandler: ServerCollectionHandler;
+    readonly cachedQueryHandler: ServerCachedQueryHandler;
     parent: null;
     constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
     getServerCache(): ServerCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
+    expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
     /**
      * @description
      * Applies the changes of the changesDelta created by the API call ({@link ChangesProcessor ChangesProcessor}/{@link SocketMessageHandler SocketMessageHandler}, or manually through a module function) on all caches
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): void;
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
     /**
      * @description
      * Gets the fields required to set the parent
@@ -57,7 +58,7 @@ export declare class ServerCache extends AbstractCache {
         entry: ItemEntry;
         changes: ServerItemEntryChanges;
     };
-    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
+    getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
     /**
      * @description
      * Invalidates the complete server cache, all items will be re-fetched whenever they are requested
@@ -77,7 +78,5 @@ export declare class ServerCache extends AbstractCache {
     applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
-    getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
 }

package/dist/types/classes/cache/server/ServerCachedQueryHandler.d.ts

@@ -0,0 +1,34 @@
+import { ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
+import { ApiRequestColumns, ApiRequestService, CollectionQuery, ColumnSubsetCache, ColumnUtil, ParentIdMap, PromiseInterface } from '../../../index';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ItemEntry } from '../../../models';
+import { CollectionOptions } from '../../../models/CollectionOptions';
+import { ItemId, ItemType } from '../../../types';
+import { CollectionEntryService } from '../../index';
+import { RequestBufferManager } from '../../RequestBufferManager';
+import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
+import { ServerCache } from './ServerCache';
+import { ServerItemHandler } from './ServerItemHandler';
+export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
+    private columnSubsetCacheFactory;
+    private requestBufferManager;
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    protected transaction: ServerCache;
+    constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, transaction: ServerCache);
+    __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    /**
+     * @description
+     * Expands the columns of the items in the cached query
+     */
+    __expandCachedQuery<ItemTypeType extends ItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/options, will do nothing if the requested CollectionEntry/columns are already cached.
+     * Will create a new {@link CollectionEntry CollectionEntry} if the CollectionEntry didn't exist yet
+     */
+    __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+}

package/dist/types/classes/cache/server/ServerItemHandler.d.ts

@@ -28,6 +28,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): ServerItemEntryChanges;
     fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    extendItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, newColumns: ApiRequestColumns): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
@@ -35,7 +36,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      *
      * @param columns should contain a derived column that refers to the parent
      */
-    fetchLinkedItemEntriesData(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchLinkedItemEntriesData(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery | null, columns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     /**
      * @description
      * General way to process an API response.

package/dist/types/classes/cache/transaction/TransactionCache.d.ts

@@ -1,14 +1,16 @@
+import { ChangesDelta, InternalChangesDelta, ServerCache, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../..';
 import { RmCore } from '../../../core';
 import { AbstractCacheDependencyInterface } from '../../../interfaces/AbstractCacheDependencyInterface';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
-import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
-import { ChangesDelta } from '../../ChangesDelta';
+import { CollectionResource, ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
+import { CollectionOptionsInterface } from '../../../models/CollectionOptions';
+import { ApiQuery, ApiRequestColumn, ApiRequestColumns, CollectionDefinition, CollectionQuery, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { ModuleChangesCompilationResult, OnAfterCreateCallback, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
-import { InternalChangesDelta } from '../../InternalChangesDelta';
+import { OnAfterCreateCallback } from '../../ChangesProcessor';
+import { ModuleChangesCompilationResult } from '../../ModuleChangesCompilation';
 import { AbstractCache } from '../AbstractCache';
-import { ServerCache } from '../server/ServerCache';
-import { TransactionEventHandler } from './TransactionEventHandler';
+import { CachedQueryItem } from '../CachedQueryHandlerBase';
+import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
+import { TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionEventHandler } from './TransactionEventHandler';
 declare type ItemResourceLinks<ItemTypeType extends ItemType> = {
     main: ItemResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
@@ -59,7 +61,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Stores the 'root' {@link ItemEntry ItemEntry}, this {@link ItemEntry ItemEntry} can be used as request parent to store the whole transaction at once
      */
-    rootItem: ItemEntry<any> | undefined;
+    rootItem: ItemEntry | undefined;
     /**
      * @description
      * Stores additional request parameters for when the transaction is stored to the server
@@ -84,6 +86,7 @@ export declare class TransactionCache extends AbstractCache {
      */
     readonly parent: AbstractCache;
     readonly itemHandler: TransactionItemHandler;
+    readonly cachedQueryHandler: TransactionCachedQueryHandler;
     readonly collectionHandler: TransactionCollectionHandler;
     readonly eventHandler: TransactionEventHandler;
     private readonly validator?;
@@ -94,7 +97,14 @@ export declare class TransactionCache extends AbstractCache {
      * For debugging purposes
      */
     id?: string | undefined, validatorFactory?: TransactionValidatorFactory);
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     destroy(): void;
+    expandCollectionResource(collectionResource: CollectionResource, newColumns: ApiRequestColumns): PromiseInterface<void>;
+    /**
+     * @description
+     * Expands the collection with the new request columns, assumes that all collections have the same itemType
+     */
+    expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     createChangesDelta(): ChangesDelta;
     getFirstErrorString(): undefined | string;
@@ -131,7 +141,7 @@ export declare class TransactionCache extends AbstractCache {
      * @param internalChangesDelta Changes to be applied
      * @param isCalledAfterApiSave If 'isCalledAfterApiSave' is true local changes will always be overwritten (instead of only when there are no changes)
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): void;
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
     /**
      * @description
      * Applies changes to this transaction and its children
@@ -159,7 +169,7 @@ export declare class TransactionCache extends AbstractCache {
      * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
      */
     getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
+    getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
     /**
      * @description
      * Traverses the transaction chain and returns the changes of the item on the first transaction
@@ -173,7 +183,7 @@ export declare class TransactionCache extends AbstractCache {
      * You should call this function when the resource is no longer needed
      *
      * @remark
-     * Does not remove changes
+     * Does not remove cached queries
      */
     clearCollectionResource(resource: CollectionResource): void;
     /**
@@ -210,11 +220,6 @@ export declare class TransactionCache extends AbstractCache {
      * Removes an {@link ItemEntry ItemEntry} from the {@link TransactionCache TransactionCache} which means that changes on this entry will no longer be tracked.
      */
     clearItemEntry(itemEntry: ItemEntry<any>): void;
-    /**
-     * @description
-     * Removes a {@link CollectionEntry CollectionEntry} through a {@link CollectionResource CollectionResource} from the {@link TransactionCache TransactionCache} which means that changes on this collection will no longer be tracked.
-     */
-    clearCollection(collectionResource: CollectionResource<any>): void;
     /**
      * @description
      * Adds a callback that will fire before the transaction is saved, rejecting this callback will prevent the transaction from saving
@@ -303,16 +308,6 @@ export declare class TransactionCache extends AbstractCache {
      * Gets an ItemEntry from the cache by ItemId
      */
     getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    /**
-     * @description
-     * Gets an CollectionEntry from the cache, doesn't do a API request, used for saving
-     */
-    getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
-    /**
-     * @description
-     * Gets an CollectionEntry from the cache, doesn't do a API request, used for saving
-     */
-    getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
     /**
      * @description
      * Returns the complete {@link InternalChangesDelta InternalChangesDelta} of the TransactionCache, this only takes into account the end result (initial is compared to changes), so changing something and reverting it
@@ -322,9 +317,8 @@ export declare class TransactionCache extends AbstractCache {
     createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
     createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType>>;
     processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResource<ItemTypeType>;
+    createCollectionResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
-    private createCollectionResources;
     /**
      * @description
      * Fetches all required columns to match/fit in collections

package/dist/types/classes/cache/transaction/TransactionCachedQueryHandler.d.ts

@@ -0,0 +1,23 @@
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
+import { ItemEntry } from '../../../models';
+import { CollectionOptions } from '../../../models/CollectionOptions';
+import { ItemId, ItemType } from '../../../types';
+import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
+import { TransactionCache } from './TransactionCache';
+export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
+    private dependencies;
+    private itemHandler;
+    protected transaction: TransactionCache;
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    /**
+     * @remark
+     * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
+     * ({<field>: <localId>}) is also a local query
+     */
+    isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+}

package/dist/types/classes/cache/transaction/TransactionCollectionHandler.d.ts

@@ -1,21 +1,22 @@
-import { ApiQuery, ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ItemEntryOptions, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
-import { CollectionEntry, ItemEntry } from '../../../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
-import { CollectionMatcher } from '../../index';
-import { CollectionHandlerBase } from '../CollectionHandlerBase';
+import { TransactionCollectionHandlerDependencyInterface } from '../../../interfaces/TransactionCollectionHandlerDependencyInterface';
+import { CollectionEntry, CollectionResource, ItemEntry } from '../../../models';
+import { ApiRequestColumns, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
 import { TransactionCache } from './TransactionCache';
-export declare class TransactionCollectionHandler extends CollectionHandlerBase {
+import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
+import { TransactionItemHandler } from './TransactionItemHandler';
+export declare class TransactionCollectionHandler {
+    protected itemHandler: TransactionItemHandler;
+    protected cachedQueryHandler: TransactionCachedQueryHandler;
     private dependencies;
-    private itemHandler;
-    protected transaction: TransactionCache;
+    private transaction;
     collectionResources: {
-        [collectionEntryId: number]: CollectionResource[];
+        [itemType: string]: {
+            [queryString: string]: CollectionResource[];
+        };
     };
-    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
-    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    getAllCollectionsByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): Array<CollectionEntry<ItemTypeType>>;
-    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
-    clearEntry(entry: CollectionEntry): void;
+    constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
+    expandCollectionResource<ItemTypeType extends ItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
     addResource(resource: CollectionResource): void;
     clearResource(resource: CollectionResource): void;
     /**
@@ -23,31 +24,5 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
      * Updates the parents of the passed {@link ItemEntry ItemEntries}, returns `void` because you should use the {@link CollectionResourceOptions.onAdd onAdd} and {@link CollectionResourceOptions.onRemove onRemove} callbacks
      */
     moveItems<CollectionEntryType extends CollectionEntry>(sourceCollectionEntry: CollectionEntryType, destinationCollectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
     cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
-    getCollectionMatcher(): CollectionMatcher;
-    fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
-    fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
-    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
-    isLocal(options: CollectionEntryOptions | ItemEntryOptions, query: ApiQuery): boolean;
-    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
-    /**
-     * @description
-     * When {@link ItemEntry ItemEntries} are added to the changes of a {@link CollectionEntry CollectionEntry} all {@link CollectionResource CollectionResources}
-     * should get new {@link ItemResource ItemResources} for the newly added entries
-     */
-    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    /**
-     * @description
-     * When {@link ItemEntry ItemEntries} are removed from the changes of a {@link CollectionEntry CollectionEntry} the {@link ItemResource ItemResources} of the ItemEntries should be removed from all {@link CollectionResource CollectionResources}
-     */
-    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    private fetchCollectionData;
-    /**
-     * @description
-     * Fetches {@link CollectionEntry CollectionEntries} of which the parents are local
-     */
-    private fetchLinkedLocalCollectionEntries;
 }

package/dist/types/classes/cache/transaction/TransactionItemHandler.d.ts

@@ -14,7 +14,7 @@ export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType =
 /**
  * @description
  * In a {@link TransactionCache Transaction} only local items can be stored, so all entries in {@link TransactionItemHandler.entries this.entries} are local
- * If a non-local entry is requested it should be passed on to the {@link ServerItemHandler ServerItemHandler} which will fetchCollectionEntry the entry from the server
+ * If a non-local entry is requested it should be passed on to the {@link ServerItemHandler ServerItemHandler} which will __fetchCachedQueryItem the entry from the server
  */
 export declare class TransactionItemHandler extends ItemHandlerBase {
     private dependencies;
@@ -77,7 +77,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
-     * Fetches the data for the passed ItemType/ItemId/columns, is able to fetchCollectionEntry non-local derived values.
+     * Fetches the data for the passed ItemType/ItemId/columns, is able to __fetchCachedQueryItem non-local derived values.
      *
      * @remark
      * Assumes the the ItemEntry with the given ItemType-ItemId is already cached

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

@@ -3,9 +3,8 @@ export * from './ApiRequestService';
 export * from './ApiResponseProcessor';
 export * from './ChangesCompilation';
 export * from './ChangesProcessor';
-export * from './CollectionCache';
 export * from './CollectionEntryService';
-export * from './CollectionMatcher';
+export * from './CollectionMatcherCachedCollectionProcessor';
 export * from './CollectionResourceService';
 export * from './ColumnCache';
 export * from './ColumnExpansion';
@@ -31,9 +30,10 @@ export * from './Util';
 export * from './cache/AbstractCache';
 export * from './cache/server/ServerCache';
 export * from './cache/server/ServerItemHandler';
-export * from './cache/server/ServerCollectionHandler';
+export * from './cache/server/ServerCachedQueryHandler';
 export * from './cache/transaction/TransactionCache';
 export * from './cache/transaction/TransactionItemHandler';
+export * from './cache/transaction/TransactionCachedQueryHandler';
 export * from './cache/transaction/TransactionCollectionHandler';
 export * from './cache/transaction/TransactionEventHandler';
 export * from './cache/transaction/TransactionValidator';

package/dist/types/core.d.ts

@@ -1,7 +1,7 @@
 import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ConversionMapService, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
 import { ItemCreateService } from './classes/ItemCreateService';
 import { TemplateCache } from './classes/TemplateCache';
-import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
+import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
 import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
 import { ChangesProcessorFactory } from './factories/ChangesProcessorFactory';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from './interfaces';
@@ -15,7 +15,6 @@ export declare class RmCore {
     changesCompilationFactory: ChangesCompilationFactory;
     changesDeltaFactory: ChangesDeltaFactory;
     changesProcessorFactory: ChangesProcessorFactory;
-    collectionCacheFactory: CollectionCacheFactory;
     collectionEntryFactory: CollectionEntryFactory;
     collectionEntryService: CollectionEntryService;
     collectionMatcherFactory: CollectionMatcherFactory;

package/dist/types/factories/CollectionEntryFactory.d.ts

@@ -1,11 +1,14 @@
-import { CollectionEntryService, KeyService } from '../classes';
-import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
+import { CollectionEntryService, ColumnCache, KeyService, QueryService } from '../classes';
+import { CollectionEntry } from '../models/';
+import { CollectionOptionsInterface } from '../models/CollectionOptions';
 import { ItemType } from '../types/';
 import { ColumnSetFactory } from './ColumnSetFactory';
 export declare class CollectionEntryFactory {
     private collectionEntryService;
     private columnSetFactory;
     private keyService;
-    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptionsInterface): CollectionEntry<ItemTypeType>;
+    private queryService;
+    private columnCache;
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, queryService: QueryService, columnCache: ColumnCache);
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionEntry<ItemTypeType>;
 }

package/dist/types/factories/CollectionMatcherFactory.d.ts

@@ -1,9 +1,19 @@
-import { CollectionMatcher, ServerCache, TransactionCache } from '../classes';
+import { AbstractCache, ApiRequestService, QueryService } from '../classes';
+import { CachedQueryItem } from '../classes/cache/CachedQueryHandlerBase';
+import { CollectionMatcherCachedQueryProcessor } from '../classes/cache/CollectionMatcherCachedQueryProcessor';
+import { CollectionMatcherCachedCollectionProcessor } from '../classes/CollectionMatcherCachedCollectionProcessor';
 import { QueryMatcherFactory } from '../factories';
-import { CollectionEntry } from '../models';
+import { PromiseLibraryInterface } from '../interfaces';
+import { CollectionResource } from '../models';
 import { ItemType } from '../types';
 export declare class CollectionMatcherFactory {
     private queryMatcherFactory;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(transaction: TransactionCache | ServerCache, getCollectionEntries: <ItemTypeType extends ItemType>(itemType: ItemTypeType) => Array<CollectionEntry<ItemTypeType>>): CollectionMatcher;
+    private queryService;
+    private apiRequestService;
+    private promiseService;
+    constructor(queryMatcherFactory: QueryMatcherFactory, queryService: QueryService, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface);
+    constructCachedCollectionProcessor(transaction: AbstractCache, getCollections: (itemType: ItemType) => {
+        [queryString: string]: CollectionResource[];
+    }): CollectionMatcherCachedCollectionProcessor;
+    constructCachedQueryProcessor(transaction: AbstractCache, getQueries: (itemType: ItemType) => CachedQueryItem[]): CollectionMatcherCachedQueryProcessor;
 }

package/dist/types/factories/CollectionResourceFactory.d.ts

@@ -1,9 +1,12 @@
-import { ItemEntryService, KeyService } from '../classes';
+import { ItemEntryService, KeyService, QueryService } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface } from '../models';
+import { CollectionResource, ItemEntry } from '../models';
+import { CollectionOptionsInterface } from '../models/CollectionOptions';
 import { ItemType } from '../types';
 import { ChangesDeltaFactory } from './ChangesDeltaFactory';
+import { CollectionEntryFactory } from './CollectionEntryFactory';
+import { ColumnSetFactory } from './ColumnSetFactory';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     exceptionHandler: ExceptionHandlerInterface;
@@ -11,6 +14,9 @@ export declare class CollectionResourceFactory {
     promiseService: PromiseLibraryInterface;
     changesDeltaFactory: ChangesDeltaFactory;
     itemEntryService: ItemEntryService;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory, itemEntryService: ItemEntryService);
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, transaction: TransactionCache): CollectionResource<ItemTypeType>;
+    collectionEntryFactory: CollectionEntryFactory;
+    queryService: QueryService;
+    columnSetFactory: ColumnSetFactory;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory, itemEntryService: ItemEntryService, collectionEntryFactory: CollectionEntryFactory, queryService: QueryService, columnSetFactory: ColumnSetFactory);
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, transaction: TransactionCache, initialItemEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
 }

package/dist/types/factories/ColumnSubsetCacheFactory.d.ts

@@ -1,6 +1,7 @@
-import { ColumnSubsetCache } from '../classes';
+import { ColumnSubsetCache, ColumnUtil } from '../classes';
 import { ApiRequestColumns, ItemType } from '../types';
 export declare class ColumnSubsetCacheFactory {
-    constructor();
+    private columnUtil;
+    constructor(columnUtil: ColumnUtil);
     construct<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
 }

package/dist/types/factories/QueryParserFactory.d.ts

@@ -2,5 +2,5 @@ import { QueryParser } from '../classes';
 import { ApiQuery } from '../types';
 export declare class QueryParserFactory {
     constructor();
-    construct(query: ApiQuery, parameters?: any): QueryParser;
+    construct(query: ApiQuery): QueryParser;
 }

package/dist/types/factories/index.d.ts

@@ -1,6 +1,5 @@
 export * from './ApiResponseProcessorFactory';
 export * from './ChangesCompilationFactory';
-export * from './CollectionCacheFactory';
 export * from './CollectionEntryFactory';
 export * from './CollectionMatcherFactory';
 export * from './CollectionResourceFactory';

package/dist/types/interfaces/AbstractCacheDependencyInterface.d.ts

@@ -1,6 +1,6 @@
 import { ApiFormatter, ApiRequestService, CollectionEntryService, ColumnCache, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService, LockService, QueryService, RequestBufferManager } from '../classes';
 import { TemplateCache } from '../classes/TemplateCache';
-import { ChangesDeltaFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../factories';
+import { ChangesDeltaFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../factories';
 import { AuthInterface } from './AuthInterface';
 import { ErrorHandlerInterface } from './ErrorHandlerInterface';
 import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
@@ -11,7 +11,6 @@ export interface AbstractCacheDependencyInterface {
     apiRequestService: ApiRequestService;
     authInterface: AuthInterface;
     changesDeltaFactory: ChangesDeltaFactory;
-    collectionCacheFactory: CollectionCacheFactory;
     collectionEntryFactory: CollectionEntryFactory;
     collectionEntryService: CollectionEntryService;
     collectionMatcherFactory: CollectionMatcherFactory;

package/dist/types/interfaces/TransactionCollectionHandlerDependencyInterface.d.ts

@@ -1,5 +1,5 @@
 import { CollectionEntryService, ColumnHandler, ColumnUtil, KeyService, QueryService } from '../classes';
-import { ChangesDeltaFactory, CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../factories';
+import { ChangesDeltaFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../factories';
 import { ErrorHandlerInterface } from './ErrorHandlerInterface';
 import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
 import { PromiseLibraryInterface } from './PromiseLibraryInterface';
@@ -9,7 +9,6 @@ export interface TransactionCollectionHandlerDependencyInterface {
     columnSubsetCacheFactory: ColumnSubsetCacheFactory;
     columnExpansionFactory: ColumnExpansionFactory;
     changesDeltaFactory: ChangesDeltaFactory;
-    collectionCacheFactory: CollectionCacheFactory;
     collectionEntryService: CollectionEntryService;
     collectionMatcherFactory: CollectionMatcherFactory;
     columnHandler: ColumnHandler;

package/dist/types/models/CollectionEntry.d.ts

@@ -1,24 +1,23 @@
-import { CollectionEntryService, ColumnExpansion, ColumnSet, KeyService } from '../classes';
+import { CollectionEntryService, ColumnCache, ColumnExpansion, ColumnSet, KeyService, QueryService } from '../classes';
 import { ColumnSetFactory } from '../factories';
-import { CollectionEntryOptions } from '../models';
-import { ApiQuery, ApiRequestColumns, CollectionQuery, EntryParentNull, ItemId, ItemType, PromiseInterface, QueryCallback } from '../types';
+import { CollectionQuery, EntryParentNull, ItemType, PromiseInterface } from '../types';
+import { CollectionOptions } from './CollectionOptions';
 export declare class CollectionEntry<ItemTypeType extends ItemType = any> {
     private collectionEntryService;
+    private queryService;
     private columnSetFactory;
     private keyService;
+    private columnCache;
     itemType: ItemTypeType;
-    options: CollectionEntryOptions;
+    options: CollectionOptions;
     id: number;
     parent: EntryParentNull;
     query: CollectionQuery;
     columns: ColumnSet<ItemTypeType>;
     reloadQueued: boolean;
     promise: PromiseInterface<this>;
-    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, itemType: ItemTypeType, options: CollectionEntryOptions);
+    constructor(collectionEntryService: CollectionEntryService, queryService: QueryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, columnCache: ColumnCache, itemType: ItemTypeType, options: CollectionOptions);
     isLocal(): boolean;
-    matchParent(itemType: ItemType, itemId: ItemId): boolean;
-    extendQuery(callback?: QueryCallback): ApiQuery;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
-    expandRequestColumns(requestColumns: ApiRequestColumns): void;
 }

package/dist/types/models/CollectionOptions.d.ts

@@ -0,0 +1,18 @@
+import { CollectionResource, ItemResource } from '../models';
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull, FieldChangeCallback, ItemType } from '../types';
+export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionOptions<ItemTypeType>>;
+export declare class CollectionOptions<ItemTypeType extends ItemType = any> {
+    columns: ApiRequestColumns;
+    query: ApiQuery | null;
+    queryColumns: ApiRequestColumns;
+    parent: EntryParentNull;
+    limit: ApiRequestLimit | null;
+    onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
+    onRemove: CollectionResourceCallback<ItemTypeType>;
+    onChange: FieldChangeCallback;
+    custom: any;
+    callOnAddWithInitialItems: boolean;
+    constructor(values: CollectionOptionsInterface<ItemTypeType>);
+}