@rentman/rm-core 6.0.2 → 6.1.2

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

@@ -1,102 +1,102 @@
-import { RmCore } from '../../core';
-import { AbstractCacheDependencyInterface } from '../../interfaces';
-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 { InternalChangesDelta } from '../InternalChangesDelta';
-import { ItemCache } from '../ItemCache';
-import { CachedQueryItem } from './CachedQueryHandlerBase';
-import { ItemHandlerBase } from './ItemHandlerBase';
-import { ServerCache } from './server/ServerCache';
-import { ServerCachedQueryHandler } from './server/ServerCachedQueryHandler';
-import { ServerItemEntryChanges } from './server/ServerItemHandler';
-import { TransactionCache } from './transaction/TransactionCache';
-import { TransactionCachedQueryHandler } from './transaction/TransactionCachedQueryHandler';
-import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
-import { TransactionValidatorFactory } from './transaction/TransactionValidator';
-export declare abstract class AbstractCache {
-    dependencies: AbstractCacheDependencyInterface;
-    core: RmCore;
-    children: TransactionCache[];
-    readonly itemHandler: ItemHandlerBase;
-    readonly cachedQueryHandler: TransactionCachedQueryHandler | ServerCachedQueryHandler;
-    parent: AbstractCache | null;
-    protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
-    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
-    onChildDestroy(cache: TransactionCache): void;
-    /**
-     * @description
-     * Expands the items in the collections with the passed columns
-     *
-     * todo[limit] move to TransactionCache ?
-     */
-    abstract expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    /**
-     * @description
-     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
-     */
-    abstract getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
-    /**
-     * @description
-     * Returns this transaction and all parents
-     */
-    getTransactionChain(): AbstractCache[];
-    /**
-     * @description
-     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
-     */
-    getCurrentItemEntryCache(): ItemCache;
-    abstract getServerCache(): ServerCache;
-    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    abstract getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    /**
-     * @description
-     * Applies changes from a child transaction to a parent
-     */
-    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
-    /**
-     * @description
-     * Called by a parent transaction, propagates changes downwards to all child caches
-     *
-     * @remarks
-     * - Should only be used by the core
-     *
-     * todo[cache] Should we refetch derived values just like in applyChangesDelta ?
-     *
-     * @internal
-     */
-    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
-    abstract getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
-    abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
-    /**
-     * @description
-     * Because the `itemChanges` object differs between the {@link ServerItemHandler.itemChanges ServerItemHandler} and the {@link TransactionItemHandler.itemChanges TransactionItemHandler} we need a function to normalise those values
-     *
-     * @remarks
-     * - Should only be used by the core
-     *
-     * @internal
-     */
-    abstract getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
-    abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
-    protected getParentFromFields<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParentNull;
-    /**
-     * @description
-     * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
-     *
-     * @private
-     */
-    protected _applyChangesDelta(changesDelta: ChangesDelta): {
-        result: ChangesDeltaResult;
-        internalChangesDelta: InternalChangesDelta;
-        rollbackFunctions: Array<(changesDelta: ChangesDelta) => void>;
-    };
-    /**
-     * @description
-     * Ensures that for all updated items in the delta the required derived values are present
-     */
-    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDelta): PromiseInterface<ItemEntry[][]>;
-}
+import { RmCore } from '../../core';
+import { AbstractCacheDependencyInterface } from '../../interfaces';
+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 { InternalChangesDelta } from '../InternalChangesDelta';
+import { ItemCache } from '../ItemCache';
+import { CachedQueryItem } from './CachedQueryHandlerBase';
+import { ItemHandlerBase } from './ItemHandlerBase';
+import { ServerCache } from './server/ServerCache';
+import { ServerCachedQueryHandler } from './server/ServerCachedQueryHandler';
+import { ServerItemEntryChanges } from './server/ServerItemHandler';
+import { TransactionCache } from './transaction/TransactionCache';
+import { TransactionCachedQueryHandler } from './transaction/TransactionCachedQueryHandler';
+import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
+import { TransactionValidatorFactory } from './transaction/TransactionValidator';
+export declare abstract class AbstractCache {
+    dependencies: AbstractCacheDependencyInterface;
+    core: RmCore;
+    children: TransactionCache[];
+    readonly itemHandler: ItemHandlerBase;
+    readonly cachedQueryHandler: TransactionCachedQueryHandler | ServerCachedQueryHandler;
+    parent: AbstractCache | null;
+    protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
+    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
+    onChildDestroy(cache: TransactionCache): void;
+    /**
+     * @description
+     * Expands the items in the collections with the passed columns
+     *
+     * todo[limit] move to TransactionCache ?
+     */
+    abstract expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    /**
+     * @description
+     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
+     */
+    abstract getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Returns this transaction and all parents
+     */
+    getTransactionChain(): AbstractCache[];
+    /**
+     * @description
+     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
+     */
+    getCurrentItemEntryCache(): ItemCache;
+    abstract getServerCache(): ServerCache;
+    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    abstract getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    /**
+     * @description
+     * Applies changes from a child transaction to a parent
+     */
+    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
+    /**
+     * @description
+     * Called by a parent transaction, propagates changes downwards to all child caches
+     *
+     * @remarks
+     * - Should only be used by the core
+     *
+     * todo[cache] Should we refetch derived values just like in applyChangesDelta ?
+     *
+     * @internal
+     */
+    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
+    abstract getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
+    abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
+    /**
+     * @description
+     * Because the `itemChanges` object differs between the {@link ServerItemHandler.itemChanges ServerItemHandler} and the {@link TransactionItemHandler.itemChanges TransactionItemHandler} we need a function to normalise those values
+     *
+     * @remarks
+     * - Should only be used by the core
+     *
+     * @internal
+     */
+    abstract getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+    abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    protected getParentFromFields<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParentNull;
+    /**
+     * @description
+     * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
+     *
+     * @private
+     */
+    protected _applyChangesDelta(changesDelta: ChangesDelta): {
+        result: ChangesDeltaResult;
+        internalChangesDelta: InternalChangesDelta;
+        rollbackFunctions: Array<(changesDelta: ChangesDelta) => void>;
+    };
+    /**
+     * @description
+     * Ensures that for all updated items in the delta the required derived values are present
+     */
+    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDelta): PromiseInterface<ItemEntry[][]>;
+}

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

