@rentman/rm-core 0.0.0-RM4-44763

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

@@ -0,0 +1,97 @@
+import { WritableSignal } from '@angular/core';
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { AbstractCache, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ColumnCache, ColumnInfo, DerivedStringToRequestColumnPath, ErrorHandlerInterface, FieldMap, GetFieldValueType, ItemCache, ItemCacheFactory, ItemEntry, ItemEntryService, ItemMatcherBase, ItemTypeColumnId, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, ResolveDerivedValue, ResolveDerivedValues, SignalFieldMap } from '../../internal';
+import { GetField } from '../matcher/QueryNode';
+export interface ItemEntryChangesTuple<ItemTypeType extends ApiItemType> {
+    entry: ItemEntry<ItemTypeType>;
+    changes: FieldMap<ItemTypeType>;
+}
+export interface ItemHandlerFieldsProxyTarget<ItemTypeType extends ApiItemType> {
+    itemEntry: ItemEntry<ItemTypeType>;
+    itemHandler: ItemHandlerBase;
+}
+export declare const fieldsSignalProxyHandler: ProxyHandler<ItemHandlerFieldsProxyTarget<any>>;
+export declare abstract class ItemHandlerBase extends ItemMatcherBase {
+    protected columnCache: ColumnCache;
+    protected errorHandler: ErrorHandlerInterface;
+    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    protected requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    protected itemEntryService: ItemEntryService;
+    protected transaction: AbstractCache;
+    readonly entries: ItemCache;
+    itemChanges: {
+        [itemEntryId: number]: FieldMap<any>;
+    };
+    itemFieldSignals: {
+        [itemEntryId: number]: {
+            [columnId: string]: WritableSignal<any>;
+        };
+    };
+    protected constructor(columnCache: ColumnCache, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory, itemEntryService: ItemEntryService, transaction: AbstractCache, itemCacheFactory: ItemCacheFactory);
+    getItemFieldSignal<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemEntry: ItemEntry<ItemTypeType>, columnId: ColumnId): WritableSignal<GetFieldValueType<ItemTypeType, ColumnId>>;
+    getDisplayName<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): string;
+    constructGetField<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): GetField<ItemTypeType>;
+    /**
+     * Construct a proxy object for the fields of the item. Reading a field will traverse the transaction chain.
+     */
+    constructFieldsProxy<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType>;
+    constructSignalFieldsProxy<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): SignalFieldMap<ItemTypeType>;
+    lookUpItemField<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(entry: ItemEntry<ItemTypeType>, columnId: ColumnId): GetFieldValueType<ItemTypeType, ColumnId> | undefined;
+    collectFields<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Copies the passed ItemEntryChanges into a format the implementing ItemHandler can put in his ItemChanges
+     * @param itemEntryChanges
+     * @param entry
+     */
+    copyTransactionItemEntryChanges<ItemTypeType extends ApiItemType>(itemEntryChanges: FieldMap<ItemTypeType>, entry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType>;
+    /**
+     * @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
+     *
+     * @param refreshAggregateColumns - See {@link fetchItemEntryData}.
+     */
+    resolveDerivedValues<ItemTypeType extends ApiItemType>(itemEntries: ItemEntry<ItemTypeType>[], rootColumns: ColumnInfo<ItemTypeType>[], refreshAggregateColumns: boolean, changesDelta?: ChangesDeltaBase): Promise<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<ItemTypeType extends ApiItemType, T extends readonly string[]>(itemEntry: ItemEntry<ItemTypeType>, columnPath: T): ResolveDerivedValues<ItemTypeType, T> | 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<ItemTypeType extends ApiItemType, T extends string, DefaultValue = unknown>(itemEntry: ItemEntry<ItemTypeType>, columnPath: T, defaultValue?: DefaultValue): ResolveDerivedValue<ItemTypeType, DerivedStringToRequestColumnPath<T>>;
+    getDerivedValue<ItemTypeType extends ApiItemType, T extends readonly string[], DefaultValue = unknown>(itemEntry: ItemEntry<ItemTypeType>, columnPath: T, defaultValue?: DefaultValue): ResolveDerivedValue<ItemTypeType, T>;
+    /**
+     * @description
+     * Clears the entry from this transaction, removing it from the {@link ItemCache ItemCache} and removing all changes
+     *
+     * @returns The deleted item changes.
+     */
+    clearItemEntry<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType> | undefined;
+    /**
+     * @param refreshAggregateColumns - Do a server request for aggregate columns even if we already have a cached value.
+     * This should be `true` when we actively request an item (e.g. using `getItemById`), but `false` when expanding an
+     * item for collection matching purposes.
+     * @param forceRequest - Always flush the request buffer when the timeout expires, ignoring request suspension,
+     * which could introduce an additional delay.
+     */
+    abstract fetchItemEntryData<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemIds: Iterable<ItemId>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, refreshAggregateColumns: boolean, forceRequest?: boolean): Promise<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;
+    private getDerivedEntry;
+    private getDerivedColumn;
+}

