@rentman/rm-core 0.0.0-RM4-44763

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

@@ -0,0 +1,342 @@
+import { WritableSignal } from '@angular/core';
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumnArray, ApiRequestColumns, CachedQueryItem, ChangesDelta, ChangesDeltaResult, ChildChangesDelta, ChildCollectionResources, CollectionOptions, CollectionQuery, CollectionResource, ConversionMap, CreateRequestParameterMap, DeregFunction, FieldMap, ItemAggregatedChangesListener, ItemChangesListener, ItemEntry, ItemIdConversionMap, ItemOptions, ItemResource, ItemResourcesItemTypeMap, ItemsByQueryOptions, ItemTypeMap, LimitedCollectionResource, ModuleChangesCompilationResult, NewItemOptions, OnAfterCreateCallback, ParentChangesDelta, ParentIdMap, RmCore, RootCollectionOptions, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionEventHandler, TransactionItemHandler, TransactionOptions, TransactionValidator, TransactionValidatorFactory } from '../../../internal';
+import { TransactionValidatorWithDependencies } from './TransactionValidatorWithDependencies';
+type ItemResourceLinks<ItemTypeType extends ApiItemType, ColumnIds extends ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionResources | undefined> = {
+    main: ItemResource<ItemTypeType, ColumnIds, Children>;
+    linked: ItemResourcesItemTypeMap;
+};
+export declare enum TransactionErrorLevel {
+    warning = "warning",
+    error = "error"
+}
+export type TransactionError = {
+    fieldString: string;
+    string: string;
+    level: TransactionErrorLevel;
+    location?: string;
+};
+export type GlobalTransactionError = {
+    string: string;
+    level: TransactionErrorLevel;
+};
+/**
+ * Converts child CollectionOptionsInterfaces to CollectionResources.
+ */
+export type OptionsToChildCollections<OptionsType> = OptionsType extends {
+    children: {
+        [itemType: string]: {
+            columns: any;
+        };
+    };
+} ? {
+    [ChildItemType in keyof OptionsType['children']]: ChildItemType extends ApiItemType ? OptionsToCollectionResource<ChildItemType, OptionsType['children'][ChildItemType]> : never;
+} : undefined;
+export type OptionsToCollectionResource<ItemTypeType extends ApiItemType, OptionsType extends {
+    columns: ApiRequestColumnArray<ItemTypeType>;
+}> = OptionsType extends {
+    order: {
+        limit: number;
+    };
+} ? LimitedCollectionResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>> : CollectionResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>;
+/**
+ * @description
+ * The {@link TransactionCache TransactionCache} is responsible for keeping track of newly created {@link ItemEntry ItemEntries}
+ * and {@link CollectionEntry CollectionEntries}, and the changes of existing ItemEntries and CollectionEntries.
+ *
+ * The TransactionCache is also responsible for creating {@link ItemResource ItemResources}, which is a combination of an {@link ItemEntry ItemEntry} and the current transaction's changes on this ItemEntry
+ */
+export declare class TransactionCache extends AbstractCache {
+    /**
+     * @description
+     * For debugging purposes
+     */
+    id?: string | undefined;
+    /**
+     * @description
+     * A map of all item errors, can be populated using {@link TransactionValidator.setGlobalError TransactionValidator.setGlobalError} and {@link TransactionValidator.setItemError TransactionValidator.setItemError}.
+     * Contains a translation and level for every error
+     */
+    errors: {
+        item: WritableSignal<{
+            [itemEntryId: string]: {
+                [columnId: string]: {
+                    [errorKey: string]: TransactionError;
+                };
+            };
+        }>;
+        global: WritableSignal<{
+            [key: string]: GlobalTransactionError;
+        }>;
+    };
+    firstError: import("@angular/core").Signal<GlobalTransactionError | undefined>;
+    firstErrorString: import("@angular/core").Signal<string | undefined>;
+    rootItemSignal: WritableSignal<ItemEntry<any> | undefined>;
+    /**
+     * @description
+     * Stores additional request parameters for when the transaction is stored to the server
+     */
+    tabRequestParameters: {};
+    hasChangesSignal: WritableSignal<boolean>;
+    /**
+     * @description
+     * The transaction's parent
+     */
+    readonly parent: AbstractCache;
+    readonly itemHandler: TransactionItemHandler;
+    readonly cachedQueryHandler: TransactionCachedQueryHandler;
+    readonly eventHandler: TransactionEventHandler;
+    readonly validator?: TransactionValidator;
+    validatorWithDependencies?: TransactionValidatorWithDependencies<any>;
+    private readonly options;
+    private changesDeltasBeingApplied;
+    private transactionStateSignal;
+    isSavingSignal: import("@angular/core").Signal<boolean>;
+    isReadySignal: import("@angular/core").Signal<boolean>;
+    isPendingSignal: import("@angular/core").Signal<boolean>;
+    isDestroyedSignal: WritableSignal<boolean>;
+    isValidSignal: import("@angular/core").Signal<boolean>;
+    constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
+    /**
+     * @description
+     * For debugging purposes
+     */
+    id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
+    /**
+     * @description
+     * Stores the 'root' {@link ItemEntry ItemEntry}, this {@link ItemEntry ItemEntry} can be used as request parent to store the whole transaction at once
+     */
+    get rootItem(): ItemEntry | undefined;
+    /**
+     * @description
+     * Is true when the current transaction has:
+     * - Newly created items
+     * - Removed items (from collections)
+     * - Changes on existing items
+     */
+    get hasChanges(): boolean;
+    /**
+     * @description
+     * Is true while the {@link TransactionCache TransactionCache} is applying changes to the parent (can either be through a merge or an Api save)
+     */
+    get isSaving(): boolean;
+    /**
+     * @description
+     * Is true while the {@link TransactionCache TransactionCache} is ready to handle new saves
+     */
+    get isReady(): boolean;
+    get isValid(): boolean;
+    attachValidator(validator: TransactionValidatorWithDependencies<any>): void;
+    /**
+     * @description
+     * Checks if the transaction is pending (or saving) on itself and on all of its children recursively
+     * This can be used to block a transaction if one of the children is still loading (for instance for a file upload)
+     */
+    isPending(): boolean;
+    /**
+     * @description
+     * Sets the transactionstate to pending, must recieve a promise as a parameter, on promise resolve, transactionstate gets put back to ready
+     * If the transaction is already in state saving, we use that and let the save function return it to ready
+     * @param promise
+     */
+    setPending(promise: Promise<any>): Promise<any>;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    destroy(): void;
+    isDestroyed(): boolean;
+    expandCollectionResource<ItemTypeType extends ApiItemType>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns<ItemTypeType>): Promise<CollectionResource<ItemTypeType>>;
+    /**
+     * @description
+     * Expands the collections with the new request columns. All collections should have the same query (excluding the
+     * parent).
+     */
+    expandCollectionResources<const ItemTypeType extends ApiItemType, CollectionResourceType extends CollectionResource<ItemTypeType, any, any>>(itemType: ItemTypeType, collections: ParentIdMap<CollectionResourceType>, newColumns: ApiRequestColumnArray<ItemTypeType>): Promise<ParentIdMap<CollectionResourceType>>;
+    registerFieldChangeCallback<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, callback: ItemChangesListener<ItemTypeType>): DeregFunction;
+    createChangesDelta(logMissingColumnErrors?: boolean): ChangesDelta;
+    getFirstErrorString(): undefined | string;
+    /**
+     * @description
+     * Should only be called by {@link TransactionValidator TransactionValidator}
+     * @internal
+     */
+    _setGlobalError(key: string, isInvalid: boolean, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    /**
+     * @description
+     * Should only be called by {@link TransactionValidator TransactionValidator}
+     * @internal
+     */
+    _setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel, location?: string): void;
+    /**
+     * @description
+     * Merges the passed changes from the parent Transaction into this Transaction's own changes and then propagates
+     * them to all child Transactions, this assumes that an action is already handled in a parent, so it does't handle created entries
+     * and removes entries that were in {@link TransactionItemHandler.deletedItems deletedItems} since they are already deleted
+     *
+     * ------------------
+     *
+     * The difference between {@link TransactionCache.applyChangesFromParent} and {@link TransactionCache.applyChangesDelta} is that applyChangesFromParent assumes
+     * the change has already been processed, and applyChangesDelta will process the changes once you save the transaction
+     *
+     * ------------------
+     * Use {@link TransactionCache.applyChangesDelta applyChangesDelta} if you want to apply changes from outside the core
+     */
+    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<void>;
+    /**
+     * Applies changes to this transaction and its children.
+     *
+     * The difference between {@link TransactionCache.applyChangesFromParent} and {@link TransactionCache.applyChangesDelta}
+     * is that applyChangesFromParent assumes the change has already been processed on the parent, and applyChangesDelta
+     * will process the changes itself.
+     *
+     * Please note that the resulting promise resolves before deletes have been processed. Deletes are processed after
+     * the changes have been applied to child transactions. This is reflected by the `allChildrenDonePromise` on the
+     * result.
+     *
+     * However, {@link TransactionCache.save} waits until the complete changes delta has been applied, so calling `save`
+     * after `applyChangesDelta` should not cause any problems.
+     */
+    applyChangesDelta(changesDelta: ChangesDelta | ChildChangesDelta): Promise<ChangesDeltaResult>;
+    private trackChangesDeltaBeingApplied;
+    getRootTransaction(): TransactionCache;
+    getServerCache(): ServerCache;
+    getCollectionChangesRecursively<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Returns whether or not the {@link TransactionCache.rootItem rootItem} is uses locks
+     */
+    isLockable(rootItem?: ItemEntry | undefined): rootItem is ItemEntry;
+    /**
+     * @description
+     * Saves the transaction, this has a different effect depending on the transaction's parent.
+     *
+     * - If the parent is another {@link TransactionCache TransactionCache} it will merge the changes of the child transaction in the the parent transaction
+     * - If the parent is the {@link ServerCache ServerCache} it will save the changes to the APi
+     */
+    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): Promise<ItemIdConversionMap>;
+    /**
+     * Rejects when another user is holding the lock, as opposed to {@link LockService.fetchLock}.
+     */
+    fetchLock(): Promise<void>;
+    detectChanges(force?: boolean): boolean;
+    /**
+     * @description
+     * Removes an {@link ItemEntry ItemEntry} through an {@link ItemResource ItemResource} from the {@link TransactionCache TransactionCache} which means that changes on this entry will no longer be tracked.
+     */
+    clearItem(itemResource: ItemResource<any>): void;
+    clearItemEntry<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Adds a callback that will fire before the transaction is saved, rejecting this callback will prevent the transaction from saving
+     */
+    onBeforeSave(key: string, callback: TransactionCacheCallbackType['onBeforeSave'], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    /**
+     * @description
+     * Adds a callback that will fire when the transaction is saved successfully
+     */
+    onSaveSuccess(key: string, callback: TransactionCacheCallbackType['onSaveSuccess'], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    /**
+     * @description
+     * Adds a callback that will fire when the root item of the transaction is deleted
+     */
+    onRootItemDeleted(key: string, callback: TransactionCacheCallbackType['onRootItemDelete'], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    /**
+     * @description
+     * Returns a {@link ModuleChangesCompilationResult ModuleChangesCompilationResult} for the transaction
+     */
+    getModuleChanges(): ModuleChangesCompilationResult;
+    /**
+     * @description
+     * Updates the passed map with the new {@link ConversionMap CconversionMap} values
+     */
+    updateItemIdMap(collectionMap: {
+        [itemId: number]: any;
+    }, conversionMap: ConversionMap): void;
+    /**
+     * @deprecated Use the `children` collection option instead.
+     */
+    getLinkCollections<const ItemTypeType extends ApiItemType, const OptionsType extends CollectionOptions<ItemTypeType>>(linkType: ApiItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: OptionsType): Promise<ParentIdMap<OptionsToCollectionResource<ItemTypeType, OptionsType>>>;
+    getCollection<const ItemTypeType extends ApiItemType, const OptionsType extends RootCollectionOptions<ItemTypeType>>(itemType: ItemTypeType, options: OptionsType): Promise<OptionsToCollectionResource<ItemTypeType, OptionsType>>;
+    getNewResourceWithId<const ItemTypeType extends ApiItemType, const OptionsType extends NewItemOptions<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId, options: OptionsType, returnLinks: true, isRoot?: boolean): Promise<ItemResourceLinks<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>>;
+    getNewResourceWithId<const ItemTypeType extends ApiItemType, const OptionsType extends NewItemOptions<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId, options: OptionsType, returnLinks?: boolean, isRoot?: boolean): Promise<ItemResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>>;
+    getNewResource<const ItemTypeType extends ApiItemType, const OptionsType extends NewItemOptions<ItemTypeType>>(itemType: ItemTypeType, options: OptionsType, returnLinks: true, isRoot?: boolean): Promise<ItemResourceLinks<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>>;
+    getNewResource<const ItemTypeType extends ApiItemType, const OptionsType extends NewItemOptions<ItemTypeType>>(itemType: ItemTypeType, options: OptionsType, returnLinks?: boolean, isRoot?: boolean): Promise<ItemResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>>;
+    /**
+     * @description
+     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
+     */
+    getItemsByQuery<const ItemTypeType extends ApiItemType, const OptionsType extends ItemsByQueryOptions<ItemTypeType>>(itemType: ItemTypeType, query: ApiQuery<ItemTypeType>, options: OptionsType): Promise<ItemResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>[]>;
+    /**
+     * @description
+     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
+     */
+    getItemsById<const ItemTypeType extends ApiItemType, const OptionsType extends ItemOptions<ItemTypeType>>(itemType: ItemTypeType, itemIds: ItemId[], options: OptionsType): Promise<ItemResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>[]>;
+    /**
+     * @description
+     * Fetches the item with the changes of the current {@link TransactionCache transaction}
+     *
+     * @param isRoot Sets the item as the root item of the transaction, new items will be linked to this item (if there's a connection in the LinkTree)
+     */
+    getItemById<const ItemTypeType extends ApiItemType, const OptionsType extends ItemOptions<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId, options: OptionsType, isRoot?: boolean): Promise<ItemResource<ItemTypeType, OptionsType['columns'], OptionsToChildCollections<OptionsType>>>;
+    /**
+     * @description
+     * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
+     */
+    fetchTitle(itemType: ApiItemType, itemId: ItemId): Promise<string>;
+    /**
+     * @description
+     * Merges the passed child Transaction into this transaction and then propagates them to the other child transactions
+     */
+    applyChangesFromChild(childTransaction: TransactionCache): Promise<ItemIdConversionMap>;
+    /**
+     * @description
+     * Gets an ItemEntry from the cache, doesn't do a API request, used for saving
+     */
+    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry;
+    /**
+     * @description
+     * Gets an ItemEntry from the cache by ItemId. Looks at the current as well as the parent transaction.
+     */
+    getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType>;
+    containsLocalItemEntryByItemId(itemType: ApiItemType, itemId: ItemEntry['itemId']): boolean;
+    /**
+     * @description
+     * Returns the complete {@link ChildChangesDelta} of the TransactionCache, this only takes into account the end
+     * result (initial is compared to changes), so changing something and reverting it won't be included.
+     */
+    getDelta(): ChildChangesDelta;
+    createItemResource<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumns<ItemTypeType>, Children extends ChildCollectionResources | undefined = undefined>(itemEntry: ItemEntry<ItemTypeType>, childCollectionMap?: Children, isNew?: boolean, onChange?: ItemAggregatedChangesListener<ItemResource<ItemTypeType, RequestColumns, Children>>, abortSignal?: AbortSignal): ItemResource<ItemTypeType, RequestColumns, Children>;
+    createItemResources<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumns<ItemTypeType>, Children extends ChildCollectionResources | undefined = undefined>(itemEntries: Iterable<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ParentIdMap<Children>, changesListener?: ItemAggregatedChangesListener<ItemResource<ItemTypeType, any, any>>, abortSignal?: AbortSignal): ItemResource<ItemTypeType, RequestColumns, Children>[];
+    processLinkedItems(linkedEntries: ItemTypeMap<ItemEntry[]>, onChange?: ItemAggregatedChangesListener<any>, abortSignal?: AbortSignal): ItemResourcesItemTypeMap;
+    clearItemError(itemEntryId?: ItemEntry['id'], columnId?: string, errorKey?: string): void;
+    clearItemError(itemEntryId: ItemEntry['id'], columnId?: string, errorKey?: string): void;
+    clearItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey?: string): void;
+    clearItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string): void;
+    private doApplyChangesDelta;
+    private updateSignals;
+    /**
+     * This method:
+     * - calls changes listeners for single items;
+     * - runs validators for single items;
+     * - calls changes listeners for collections;
+     * - calls aggregated changes listeners;
+     *
+     * When this method is called, all collections should already be updated. This ensures collections used in changes
+     * listeners and validators are up-to-date.
+     *
+     * @param changesDelta - Newly created items as well as previous values for changed items are read from this
+     * changes delta.
+     * {@link processUpdatesFromDelta} should have been called already. TODO: Express this in the type somehow.
+     */
+    private runChangesListenersAndValidators;
+    private clearChildCollectionResources;
+    /**
+     * Sets a default value for all columns required to match / fit in collections.
+     *
+     * This whole step could be removed once we always request all columns when doing a columns request. (RM4-25895).
+     * We could set a default value for all columns when creating a local item, even if the column is not included in
+     * the template.
+     */
+    private expandLocalItemsFromDelta;
+    private clearGlobalError;
+    private maybeCallInitialChangesListener;
+}
+export {};

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