@@ -1,73 +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;
-}
+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

@@ -1,35 +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;
-}
+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

@@ -1,93 +1,93 @@
-import { ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
-import { ItemEntry, ItemEntryOptions } from '../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../types';
-import { ApiFormatter } from '../ApiFormatter';
-import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
-import { ColumnInfo } from '../ColumnInfo';
-import { ColumnUtil } from '../ColumnUtil';
-import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
-import { ItemCache } from '../ItemCache';
-import { AbstractCache } from './AbstractCache';
-import { ServerItemEntryChanges } from './server/ServerItemHandler';
-import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
-export declare abstract class ItemHandlerBase {
-    protected columnUtil: ColumnUtil;
-    protected apiFormatter: ApiFormatter;
-    protected itemEntryFactory: ItemEntryFactory;
-    protected promiseService: PromiseLibraryInterface;
-    protected errorHandler: ErrorHandlerInterface;
-    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    protected transaction: AbstractCache;
-    readonly entries: ItemCache;
-    abstract itemChanges: ServerItemEntryChanges | TransactionItemEntryChanges;
-    protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
-    /**
-     * @description
-     * Copies the passed ItemEntryChanges into a format the implementing ItemHandler can put in his ItemChanges
-     * @param itemEntryChanges
-     * @param entry
-     */
-    abstract copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): any;
-    /**
-     * @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 !
-     */
-    abstract fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the ItemEntries for the given ItemIds
-     */
-    abstract fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches an ItemEntry with the given itemId
-     */
-    abstract fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    /**
-     * @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<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
-     *
-     * ---------------------
-     *
-     * @remark
-     * Assumes the derived item's values are already cached
-     */
-    getDerivedValues(itemEntry: ItemEntry, columnPath: string[]): Readonly<FieldMap> | undefined;
-    /**
-     * @description
-     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
-     *
-     * @param itemEntry The root entry to start the path from
-     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
-     */
-    getDerivedValue<T extends any = any>(itemEntry: ItemEntry, columnPath: string[] | string): T | undefined;
-    /**
-     * @description
-     * Clears the entry from this transaction, removing it from the {@link ItemCache ItemCache} and removing all changes
-     */
-    clearItemEntry(entry: ItemEntry): void;
-    /**
-     * @description
-     * Recursively fetches derived values as separate requests, instead of as columns of a primary item
-     * Can be used when derived values of a local item have to be fetched, since a local item can't be used as root item of a query
-     */
-    fetchDerivedValuesByColumn<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, changesDelta?: ChangesDeltaBase): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}
-     */
-    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 expandColumnsWithCachedQueryColumns(itemType: ItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
-}
+import { ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
+import { ItemEntry, ItemEntryOptions } from '../../models';
+import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../types';
+import { ApiFormatter } from '../ApiFormatter';
+import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
+import { ColumnInfo } from '../ColumnInfo';
+import { ColumnUtil } from '../ColumnUtil';
+import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
+import { ItemCache } from '../ItemCache';
+import { AbstractCache } from './AbstractCache';
+import { ServerItemEntryChanges } from './server/ServerItemHandler';
+import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
+export declare abstract class ItemHandlerBase {
+    protected columnUtil: ColumnUtil;
+    protected apiFormatter: ApiFormatter;
+    protected itemEntryFactory: ItemEntryFactory;
+    protected promiseService: PromiseLibraryInterface;
+    protected errorHandler: ErrorHandlerInterface;
+    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    protected transaction: AbstractCache;
+    readonly entries: ItemCache;
+    abstract itemChanges: ServerItemEntryChanges | TransactionItemEntryChanges;
+    protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
+    /**
+     * @description
+     * Copies the passed ItemEntryChanges into a format the implementing ItemHandler can put in his ItemChanges
+     * @param itemEntryChanges
+     * @param entry
+     */
+    abstract copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): any;
+    /**
+     * @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 !
+     */
+    abstract fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the ItemEntries for the given ItemIds
+     */
+    abstract fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches an ItemEntry with the given itemId
+     */
+    abstract fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    /**
+     * @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<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
+     *
+     * ---------------------
+     *
+     * @remark
+     * Assumes the derived item's values are already cached
+     */
+    getDerivedValues(itemEntry: ItemEntry, columnPath: string[]): Readonly<FieldMap> | undefined;
+    /**
+     * @description
+     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
+     *
+     * @param itemEntry The root entry to start the path from
+     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
+     */
+    getDerivedValue<T extends any = any>(itemEntry: ItemEntry, columnPath: string[] | string): T | undefined;
+    /**
+     * @description
+     * Clears the entry from this transaction, removing it from the {@link ItemCache ItemCache} and removing all changes
+     */
+    clearItemEntry(entry: ItemEntry): void;
+    /**
+     * @description
+     * Recursively fetches derived values as separate requests, instead of as columns of a primary item
+     * Can be used when derived values of a local item have to be fetched, since a local item can't be used as root item of a query
+     */
+    fetchDerivedValuesByColumn<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | Array<ItemEntry<ItemTypeType>>>;
+    resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, changesDelta?: ChangesDeltaBase): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}
+     */
+    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 expandColumnsWithCachedQueryColumns(itemType: ItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
+}