package/dist/types/src/classes/cache/ItemMatcherBase.d.ts

@@ -0,0 +1,90 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ItemEntry } from '../../models/ItemEntry';
+import { GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { GetField, LeafQueryNode, MatchesAccumulatorTuple } from '../matcher/QueryNode';
+import { RootQueryNode } from '../matcher/RootQueryNode';
+import { ParentChangesDelta } from '../ParentChangesDelta';
+export type GetMergedQueryGraph = <ItemTypeType extends ApiItemType>(itemType: ItemTypeType) => RootQueryNode<ItemTypeType> | null;
+export interface MatchingResultsAccumulatorTuple<ItemTypeType extends ApiItemType> extends MatchesAccumulatorTuple<ItemEntry<ItemTypeType>> {
+    false?: Set<ItemEntry<ItemTypeType>>;
+}
+/**
+ * This type is similar to {@link MatchesAccumulator} by design, so we can pass it directly to the match function
+ * when matching created items.
+ */
+type MatchingResultsAccumulator<ItemTypeType extends ApiItemType> = Map<string, MatchingResultsAccumulatorTuple<ItemTypeType>>;
+export type MatchingResultsAccumulatorMapType = {
+    [ItemType in ApiItemType]?: MatchingResultsAccumulator<ItemType>;
+};
+/**
+ * A convenience class to group matches accumulators by item type.
+ */
+export declare class MatchesAccumulatorMap<ItemTypeMapType extends {
+    [ItemType in ApiItemType]?: any;
+}> {
+    private entries;
+    get<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Exclude<ItemTypeMapType[ItemTypeType], undefined>;
+    [Symbol.iterator](): Generator<[
+        ApiItemType,
+        Exclude<ItemTypeMapType[ApiItemType], undefined>
+    ]>;
+}
+export declare abstract class ItemMatcherBase {
+    /**
+     * Convenience method to quickly add items entries to a matching results accumulator tuple. Will create a tuple
+     * if none exists yet.
+     *
+     * The matching results accumulator is a map, so we can't define this on the class itself.
+     */
+    private static addItemsToMatchingResults;
+    abstract constructGetField<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): GetField<ItemTypeType>;
+    abstract lookUpItemField<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(entry: ItemEntry<ItemTypeType>, columnId: ColumnId): GetFieldValueType<ItemTypeType, ColumnId> | undefined;
+    /**
+     * For deleted items, we're determining the collections the item is currently in by matching using the current
+     * fields. This means this method should run *before* the fields are removed from the cache.
+     *
+     * In order to limit back-end requests, we treat 'maybe' matches as a proper match. This means we might try to
+     * remove items from collections that don't contain the item.
+     */
+    matchItemsInDeletedChangesDelta(changesDelta: ParentChangesDelta, getMergedQueryGraph: GetMergedQueryGraph, matchingResultsAccumulatorMap: MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>): void;
+    /**
+     * Convenience method to match multiple item entries to a single query graph. If you want to match item entries to
+     * multiple query graphs, it would be better to merge them first.
+     */
+    matchItemsToQueryGraph<ItemTypeType extends ApiItemType>(queryGraph: RootQueryNode<ItemTypeType>, leafNode: LeafQueryNode, itemEntries: ItemEntry<ItemTypeType>[], matchesAccumulatorTuple?: MatchesAccumulatorTuple<ItemEntry<ItemTypeType>>): MatchesAccumulatorTuple<ItemEntry<ItemTypeType>>;
+    /**
+     * Empty updates (where `previous` is `null`) are used:
+     * - When adding items to newly created cached queries on the server cache;
+     * - When restoring previously deleted items.
+     *
+     * Note that this method:
+     * - Only adds items (because we technically don't have any changes).
+     * - Discards 'maybe' matches. (Again, because we technically don't have any changes. When populating a non-locally
+     * matchable query, the query results should be added to the query graph.)
+     * - Does not check whether the items are deleted (we don't store deleted items on the server cache and restored
+     * items are by definition no longer deleted).
+     */
+    matchEmptyItemsInUpdatedChangesDelta(updatedChangesDelta: ParentChangesDelta['updated'], getMergedQueryGraph: GetMergedQueryGraph, matchingResultsAccumulatorMap: MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>): void;
+    /**
+     * For updated items, we  match using the current fields first, then using the updated fields.
+     * - When the item matches using the updated fields it will always be added. This is because on the server cache,
+     * we always want to add the item to possible newly created cached queries, even if there are changes. This means
+     * that we might add items to collections that already contain the item.
+     * - When the item matches using the current fields, but does not when using the updated ones, it should be removed.
+     * - In order to limit back-end requests, we consider 'maybe' only for the updated fields. For the current fields,
+     * we treat 'maybe' as a proper match. This means we might try to remove items from collections that don't contain
+     * the item.
+     *
+     * This method should be optimized for simple operations on large amounts of items, e.g. moving many Missings from
+     * an 'origin' to a 'destination' status. In this case:
+     * - A queries matched for the current and updated fields don't overlap;
+     * - No `maybe` matches should be involved.
+     */
+    matchItemsInUpdatedChangesDelta(updatedChangesDelta: ParentChangesDelta['updated'], getMergedQueryGraph: GetMergedQueryGraph, matchingResultsAccumulatorMap: MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>): void;
+    /**
+     * For created items, we can write directly to the matching results accumulator.
+     */
+    matchItemsInCreatedChangesDelta(createdChangesDelta: ParentChangesDelta['created'], getMergedQueryGraph: GetMergedQueryGraph, matchingResultsAccumulatorMap: MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>): void;
+    abstract itemIsDeleted<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): boolean;
+}
+export {};

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