@@ -0,0 +1,111 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, CachedQueryHandlerBase, CachedQueryHandlerCollectionTuple, CachedQueryItem, CachedQueryItemsItemTypeTuple, CachedQueryItemTuple, CachedQueryOptions, ChildCollectionsOption, CollectionItemResourceChanges, CollectionOptions, CollectionQuery, CollectionResource, EntryParent, ItemIdConversionMap, LinkCollectionBatchQueryTuple, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, ParentCachedQueryItemTuple, RequestColumnsOperationsCache, TransactionCache, TransactionCollectionHandlerDependencyInterface } from '../../../internal';
+import { RootQueryNode } from '../../matcher/RootQueryNode';
+export interface LinkCollectionOptionsItemTypeTuple<ItemTypeType extends ApiItemType> {
+    itemType: ItemTypeType;
+    linkCollectionOptions: LinkCollectionOptionsTuple<ItemTypeType>;
+}
+interface CollectionQueryTuple<ItemTypeType extends ApiItemType> {
+    parsedQuery: CollectionQuery<ItemTypeType>;
+    options: CollectionOptions<ItemTypeType>;
+}
+interface LinkCollectionOptionsTuple<ItemTypeType extends ApiItemType> extends LinkCollectionBatchQueryTuple<ItemTypeType> {
+    collectionQueryTuples: CollectionQueryTuple<ItemTypeType>[];
+}
+interface TransactionCachedQueryHandlerCollectionTuple<ItemTypeType extends ApiItemType> extends CachedQueryHandlerCollectionTuple<ItemTypeType> {
+    collectionResources?: WeakRef<CollectionResource<ItemTypeType, any, any>>[];
+}
+export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
+    protected dependencies: TransactionCollectionHandlerDependencyInterface;
+    /**
+     *  As opposed to the server cache, where `collections` only contains cached queries, on the transaction cache
+     *  `collections` can contain collection resources as well.
+     */
+    protected collections: {
+        [ItemType in ApiItemType]?: {
+            [queryString: string]: TransactionCachedQueryHandlerCollectionTuple<ItemType> | undefined;
+        };
+    };
+    protected transaction: TransactionCache;
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
+    getCollectionResources<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, cleanUpStaleResources?: boolean): Generator<CollectionResource<ItemTypeType, any, any>>;
+    /**
+     * This method is called when constructing a collection resource. There should be no need to call it in any other
+     * situation.
+     */
+    addCollectionResource<CollectionResourceType extends CollectionResource<any, any, any>>(resource: CollectionResourceType): CollectionResourceType;
+    /**
+     * Iterates over all collection resources that don't have an associated cached query.
+     */
+    getUncachedCollectionsIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Generator<CollectionResource<ItemTypeType>>;
+    clearCollectionResource<ItemTypeType extends ApiItemType>(resource: CollectionResource<ItemTypeType, any, any>): void;
+    /**
+     * @description
+     * Updates all cached queries which references one of the updated IDs in the conversionMap
+     *
+     * @param conversionMap ConversionMap with the updated IDs
+     */
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
+    __maybeExpandCachedQuery<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, batchedLinkedToQuery?: CollectionQuery<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    __fetchItemEntriesByQueryData<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>, linkCollectionBatchQueryTuple?: LinkCollectionBatchQueryTuple<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @remark
+     * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
+     * ({<field>: <localId>}) is also a local query
+     */
+    isLocal<ItemTypeType extends ApiItemType>(options: {
+        parent?: EntryParent;
+    }, query: ApiQuery<ItemTypeType>): boolean;
+    /**
+     * @description
+     * Fetches collections linked to the passed parents
+     * @returns An array of cached query items. The items are in the same order as the parent IDs.
+     */
+    __fetchLinkedCachedQueryItems<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, linkCollectionOptionsTuple: LinkCollectionOptionsTuple<ItemTypeType>): Promise<CachedQueryItemTuple<ItemTypeType>[]>;
+    createBatchLinkedToQuery<ItemTypeType extends ApiItemType>(parentItemType: ApiItemType, parentItemIds: ItemId[], additionalQuery?: ApiQuery<ItemTypeType>): CollectionQuery<ItemTypeType>;
+    /**
+     * The order of the `collectionQueryTuples` property of the result will be the same as the order of
+     * `parentItemIds`.
+     */
+    processLinkCollectionOptions<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parentItemType: ApiItemType, parentItemIds: ItemId[], options: CollectionOptions<ItemTypeType>): LinkCollectionOptionsTuple<ItemTypeType>;
+    __fetchParentCachedQueryItem<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>): Promise<ParentCachedQueryItemTuple<ItemTypeType>>;
+    __fetchChildCachedQueryItems(parentItemType: ApiItemType, parentItemIds: ItemId[], childCollectionOptions: ChildCollectionsOption): Promise<CachedQueryItemsItemTypeTuple<ApiItemType>[]>;
+    /**
+     * Fetches a cached query, respecting children. Like {@link __fetchItemEntriesByQueryData}, assumes the options are
+     * processed already.
+     *
+     * todo: Rename this method and {@link __fetchItemEntriesByQueryData} to something that's easier to understand.
+     */
+    __fetchParentItemEntriesByQueryData<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>): Promise<ParentCachedQueryItemTuple<ItemTypeType>>;
+    private cloneOptions;
+    fetchChildCachedQueryItems(linkCollectionOptionsItemTypeTuples: LinkCollectionOptionsItemTypeTuple<ApiItemType>[]): Promise<CachedQueryItemsItemTypeTuple<ApiItemType>[]>;
+    /**
+     * Updates the items included in cached queries and collection resources based on query matcher results. Note that
+     * method does not clear child collection resources of removed item resources.
+     */
+    applyMatchingResultsToCollections(matchingResultsAccumulatorMap: MatchesAccumulatorMap<MatchingResultsAccumulatorMapType>): Promise<CollectionItemResourceChanges<any>[]>;
+    protected clearCollectionTupleIfEmpty<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, didAlreadyClearResourceRefs?: boolean): void;
+    protected getQueryGraphsForItemType<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Set<RootQueryNode<ItemTypeType>>;
+    protected getCollectionQueries<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): Set<CollectionQuery<ItemTypeType>>;
+    private getCollectionResourcesByTuple;
+    private updateQueryLocalItemIdReferences;
+    /**
+     * Sets the `children` property for each of the cached queries in `cachedQueryItemTuples`. Assumes the `children`
+     * *options* property is the same for all cached query items.
+     *
+     * The `children` property will remain `null` if  the children option is unset.
+     */
+    private resolveParentCachedQueryItems;
+    private resolveLocalCachedQueryItem;
+    private mergeColumnsAndExpandLocalItems;
+    private getLocalItemEntries;
+    /**
+     * For all items with changes on the transaction, check whether they fit the query. This will catch both items
+     * that now fit the query and items that no longer fit the query. Because items that are created on this transaction
+     * are also considered to have changes, this will cover those, too.
+     */
+    private matchItemEntriesWithChangesToCachedQuery;
+    private syncCachedQueryWithLocalItems;
+    private cleanUpQueryString;
+}
+export {};

