@rentman/rm-core 4.0.1 → 4.0.3

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

@@ -1,95 +1,95 @@
-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 !
-     *
-     * 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>>>;
-    /**
-     * @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(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): void;
-    /**
-     * @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}
-     */
-    protected 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;
-}
+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 !
+     *
+     * 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>>>;
+    /**
+     * @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(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): void;
+    /**
+     * @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}
+     */
+    protected 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;
+}

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

@@ -1,83 +1,83 @@
-import { RmCore } from '../../../core';
-import { ServerCacheDependencyInterface } from '../../../interfaces';
-import { CollectionEntry, ItemEntry } from '../../../models';
-import { ApiRequestColumnMap, 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 { ServerItemEntryChanges, ServerItemHandler } from './ServerItemHandler';
-/**
- * @description
- * The {@link ServerCache ServerCache} is responsible for keeping track of {@link ItemEntry ItemEntries} and {@link CollectionEntry CollectionEntries}
- * which are saved on the server.
- *
- * It's basically a local representation of the database
- */
-export declare class ServerCache extends AbstractCache {
-    protected dependencies: ServerCacheDependencyInterface;
-    readonly itemHandler: ServerItemHandler;
-    readonly collectionHandler: ServerCollectionHandler;
-    parent: null;
-    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
-    getServerCache(): ServerCache;
-    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;
-    /**
-     * @description
-     * Gets the fields required to set the parent
-     */
-    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
-    /**
-     * @description
-     * Gets the entry's parent
-     *
-     * @param itemEntry The entry to get the parent from
-     * @param _fromInitial Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
-     * @param _providedFields Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
-     *
-     * @remark
-     * 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;
-    getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
-    /**
-     * @description
-     * Only takes the local changes into account, used for saving
-     */
-    getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): {
-        entry: ItemEntry;
-        changes: ServerItemEntryChanges;
-    };
-    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
-    /**
-     * @description
-     * Invalidates the complete server cache, all items will be re-fetched whenever they are requested
-     */
-    invalidateCache(): void;
-    /**
-     * @description
-     * Merges the passed changes from the child Transaction into this Transaction's own changes and then propagates
-     * them to all child Transactions
-     */
-    applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
-    /**
-     * @description
-     * Applies changes to this transaction and its children
-     * Differs from {@link TransactionCache.applyChangesDelta TransactionCache.applyChangesDelta} in the handling of deleted entries and the applyChangesFromParent call
-     */
-    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>;
-}
+import { RmCore } from '../../../core';
+import { ServerCacheDependencyInterface } from '../../../interfaces';
+import { CollectionEntry, ItemEntry } from '../../../models';
+import { ApiRequestColumnMap, 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 { ServerItemEntryChanges, ServerItemHandler } from './ServerItemHandler';
+/**
+ * @description
+ * The {@link ServerCache ServerCache} is responsible for keeping track of {@link ItemEntry ItemEntries} and {@link CollectionEntry CollectionEntries}
+ * which are saved on the server.
+ *
+ * It's basically a local representation of the database
+ */
+export declare class ServerCache extends AbstractCache {
+    protected dependencies: ServerCacheDependencyInterface;
+    readonly itemHandler: ServerItemHandler;
+    readonly collectionHandler: ServerCollectionHandler;
+    parent: null;
+    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
+    getServerCache(): ServerCache;
+    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;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     */
+    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    /**
+     * @description
+     * Gets the entry's parent
+     *
+     * @param itemEntry The entry to get the parent from
+     * @param _fromInitial Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
+     * @param _providedFields Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
+     *
+     * @remark
+     * 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;
+    getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
+    /**
+     * @description
+     * Only takes the local changes into account, used for saving
+     */
+    getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): {
+        entry: ItemEntry;
+        changes: ServerItemEntryChanges;
+    };
+    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
+    /**
+     * @description
+     * Invalidates the complete server cache, all items will be re-fetched whenever they are requested
+     */
+    invalidateCache(): void;
+    /**
+     * @description
+     * Merges the passed changes from the child Transaction into this Transaction's own changes and then propagates
+     * them to all child Transactions
+     */
+    applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
+    /**
+     * @description
+     * Applies changes to this transaction and its children
+     * Differs from {@link TransactionCache.applyChangesDelta TransactionCache.applyChangesDelta} in the handling of deleted entries and the applyChangesFromParent call
+     */
+    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/ServerCollectionHandler.d.ts

@@ -1,44 +1,44 @@
-import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ApiQuery, ApiRequestColumns, ApiRequestService, CollectionEntryOptions, CollectionMatcher, ColumnUtil, ItemEntryOptions, PromiseInterface } from '../../../index';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { CollectionEntry, ItemEntry } from '../../../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
-import { CollectionEntryService, QueryService } from '../../index';
-import { RequestBufferManager } from '../../RequestBufferManager';
-import { CollectionHandlerBase } from '../CollectionHandlerBase';
-import { ServerCache } from './ServerCache';
-import { ServerItemHandler } from './ServerItemHandler';
-export declare class ServerCollectionHandler extends CollectionHandlerBase {
-    private columnSubsetCacheFactory;
-    private requestBufferManager;
-    private columnExpansionFactory;
-    private apiRequestService;
-    private collectionMatcherFactory;
-    private errorHandler;
-    private itemHandler;
-    private promiseService;
-    private queryService;
-    protected transaction: ServerCache;
-    constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, columnExpansionFactory: ColumnExpansionFactory, apiRequestService: ApiRequestService, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, queryService: QueryService, columnUtil: ColumnUtil, transaction: ServerCache);
-    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    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>>;
-    extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
-    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newRequestColumns: 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;
-    /**
-     * @description
-     * Expands the columns of the items in the collection
-     */
-    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
-    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    /**
-     * @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
-     */
-    private fetchCollectionData;
-}
+import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
+import { ApiQuery, ApiRequestColumns, ApiRequestService, CollectionEntryOptions, CollectionMatcher, ColumnUtil, ItemEntryOptions, PromiseInterface } from '../../../index';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { CollectionEntry, ItemEntry } from '../../../models';
+import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
+import { CollectionEntryService, QueryService } from '../../index';
+import { RequestBufferManager } from '../../RequestBufferManager';
+import { CollectionHandlerBase } from '../CollectionHandlerBase';
+import { ServerCache } from './ServerCache';
+import { ServerItemHandler } from './ServerItemHandler';
+export declare class ServerCollectionHandler extends CollectionHandlerBase {
+    private columnSubsetCacheFactory;
+    private requestBufferManager;
+    private columnExpansionFactory;
+    private apiRequestService;
+    private collectionMatcherFactory;
+    private errorHandler;
+    private itemHandler;
+    private promiseService;
+    private queryService;
+    protected transaction: ServerCache;
+    constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, columnExpansionFactory: ColumnExpansionFactory, apiRequestService: ApiRequestService, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, queryService: QueryService, columnUtil: ColumnUtil, transaction: ServerCache);
+    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    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>>;
+    extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
+    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newRequestColumns: 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;
+    /**
+     * @description
+     * Expands the columns of the items in the collection
+     */
+    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
+    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    /**
+     * @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
+     */
+    private fetchCollectionData;
+}

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

