@rentman/rm-core 9.2.2 → 9.2.4

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

@@ -1,68 +1,68 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { AbstractCache, ApiQuery, ApiRequestColumns, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnUtil, ItemEntry, ParentIdMap, ParentItemMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory } from '../../internal';
-export declare type CachedQueryItemTree<ItemTypeType extends ApiEnumItemType = any> = {
-    item: CachedQueryItem<ItemTypeType>;
-    children: ParentItemMap<CachedQueryItemTree> | null;
-};
-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);
-    /**
-     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
-     */
-    setCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns, itemEntries?: ItemEntry<ItemTypeType>[]): CachedQueryItem<ItemTypeType>;
-    getCachedQueryItems<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string): undefined | ItemEntry<ItemTypeType>[];
-    getCachedQueryObjectsByItemType(itemType: ApiEnumItemType): CachedQueryItem[];
-    /**
-     * @description
-     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
-     */
-    abstract __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches collections linked to the passed parents
-     */
-    abstract __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches collections linked to the passed parents
-     */
-    abstract __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    /**
-     * @description
-     * Removes the passed {@link ItemId ItemIds} from the Transaction's query cache
-     */
-    __removeItemEntriesFromCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): ItemEntry<ItemTypeType>[];
-    /**
-     * @description
-     * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CacheSyncer CacheSyncer} to function.
-     * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionOptions.queryColumns queryColumns} should also be taken into account
-     */
-    expandColumnsWithQueryColumns(itemType: ApiEnumItemType, options: CollectionOptions, query: ApiQuery): void;
-    /**
-     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
-     */
-    protected constructCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns): 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 ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { AbstractCache, ApiQuery, ApiRequestColumns, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnUtil, ItemEntry, ParentIdMap, ParentItemMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory } from '../../internal';
+export declare type CachedQueryItemTree<ItemTypeType extends ApiEnumItemType = any> = {
+    item: CachedQueryItem<ItemTypeType>;
+    children: ParentItemMap<CachedQueryItemTree> | null;
+};
+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);
+    /**
+     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
+     */
+    setCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns, itemEntries?: ItemEntry<ItemTypeType>[]): CachedQueryItem<ItemTypeType>;
+    getCachedQueryItems<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string): undefined | ItemEntry<ItemTypeType>[];
+    getCachedQueryObjectsByItemType(itemType: ApiEnumItemType): CachedQueryItem[];
+    /**
+     * @description
+     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
+     */
+    abstract __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     */
+    abstract __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     */
+    abstract __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    /**
+     * @description
+     * Removes the passed {@link ItemId ItemIds} from the Transaction's query cache
+     */
+    __removeItemEntriesFromCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): ItemEntry<ItemTypeType>[];
+    /**
+     * @description
+     * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CacheSyncer CacheSyncer} to function.
+     * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionOptions.queryColumns queryColumns} should also be taken into account
+     */
+    expandColumnsWithQueryColumns(itemType: ApiEnumItemType, options: CollectionOptions, query: ApiQuery): void;
+    /**
+     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
+     */
+    protected constructCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns): 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 ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
+}

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