package/dist/types/src/classes/cache/transaction/TransactionEventHandler.d.ts

@@ -0,0 +1,17 @@
+import { ErrorHandlerInterface, ItemIdConversionMap, TransactionCache } from '../../../internal';
+export type TransactionCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
+export type TransactionCacheCallbackType = {
+    onBeforeSave: (transaction: TransactionCache) => any;
+    onSaveSuccess: (transaction: TransactionCache, conversionMap: ItemIdConversionMap) => any;
+    onRootItemDelete: () => any;
+};
+export declare class TransactionEventHandler {
+    private errorHandler;
+    private callbacks;
+    constructor(errorHandler: ErrorHandlerInterface);
+    clear(): void;
+    registerCallback<T extends keyof TransactionCacheCallbackType>(type: T, key: string, callback: TransactionCacheCallbackType[T], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    executeCallbacks<T extends keyof TransactionCacheCallbackType>(type: T, execute: (callback: TransactionCacheCallbackType[T]) => any, closeTab: boolean): Promise<any>;
+    private getPriorityLevel;
+    private executeCallbacksPriorityLevel;
+}

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

@@ -0,0 +1,121 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ChangesDelta, ChangesDeltaBase, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemCreateDelta, ChangesDeltaResult, DeregFunction, FieldMap, ItemChangesListenerContext, ItemEntry, ItemHandlerBase, ItemHandlerFieldsProxyTarget, ItemIdConversionMap, ItemResource, ItemTypeColumnIds, ItemTypeMap, ModifyFieldsCallback, NewItemOptions, ParentChangesDelta, RequestColumnsOperationsCache, ResponseColumnItemTypeMap, TransactionCache, TransactionItemHandlerDependencyInterface } from '../../../internal';
+export type TransactionDeletedItem = {
+    entry: ItemEntry;
+    isCascaded: boolean;
+};
+export interface TransactionItemHandlerFieldsProxyTarget<ItemTypeType extends ApiItemType> extends ItemHandlerFieldsProxyTarget<ItemTypeType> {
+    itemHandler: TransactionItemHandler;
+}
+export type ItemChangesListener<ItemTypeType extends ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = (args: ItemChangesListenerContext<ItemResource<ItemTypeType, ColumnIds>>) => void;
+/**
+ * See {@link ItemHandlerBase.fieldsProxyHandler}.
+ */
+export declare const initialProxyHandler: ProxyHandler<TransactionItemHandlerFieldsProxyTarget<any>>;
+/**
+ * @description
+ * In a {@link TransactionCache Transaction} only local items can be stored, so all entries in {@link TransactionItemHandler.entries this.entries} are local
+ * If a non-local entry is requested it should be passed on to the {@link ServerItemHandler ServerItemHandler} which will __fetchCachedQueryItem the entry from the server
+ */
+export declare class TransactionItemHandler extends ItemHandlerBase {
+    private dependencies;
+    transaction: TransactionCache;
+    fieldChangeCallbacks: {
+        [itemType: string]: {
+            [itemId: string]: ItemChangesListener<any, any>[];
+        };
+    };
+    /**
+     * @warning
+     * Can contain both local and non-local {@link ItemEntry itemEntries}
+     */
+    deletedItems: ItemTypeMap<TransactionDeletedItem[]>;
+    itemResourcesPerEntry: Map<ItemEntry, WeakRef<ItemResource<any, any, any>>[]>;
+    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache);
+    registerItemResource(itemResource: ItemResource<any, any, any>): void;
+    getItemResources<const ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, cleanUpStaleResources?: boolean): Generator<ItemResource<ItemTypeType, any, any>>;
+    cleanUpItemResourcesForEntry(itemEntry: ItemEntry<any>): void;
+    clearItemEntry<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType> | undefined;
+    addToDeletedItems(itemEntry: ItemEntry<any>, isCascaded: boolean): void;
+    removeFromDeletedItems(itemEntry: ItemEntry<any>): void;
+    getDeletedItemsIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): IterableIterator<ItemEntry<ItemTypeType>>;
+    getDeletedItemsAmount<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): number;
+    /**
+     * Construct a proxy object for the initial fields of the item. Reading a field will traverse the transaction chain.
+     * The fields will come from the parent transaction, if avaiable.
+     */
+    constructInitialProxy<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType>;
+    getItemEntriesWithChangesIterator(): Generator<ItemEntry<any>>;
+    /**
+     * Processes the changes on the transaction, and stores the changes as well as the previous values in
+     * `parentChangesDelta`. Also handles changes listeners and validators.
+     *
+     * 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>;
+    }, createItemChangesIfNoneExist: boolean, parentChangesDelta: ParentChangesDelta): void;
+    updateLocalItemIdReferences(itemType: ApiItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta: ChangesDeltaBase): void;
+    registerFieldChangeCallback<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, callback: ItemChangesListener<ItemTypeType>): DeregFunction;
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    /**
+     * @description
+     * Gets the local {@link FieldMap changes} of the {@link ItemEntry entry} on the {@link TransactionCache transaction} in a formatted way the API accepts
+     */
+    formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): {
+        [columnId: string]: any;
+    };
+    detectChanges(): boolean;
+    /**
+     * @description
+     * Checks if the transaction has changes for the passed {@link ItemEntry.id ItemEntryId}
+     */
+    detectEntryChanges(itemEntryId: ItemEntry['id']): boolean;
+    cloneItemEntries<ItemTypeType extends ApiItemType>(changesDelta: ChangesDelta, itemEntries: ItemEntry<ItemTypeType>[], conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
+    cloneItemEntry<ItemTypeType extends ApiItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
+    fetchItemEntry<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, requestColumns: ApiRequestColumns<ItemTypeType>): Promise<ItemEntry<ItemTypeType>>;
+    fetchItemEntries<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemIds: ItemId[], requestColumns: ApiRequestColumns<ItemTypeType>): Promise<ItemEntry<ItemTypeType>[]>;
+    /**
+     * @description
+     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
+     */
+    fetchNewItemEntry<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, options: NewItemOptions<ItemTypeType>, isRoot?: boolean): Promise<ChangesDeltaResult>;
+    fetchItemEntryData<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemIds: Iterable<ItemId>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, refreshAggregateColumns: boolean, forceRequest?: boolean): Promise<ItemEntry<ItemTypeType>[]>;
+    fetchTitle<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId): Promise<string>;
+    /**
+     * `expandLocalItemEntries` ensures values are available for the columns passed in `requestColumns`. As this method
+     * only handles local items, it will set a default value.
+     *
+     * This is not handled using a changes delta because:
+     *  - these changes are strictly limited to the current transaction;
+     *  - existing fields are not affected, so no changes hooks should be triggered.
+     *
+     * @param itemEntries - Only local item entries (stored on this transaction only) should be passed here.
+     */
+    expandLocalItemEntries<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemEntries: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns<ItemTypeType>, responseColumns: Partial<ResponseColumnItemTypeMap>, refreshAggregateColumns: boolean): Promise<void>;
+    /**
+     * If the entry was previously deleted, and somehow updated by another call (could be from server) we don't want to
+     * re-add it to collections.
+     */
+    itemIsDeleted<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): boolean;
+    clearItemResource(resource: ItemResource<any, any, any>): void;
+    /**
+     * @description
+     * Processes on a cached entry, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new
+     * values will not be processed unless `createItemChangesIfNoneExist` is set.
+     *
+     * Note: Even though both the server item handler and the transaction item handler have a
+     * {@link processItemEntryChanges} method, it is not defined on the superclass as the transaction item handler
+     * introduces a `createItemChangesIfNoneExist` parameter.
+     *
+     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`. We assume that when
+     * `applyChangesDelta` is called with updates that aren't on the transaction they should be added.
+     *
+     * @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>, createItemChangesIfNoneExist: boolean): Readonly<Partial<FieldMap<ItemTypeType>>> | null;
+    private fetchLocalItemEntryData;
+}

package/dist/types/src/classes/cache/transaction/TransactionValidator.d.ts

@@ -0,0 +1,25 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { FieldMap, ItemChangesListenerContext, ItemEntry, ItemResource, ItemTypeColumnIds, TransactionCache } from '../../../internal';
+import { TransactionValidatorBase } from './TransactionValidatorBase';
+export interface TransactionValidatorFactory {
+    construct(transaction: TransactionCache): TransactionValidator;
+}
+export type TransactionValidatorCompareField<ItemTypeType extends ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = ItemChangesListenerContext<ItemResource<ItemTypeType, ColumnIds>>['compareField'];
+export declare abstract class TransactionValidator extends TransactionValidatorBase {
+    /**
+     * @description
+     * Will be called after {@link TransactionCache.applyChangesFromParent applyChangesFromParent}, {@link TransactionCache.applyChangesFromChild applyChangesFromChild} or {@link TransactionCache.applyChangesDelta applyChangesDelta} is called
+     * Allows you to set {@link TransactionCache.errors global errors}
+     */
+    abstract validateTransaction(): void;
+    /**
+     * @description
+     * Will be called whenever an item is changed, allows you to set errors on the transaction
+     * @param itemEntry
+     * @param fields
+     * @param previous Previous contain only fields changed on this transaction
+     * @param compareField
+     */
+    abstract validateItem<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: Partial<FieldMap<ItemTypeType>>, compareField: TransactionValidatorCompareField<ItemTypeType>): void;
+    protected hasFields<ItemTypeType extends ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType>>(fields: FieldMap<ItemTypeType, []>, columnIds: ColumnIds): fields is FieldMap<ItemTypeType, ColumnIds>;
+}

package/dist/types/src/classes/cache/transaction/TransactionValidatorBase.d.ts

@@ -0,0 +1,19 @@
+import { ItemEntry, TransactionCache, TransactionErrorLevel } from '../../../internal';
+export declare abstract class TransactionValidatorBase {
+    protected transaction: TransactionCache;
+    private lastCallIdMap;
+    isPendingSignal: import("@angular/core").Signal<boolean>;
+    protected _lastCallId: number;
+    constructor(transaction: TransactionCache);
+    /**
+     * @description
+     * Will return `true` if there are any validators pending
+     */
+    isPending(): boolean;
+    setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | Promise<boolean>, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn?: () => string, level?: TransactionErrorLevel, location?: string): void;
+    setGlobalError(key: string, isInvalid: boolean | Promise<boolean>, saveButtonErrorTranslationFn: () => string, level?: TransactionErrorLevel): void;
+    private getHash;
+    private deleteLastCall;
+    private setLastCall;
+    private isLastCall;
+}