@@ -1,51 +1,51 @@
-import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../../types';
-import { ChangesDelta } from '../../ChangesDelta';
-import { ChangesDeltaItemUpdateDelta } from '../../ChangesDeltaBase';
-import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
-import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse, TransactionItemEntryChanges } from '../../index';
-import { ItemHandlerBase } from '../ItemHandlerBase';
-import { ServerCache } from './ServerCache';
-export declare type ServerItemEntryChanges<ItemTypeType extends ItemType = any> = FieldMap<ItemTypeType>;
-export declare class ServerItemHandler extends ItemHandlerBase {
-    private requestBufferManager;
-    private queryParserFactory;
-    private queryService;
-    private columnSubsetCacheFactory;
-    protected transaction: ServerCache;
-    itemChanges: {
-        [itemEntryId: number]: ServerItemEntryChanges;
-    };
-    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
-    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
-    /**
-     * @description
-     * Processes updates on a cached entry
-     */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
-    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>>>;
-    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the data for the ItemEntries linked to the parent Items
-     *
-     * @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>;
-    /**
-     * @description
-     * General way to process an API response.
-     * Will call {@link ChangesDelta.setItemCreated setItemCreated} if an entry doesn't exist yet, and otherwise {@link ChangesDelta.setItemUpdated setItemUpdated} if it does.
-     */
-    processApiResponse<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemId: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>): void;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.
-     * Will create a new {@link ItemEntry ItemEntry} if the ItemEntry didn't exist yet
-     */
-    private fetchItemEntryData;
-}
+import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ItemEntry, ItemEntryOptions } from '../../../models';
+import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
+import { ChangesDeltaItemUpdateDelta } from '../../ChangesDeltaBase';
+import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
+import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse, TransactionItemEntryChanges } from '../../index';
+import { ItemHandlerBase } from '../ItemHandlerBase';
+import { ServerCache } from './ServerCache';
+export declare type ServerItemEntryChanges<ItemTypeType extends ItemType = any> = FieldMap<ItemTypeType>;
+export declare class ServerItemHandler extends ItemHandlerBase {
+    private requestBufferManager;
+    private queryParserFactory;
+    private queryService;
+    private columnSubsetCacheFactory;
+    protected transaction: ServerCache;
+    itemChanges: {
+        [itemEntryId: number]: ServerItemEntryChanges;
+    };
+    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    /**
+     * @description
+     * Processes updates on a cached entry
+     */
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
+    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>>>;
+    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the data for the ItemEntries linked to the parent Items
+     *
+     * @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>;
+    /**
+     * @description
+     * General way to process an API response.
+     * Will call {@link ChangesDelta.setItemCreated setItemCreated} if an entry doesn't exist yet, and otherwise {@link ChangesDelta.setItemUpdated setItemUpdated} if it does.
+     */
+    processApiResponse<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemId: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>): void;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.
+     * Will create a new {@link ItemEntry ItemEntry} if the ItemEntry didn't exist yet
+     */
+    private fetchItemEntryData;
+}