@@ -1,102 +1,102 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { AbstractCache, ApiFormatter, ApiQuery, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ColumnInfo, ColumnUtil, ErrorHandlerInterface, FieldMap, ItemCache, ItemCacheFactory, ItemEntry, ItemEntryFactory, ItemEntryOptions, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, TransactionItemEntryChanges } from '../../internal';
-export declare enum ItemCacheStatus {
-    CACHED = "cached",
-    NOT_CACHED = "not_cached",
-    NO_CHANGES = "no_changes"
-}
-export interface ItemEntryChanges<ItemTypeType extends ApiEnumItemType> {
-    fields: FieldMap<ItemTypeType>;
-}
-export interface ItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType> {
-    entry: ItemEntry<ItemTypeType>;
-    changes: ItemEntryChanges<ItemTypeType>;
-}
-export declare type ProcessItemEntryChangesResult<ItemTypeType extends ApiEnumItemType> = {
-    status: ItemCacheStatus.NO_CHANGES | ItemCacheStatus.NOT_CACHED;
-    previous: null;
-} | {
-    status: ItemCacheStatus.CACHED;
-    previous: FieldMap<ItemTypeType>;
-};
-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: {
-        [itemEntryId: number]: ItemEntryChanges<any>;
-    };
-    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<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: TransactionItemEntryChanges<ItemTypeType>, entry: ItemEntry<ItemTypeType>): ItemEntryChanges<ItemTypeType>;
-    /**
-     * @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 ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
-    /**
-     * @description
-     * Fetches the ItemEntries for the given ItemIds
-     */
-    abstract fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
-    /**
-     * @description
-     * Fetches an ItemEntry with the given itemId
-     */
-    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): 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 ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
-    /**
-     * @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 ApiEnumItemType>(itemEntries: ItemEntry<ItemTypeType>[], rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | ItemEntry<ItemTypeType>[]>;
-    resolveDerivedValues<ItemTypeType extends ApiEnumItemType>(itemEntries: ItemEntry<ItemTypeType>[], columns: ColumnInfo<ItemTypeType>[], changesDelta?: ChangesDeltaBase): PromiseInterface<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 ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { AbstractCache, ApiFormatter, ApiQuery, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ColumnInfo, ColumnUtil, ErrorHandlerInterface, FieldMap, ItemCache, ItemCacheFactory, ItemEntry, ItemEntryFactory, ItemEntryOptions, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, TransactionItemEntryChanges } from '../../internal';
+export declare enum ItemCacheStatus {
+    CACHED = "cached",
+    NOT_CACHED = "not_cached",
+    NO_CHANGES = "no_changes"
+}
+export interface ItemEntryChanges<ItemTypeType extends ApiEnumItemType> {
+    fields: FieldMap<ItemTypeType>;
+}
+export interface ItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType> {
+    entry: ItemEntry<ItemTypeType>;
+    changes: ItemEntryChanges<ItemTypeType>;
+}
+export declare type ProcessItemEntryChangesResult<ItemTypeType extends ApiEnumItemType> = {
+    status: ItemCacheStatus.NO_CHANGES | ItemCacheStatus.NOT_CACHED;
+    previous: null;
+} | {
+    status: ItemCacheStatus.CACHED;
+    previous: FieldMap<ItemTypeType>;
+};
+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: {
+        [itemEntryId: number]: ItemEntryChanges<any>;
+    };
+    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<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: TransactionItemEntryChanges<ItemTypeType>, entry: ItemEntry<ItemTypeType>): ItemEntryChanges<ItemTypeType>;
+    /**
+     * @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 ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    /**
+     * @description
+     * Fetches the ItemEntries for the given ItemIds
+     */
+    abstract fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    /**
+     * @description
+     * Fetches an ItemEntry with the given itemId
+     */
+    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): 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 ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    /**
+     * @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 ApiEnumItemType>(itemEntries: ItemEntry<ItemTypeType>[], rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | ItemEntry<ItemTypeType>[]>;
+    resolveDerivedValues<ItemTypeType extends ApiEnumItemType>(itemEntries: ItemEntry<ItemTypeType>[], columns: ColumnInfo<ItemTypeType>[], changesDelta?: ChangesDeltaBase): PromiseInterface<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 ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
+}

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

@@ -1,78 +1,78 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestColumn, ApiRequestColumnMap, ApiResponseProcessor, CachedQueryItem, ChangesDelta, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemEntry, ItemEntryChangesTuple, ItemIdConversionMap, ItemTypeMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, RmCore, ServerCacheDependencyInterface, ServerCachedQueryHandler, ServerItemHandler, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
-/**
- * @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 {
-    dependencies: ServerCacheDependencyInterface;
-    readonly itemHandler: ServerItemHandler;
-    readonly cachedQueryHandler: ServerCachedQueryHandler;
-    parent: null;
-    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
-    getServerCache(): ServerCache;
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
-    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    /**
-     *
-     * @param response
-     * @param requestColumnMap
-     * @param isCalledAfterSocketUpdate
-     * @param changesDelta
-     * @param conversionMap
-     * @param directRequestItemMap Should be a map of ItemType->ItemId of items that were directly part of the create/update request (queries should be excluded from this because we don't want to overwrite the user's changes (derived values are also queries))
-     */
-    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, directRequestItemMap?: ItemTypeMap<Record<string, boolean>>, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
-    /**
-     * @description
-     * Applies changes to this transaction and its children
-     * ServerCache.applyChangesFromParent should be used when processing an API update/create/delete
-     */
-    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
-    /**
-     * @description
-     * Gets the fields required to set the parent
-     */
-    getLinkFieldsByParent<ItemTypeType extends ApiEnumItemType>(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 ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
-    /**
-     * @description
-     * Only takes the local changes into account, used for saving
-     */
-    getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
-    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
-    /**
-     * @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
-     * ServerCache.applyChangesDelta should be used when processing an API response which should create new entries on the ServerCache (such as a Query)
-     */
-    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
-    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestColumn, ApiRequestColumnMap, ApiResponseProcessor, CachedQueryItem, ChangesDelta, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemEntry, ItemEntryChangesTuple, ItemIdConversionMap, ItemTypeMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, RmCore, ServerCacheDependencyInterface, ServerCachedQueryHandler, ServerItemHandler, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+/**
+ * @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 {
+    dependencies: ServerCacheDependencyInterface;
+    readonly itemHandler: ServerItemHandler;
+    readonly cachedQueryHandler: ServerCachedQueryHandler;
+    parent: null;
+    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
+    getServerCache(): ServerCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    /**
+     *
+     * @param response
+     * @param requestColumnMap
+     * @param isCalledAfterSocketUpdate
+     * @param changesDelta
+     * @param conversionMap
+     * @param directRequestItemMap Should be a map of ItemType->ItemId of items that were directly part of the create/update request (queries should be excluded from this because we don't want to overwrite the user's changes (derived values are also queries))
+     */
+    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, directRequestItemMap?: ItemTypeMap<Record<string, boolean>>, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
+    /**
+     * @description
+     * Applies changes to this transaction and its children
+     * ServerCache.applyChangesFromParent should be used when processing an API update/create/delete
+     */
+    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     */
+    getLinkFieldsByParent<ItemTypeType extends ApiEnumItemType>(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 ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Only takes the local changes into account, used for saving
+     */
+    getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
+    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @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
+     * ServerCache.applyChangesDelta should be used when processing an API response which should create new entries on the ServerCache (such as a Query)
+     */
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
+    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+}

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

@@ -1,25 +1,25 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiRequestColumns, ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, ItemEntry, ParentIdMap, PromiseInterface, PromiseLibraryInterface, RequestBufferManager, RequestColumnExpansionFactory, ServerCache, ServerItemHandler } from '../../../internal';
-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 ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): void;
-    /**
-     * @description
-     * Expands the columns of the items in the cached query
-     */
-    __expandCachedQuery<ItemTypeType extends ApiEnumItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): 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 ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, ItemEntry, ParentIdMap, PromiseInterface, PromiseLibraryInterface, RequestBufferManager, RequestColumnExpansionFactory, ServerCache, ServerItemHandler } from '../../../internal';
+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 ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): void;
+    /**
+     * @description
+     * Expands the columns of the items in the cached query
+     */
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): 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 ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+}