@@ -0,0 +1,83 @@
+import { ApiFieldsOnDeleteRule, ApiItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestColumnMap, ApiRequestColumns, ApiResponseProcessor, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemUpdateMode, ChangesDeltaResult, CollectionQuery, CollectionResource, ConversionMap, DeregFunction, EntryParent, FieldMap, ItemEntry, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, RequestBufferManager, RequestColumnExpansion, ResponseColumnItemTypeMap, ResponseItemUpdateModeMap, RmCore, ServerCacheDependencyInterface, ServerCachedQueryHandler, ServerItemHandler, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+type OnDeltaAppliedCallback = (delta: ChangesDeltaBase) => unknown;
+export type ActiveItemEntries = Set<ItemEntry>;
+/**
+ * @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;
+    private apiFieldsOnDeleteRule;
+    readonly requestBufferManager: RequestBufferManager;
+    readonly itemHandler: ServerItemHandler;
+    readonly cachedQueryHandler: ServerCachedQueryHandler;
+    onDeltaAppliedCallbacks: OnDeltaAppliedCallback[];
+    parent: null;
+    constructor(dependencies: ServerCacheDependencyInterface, apiFieldsOnDeleteRule: typeof ApiFieldsOnDeleteRule, core: RmCore);
+    onDeltaApplied(callback: OnDeltaAppliedCallback): DeregFunction;
+    getServerCache(): ServerCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    getActiveItemEntries(): ActiveItemEntries;
+    processResponseByItemType<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType> | null, responseColumns: ResponseColumnItemTypeMap, responseItems: Iterable<FieldMap<ItemTypeType>>, changesDelta: ChangesDelta, itemUpdateModeMap?: {
+        [itemId: string]: ChangesDeltaItemUpdateMode;
+    }, conversionMap?: ConversionMap): ChangesDelta;
+    /**
+     *
+     * @param response
+     * @param requestColumnMap
+     * @param isCalledAfterSocketUpdate
+     * @param changesDelta
+     * @param conversionMap
+     * @param itemUpdateModeMap Allows you to overwrite the update mode for specific items, this is useful when you want to process the direct items of an update/create request
+     */
+    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, changesDelta?: ChangesDelta, itemUpdateModeMap?: ResponseItemUpdateModeMap, conversionMap?: ItemIdConversionMap): ChangesDelta;
+    /**
+     * @description
+     * Applies changes to this transaction and its children
+     * ServerCache.applyChangesFromParent should be used when processing an API update/create/delete
+     *
+     * `applyChangesFromParent` assumes that all derived values are already fetched and won't attempt to resolve them
+     * (which `applyChangesDelta` does)
+     */
+    applyChangesFromParent(changesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): Promise<void>;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     */
+    getLinkFieldsByParent<const ItemTypeType extends ApiItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    getCollectionChangesRecursively<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @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): Promise<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` also ensures any required derived values are properly fetched
+     * (which `applyChangesFromParent` doesn't)
+     */
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<ChangesDeltaResult>;
+    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry;
+    getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType>;
+    containsLocalItemEntryByItemId(itemType: ApiItemType, itemId: ItemEntry['itemId']): boolean;
+    /**
+     * Merged the request columns with columns required for delete relations and the query matcher.
+     * This method is in the server cache because the queries contain the superset of all columns here.
+     *
+     * Please note that this function is usually called in the request columns operation cache.
+     */
+    expandColumnsWithRequiredColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>): ApiRequestColumns<ItemTypeType>;
+    expandColumnExpansionWithRequiredColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumnExpansion: RequestColumnExpansion, cachedQueryItems: Iterable<CachedQueryItem<ItemTypeType>>, uncachedCollectionResources: Iterable<CollectionResource<ItemTypeType>>): ApiRequestColumns<ItemTypeType>;
+    private getColumnIdsWithRelations;
+    private callOnDeltaAppliedCallbacks;
+    private collectActiveItemEntriesBasedOnParentEntry;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { GraphQueryParserFactory } from '../../../factories/GraphQueryParserFactory';
+import { ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CachedQueryOptions, CollectionQuery, CollectionResource, ErrorHandlerInterface, LinkCollectionBatchQueryTuple, LinkTreeServiceInterface, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, ServerCache } from '../../../internal';
+export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
+    protected transaction: ServerCache;
+    constructor(dependencies: {
+        apiRequestService: ApiRequestService;
+        errorHandler: ErrorHandlerInterface;
+        graphQueryParserFactory: GraphQueryParserFactory;
+        linkTreeService: LinkTreeServiceInterface;
+        queryService: QueryService;
+        requestColumnExpansionFactory: RequestColumnExpansionFactory;
+        requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    }, transaction: ServerCache);
+    hasActiveCollectionsForQuery(itemType: ApiItemType, queryString: string): boolean;
+    markCachedQueriesOutdatedInAllTransactions(itemType: ApiItemType, queryString: string): void;
+    getUncachedCollectionsOnChildTransactionsIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Generator<CollectionResource<ItemTypeType>>;
+    /**
+     * @description
+     * Expands the columns of the items in the cached query
+     */
+    __maybeExpandCachedQuery<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, batchedLinkedToQuery?: CollectionQuery<ItemTypeType>): Promise<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<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>, linkCollectionBatchQueryTuple?: LinkCollectionBatchQueryTuple<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+}

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

@@ -0,0 +1,35 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemCreateDelta, ColumnCache, ErrorHandlerInterface, FieldMap, ItemCacheFactory, ItemEntry, ItemEntryService, ItemHandlerBase, ParentChangesDelta, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, ServerCache } from '../../../internal';
+export declare class ServerItemHandler extends ItemHandlerBase {
+    protected transaction: ServerCache;
+    private itemFieldLastModified;
+    constructor(errorHandler: ErrorHandlerInterface, columnCache: ColumnCache, itemCacheFactory: ItemCacheFactory, itemEntryService: ItemEntryService, requestColumnExpansionFactory: RequestColumnExpansionFactory, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory, transaction: ServerCache);
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    /**
+     * @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
+     */
+    fetchItemEntryData<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemIds: Iterable<ItemId>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, refreshAggregateColumns: boolean, forceRequest?: boolean): Promise<ItemEntry<ItemTypeType>[]>;
+    /**
+     * Processes the changes on the transaction, and stores the changes as well as the previous values in
+     * `parentChangesDelta`.
+     *
+     * Note: Even though both the server item handler and the transaction item handler have a
+     * {@link processUpdatesFromDelta} method, it is not defined on the superclass as the transaction item handler
+     * introduces the `createItemChangesIfNoneExist` parameter.
+     */
+    processUpdatesFromDelta(updated: {
+        [itemEntryId: number]: ChangesDeltaBaseItemUpdateDelta<any>;
+    }, parentChangesDelta: ParentChangesDelta): void;
+    itemIsDeleted(): boolean;
+    /**
+     * @description
+     * Processes the passed {@link ChangesDeltaBaseItemUpdateDelta update delta} on the server cache. New
+     * {@link TransactionItemHandler.itemChanges item changes} will be created if none exist.
+     *
+     * @returns An object containing a previous value for each applied change. Because of the nature of item changes
+     * it may also include changes applied on ancestor transactions. Is `null` when no changes have been made.
+     */
+    protected processItemEntryChanges<ItemTypeType extends ApiItemType>(itemEntryChangesTuple: ChangesDeltaBaseItemUpdateDelta<ItemTypeType>): Readonly<Partial<FieldMap<ItemTypeType>>> | null;
+}