@rentman/rm-core 11.0.3 → 12.0.0

package/dist/types/src/classes/ColumnUtil.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumApiType, ApiEnumItemType, ApiFields, ResponseColumn, ResponseColumnCustom, ResponseColumnItem } from '@rentman/backend-types';
-import { ApiRequestColumn, ApiRequestColumns, LinkTreeServiceInterface, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
+import { ApiRequestColumn, ApiRequestColumnArray, ApiRequestColumns, LinkTreeServiceInterface, MutableApiRequestColumnArray, RequestColumnsTuple, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
 export declare type RequestColumnMergeResult<T extends ApiRequestColumns = ApiRequestColumns, U extends ApiRequestColumns = ApiRequestColumns> = {
     merged: T;
     difference: U;
@@ -24,7 +24,7 @@ export declare class ColumnUtil {
      * - For {@link ApiLinkTreeType.DIRECT direct links} it will be a columnId
      * - For {@link ApiLinkTreeType.ITEMTABLE itemtable links} it will be 'itemtype' and 'item'
      */
-    getColumnsFromLink(parentType: ApiEnumItemType, itemType: ApiEnumItemType): ApiRequestColumn[];
+    getColumnsFromLink<ChildItemType extends ApiEnumItemType>(parentType: ApiEnumItemType, itemType: ChildItemType): ApiRequestColumn[];
     getColumnPath(columns: ResponseColumn[], renderAs: null | string): string;
     getDateFormatOptions(columnType?: 'datetime'): {
         'J-M-Y': string;
@@ -58,23 +58,23 @@ export declare class ColumnUtil {
         type: ApiEnumApiType.TYPE_DATE | ApiEnumApiType.TYPE_DATETIME | ApiEnumApiType.TYPE_DURATION;
     }): ['>', '<'];
     getComparators(column: ResponseColumn): ['=', '!='];
-    containsColumn(requestColumn: ApiRequestColumn, destination: ApiRequestColumn[]): boolean;
-    containsDerivedColumns(requestColumns: ApiRequestColumn[]): boolean;
-    responseColumnsAvailable(itemType: ApiEnumItemType, requestColumns: ApiRequestColumn[], responseColumnMap: ResponseColumnItemTypeMap): boolean;
+    containsColumn(requestColumn: ApiRequestColumn, destination: ApiRequestColumnArray): boolean;
+    containsDerivedColumns(requestColumns: ApiRequestColumnArray): boolean;
+    responseColumnsAvailable(itemType: ApiEnumItemType, requestColumns: ApiRequestColumnArray, responseColumnMap: ResponseColumnItemTypeMap): boolean;
     copyRequestColumns(columns: true): true;
-    copyRequestColumns(columns: ApiRequestColumn[]): ApiRequestColumn[];
+    copyRequestColumns(columns: ApiRequestColumns): ApiRequestColumns;
     copyRequestColumn(requestColumn: ApiRequestColumn): ApiRequestColumn;
     mergeRequestColumns(first: true, second: ApiRequestColumns): RequestColumnMergeResult<true, []>;
-    mergeRequestColumns(first: ApiRequestColumn[], second: true): RequestColumnMergeResult<true, true>;
-    mergeRequestColumns(first: ApiRequestColumn[], second: ApiRequestColumn[]): RequestColumnMergeResult<ApiRequestColumn[], ApiRequestColumn[]>;
+    mergeRequestColumns(first: ApiRequestColumnArray, second: true): RequestColumnMergeResult<true, true>;
+    mergeRequestColumns(first: ApiRequestColumnArray, second: ApiRequestColumnArray): RequestColumnMergeResult<ApiRequestColumnArray, ApiRequestColumnArray>;
     mergeRequestColumns(first: ApiRequestColumns, second: ApiRequestColumns): RequestColumnMergeResult;
-    mergeRequestColumn(requestColumn: ApiRequestColumn, destination: ApiRequestColumn[]): string | {
-        [columnId: string]: ApiRequestColumn[];
-    } | null;
+    mergeRequestColumn(requestColumn: ApiRequestColumn, destination: MutableApiRequestColumnArray): ApiRequestColumn | null;
+    createRequestColumnSetId(requestColumns: ApiRequestColumns): RequestColumnsTuple['string'];
+    private createRequestColumnId;
     getRequestColumnId(requestColumn: ApiRequestColumn): string;
     parseRequestColumn(requestColumn: ApiRequestColumn): {
         id: string;
-        children: ApiRequestColumn[];
+        children: ApiRequestColumnArray;
     };
     /**
      * @description
@@ -103,6 +103,6 @@ export declare class ColumnUtil {
     isLocalColumnId(columnId: string): boolean;
     processConfigColumns(configColumns: string[]): ApiRequestColumn[];
     parseConfigColumn(configColumn: string): string[];
-    processConfigColumn(parsedConfigColumn: string[], destination: ApiRequestColumn[]): void;
-    findRequestColumn(columnId: string, requestColumns: ApiRequestColumn[]): number;
+    processConfigColumn(parsedConfigColumn: string[], destination: MutableApiRequestColumnArray): void;
+    findRequestColumn(columnId: string, requestColumns: ApiRequestColumnArray): number;
 }

package/dist/types/src/classes/InternalChangesDelta.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, ChangesDeltaBase, EntryParent, FieldMap, ItemEntry, ItemEntryService, ItemIdConversionMap, TransactionItemEntryChangesTuple } from '../internal';
+import { ApiFormatter, ChangesDeltaBase, EntryParent, FieldMap, ItemEntry, ItemEntryChangesTuple, ItemEntryService, ItemIdConversionMap } from '../internal';
 export declare type InternalCreateDelta<ItemTypeType extends ApiEnumItemType = any> = {
     entry: ItemEntry<ItemTypeType>;
     fields: FieldMap<ItemTypeType>;
@@ -20,7 +20,7 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
         [itemEntryId: string]: InternalCreateDelta;
     };
     deleted: {
-        [itemType: string]: TransactionItemEntryChangesTuple<any>[];
+        [itemType in ApiEnumItemType]?: ItemEntryChangesTuple<itemType>[];
     };
     moved: {
         [itemEntryId: number]: {
@@ -31,9 +31,9 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
     itemIdConversionMap: ItemIdConversionMap;
     constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
     merge(otherChangesDelta: InternalChangesDelta): InternalChangesDelta;
-    setItemDeleted(tuple: TransactionItemEntryChangesTuple<any>): this;
-    setItemsDeleted(deleted: TransactionItemEntryChangesTuple<any>[]): this;
-    setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
+    setItemDeleted(tuple: ItemEntryChangesTuple<any>): this;
+    setItemsDeleted(deleted: ItemEntryChangesTuple<any>[]): this;
+    setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>): void;
     /**
      * @remark
      * Parent fields are non-writable so we need to keep track of moved entries another way (to do a linkTo request)

package/dist/types/src/classes/QueryContainsLocalIdParser.d.ts

@@ -1,4 +1,4 @@
-import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, KeyService, QueryParserBase } from '../internal';
 declare type ReturnType = boolean;
 export declare class QueryContainsLocalIdParser extends QueryParserBase<ReturnType> {
@@ -9,7 +9,7 @@ export declare class QueryContainsLocalIdParser extends QueryParserBase<ReturnTy
     protected parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], _itemType: T['itemType'], field: T['field'], query: T['query']): ReturnType;
     protected parseSearchQuery(): ReturnType;
     protected parseCustomQuery(): ReturnType;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value']): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionIn>(_key: T['key'], value: T['value'], comparator: T['comparator']): ReturnType;
     protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query: T['query']): ReturnType;
     protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
     private parseConditions;

package/dist/types/src/classes/QueryMatcher.d.ts

@@ -1,17 +1,17 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, ApiQuery, EntryParentNull, FieldMap } from '../internal';
-export declare class QueryMatcher {
+import { ApiFormatter, ApiQuery, FieldMap, LinkTreeServiceInterface } from '../internal';
+export declare class QueryMatcher<ItemTypeType extends ApiEnumItemType> {
+    private linkTreeService;
     private apiFormatter;
-    itemType: ApiEnumItemType;
-    fields: FieldMap | [FieldMap, FieldMap];
-    parent: EntryParentNull;
+    itemType: ItemTypeType;
+    fields: Partial<FieldMap<ItemTypeType>> | [Partial<FieldMap<ItemTypeType>>, Partial<FieldMap<ItemTypeType>>];
     /**
+     * @param linkTreeService
      * @param apiFormatter
      * @param itemType
      * @param fields The fields to match against, if "fields" is an array index [0] should be the new/updated values, and index [1] the cached ones
-     * @param parent
      */
-    constructor(apiFormatter: ApiFormatter, itemType: ApiEnumItemType, fields: FieldMap | [FieldMap, FieldMap], parent?: EntryParentNull);
+    constructor(linkTreeService: LinkTreeServiceInterface, apiFormatter: ApiFormatter, itemType: ItemTypeType, fields: Partial<FieldMap<ItemTypeType>> | [Partial<FieldMap<ItemTypeType>>, Partial<FieldMap<ItemTypeType>>]);
     /**
      * @remark
      * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
@@ -21,4 +21,5 @@ export declare class QueryMatcher {
     private matchLinkedToQuery;
     private matchComplexQuery;
     private matchSimpleQuery;
+    private getField;
 }

package/dist/types/src/classes/RequestBuffer.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestService, ApiResponseProcessor, ChangesDeltaFactory, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, ServerCache } from '../internal';
+import { ApiQuery, ApiRequestColumns, ApiRequestService, ApiResponseProcessor, ChangesDeltaFactory, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, RequestColumnsTuple, ServerCache } from '../internal';
 export declare type RequestBufferResponse<ItemTypeType extends ApiEnumItemType = any> = ApiResponseProcessor<ItemTypeType>;
 export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = any> {
     private promiseLibrary;
@@ -16,7 +16,7 @@ export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = any> {
     containsId(itemId: ItemId): boolean;
     containsQuery(queryString: string): boolean;
     addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    addQuery(query: [ApiQuery, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    addQuery(query: [ApiQuery, string], requestColumnsTuple: RequestColumnsTuple): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     isPrivateBuffer(): boolean;

package/dist/types/src/classes/RequestBufferManager.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
-import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, ServerCache } from '../internal';
+import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, RequestColumnsTuple, ServerCache } from '../internal';
 export declare class RequestBufferManager {
     private promiseLibrary;
     private apiRequestService;
@@ -14,7 +14,7 @@ export declare class RequestBufferManager {
     setServerCache(serverCache: ServerCache): void;
     fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumns: ApiRequestColumns, usePrivateBuffer: boolean): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumnsTuple: RequestColumnsTuple, usePrivateBuffer: boolean): PromiseInterface<RequestBufferResponse>;
     private constructPrivateBuffer;
     private constructBuffer;
     private _constructBuffer;

package/dist/types/src/classes/RequestColumnExpansion.d.ts

@@ -1,15 +1,13 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumns, ColumnSet, ColumnUtil, RequestColumnMergeResult } from '../internal';
-declare type RequestColumnMap = {
-    [itemType: string]: ApiRequestColumns;
-};
+import { ApiRequestColumnMap, ApiRequestColumns, ColumnSet, ColumnUtil, RequestColumnsTuple } from '../internal';
 export declare class RequestColumnExpansion {
     private columnUtil;
     private columns;
     private columnSetIdMap;
+    private requestColumnSetIdMap;
     constructor(columnUtil: ColumnUtil);
-    expandWithRequestColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns): RequestColumnMergeResult;
-    expand<T extends ColumnSet<ApiEnumItemType>>(columnSet: T): void;
-    get(): RequestColumnMap;
+    expandWithRequestColumnsTuple(itemType: ApiEnumItemType, requestColumnsTuple: RequestColumnsTuple): void;
+    expandWithColumnSet(columnSet: ColumnSet): void;
+    expandWithRequestColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns): void;
+    get(): ApiRequestColumnMap;
 }
-export {};

package/dist/types/src/classes/RequestColumnsOperationsCache.d.ts

@@ -0,0 +1,46 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestColumnArray, ApiRequestColumns, ColumnCache, ColumnSet, ColumnUtil, RequestColumnsTuple } from '../internal';
+declare type RequestColumnSetMergeResult = {
+    merged: RequestColumnsTuple;
+    difference: RequestColumnsTuple;
+};
+declare type AggregateColumnsTuple = {
+    readonly object: ApiRequestColumnArray;
+    readonly string: string;
+};
+/**
+ * @description This class caches the results of frequently performed operations on request columns:
+ * - Merging;
+ * - Testing whether all columns of one column set are present in another (which is mainly done by merging and checking
+ * the difference);
+ * - Creating hashes (IDs) for sets of request columns.
+ */
+export declare class RequestColumnsOperationsCache<ItemTypeType extends ApiEnumItemType> {
+    readonly itemType: ItemTypeType;
+    private columnUtil;
+    private columnCache;
+    private readonly requestColumnsTuple;
+    private aggregateColumnsTuple?;
+    private expandedRequestColumnsTuple?;
+    private columnsMergedWithTupleMap;
+    private expandedColumnsMergedWithTupleMap;
+    private setContainsAllColumnsMap;
+    private setContainsAllExpandedColumnsMap;
+    constructor(itemType: ItemTypeType, columnUtil: ColumnUtil, columnCache: ColumnCache, requestColumns: ApiRequestColumns);
+    getRequestColumnsTuple(transactionCache: AbstractCache): RequestColumnsTuple;
+    getAggregateColumns(): AggregateColumnsTuple;
+    hasAggregateColumns(): boolean;
+    /**
+     *
+     * @param requestColumnsTuple
+     * @param transactionCache - When in the server cache, we'll include the columns required for delete
+     * relations and the query matcher in the operation.
+     */
+    getColumnsMergedWithTuple(requestColumnsTuple: RequestColumnsTuple, transactionCache: AbstractCache): RequestColumnSetMergeResult;
+    tupleContainsAllColumns(requestColumnsTuple: RequestColumnsTuple, transactionCache: AbstractCache): boolean;
+    setContainsAllColumns(columnSet: ColumnSet<ItemTypeType>, transactionCache: AbstractCache): boolean;
+    private mergeColumnsWithTuple;
+    private extractAggregateColumns;
+    private createRequestColumnsTuple;
+}
+export {};

package/dist/types/src/classes/TemplateCache.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, ItemTypeColumnIds, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
+import { ApiRequestColumnMap, ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, ItemTypeColumnIds, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
 export declare class TemplateCache {
     private columnUtil;
     private promiseService;
@@ -56,7 +56,7 @@ export declare class TemplateCache {
      *          );
      *  ```
      */
-    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
+    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: ApiRequestColumnMap, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
     private expandWithLinkedItemTypesDefaultColumns;
     private fetchTemplateById;
     private constructTemplateBuffer;

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

@@ -1,6 +1,6 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
 import { RmCore } from '../../core';
-import { AbstractCacheDependencyInterface, ApiRequestColumn, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, InternalChangesDelta, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, ServerCache, ServerCachedQueryHandler, TransactionCache, TransactionCachedQueryHandler, TransactionValidatorFactory } from '../../internal';
+import { AbstractCacheDependencyInterface, ApiRequestColumnArray, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, InternalChangesDelta, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, ServerCache, ServerCachedQueryHandler, TransactionCache, TransactionCachedQueryHandler, TransactionValidatorFactory } from '../../internal';
 export declare type TransactionOptions = {
     /**
      * @description
@@ -24,7 +24,7 @@ export declare abstract class AbstractCache {
      *
      * todo[limit] move to TransactionCache ?
      */
-    abstract expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    abstract expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumnArray): PromiseInterface<CollectionResourceParentIdMap>;
     /**
      * @description
      * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
@@ -62,7 +62,6 @@ export declare abstract class AbstractCache {
      */
     abstract applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate: boolean): void;
     abstract getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    abstract getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
     abstract getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
     abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
     protected getParentFromFields<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields?: FieldMap<ItemTypeType>): EntryParentNull;

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

@@ -1,13 +1,24 @@
-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';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiQuery, ApiRequestLimit, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnUtil, EntryParentNull, ItemEntry, ParentItemMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, RequestColumnsTuple } from '../../internal';
 export declare type CachedQueryItemTree<ItemTypeType extends ApiEnumItemType = any> = {
     item: CachedQueryItem<ItemTypeType>;
     children: ParentItemMap<CachedQueryItemTree> | null;
 };
+/**
+ * We're using a subset of the collection options here, because whenever we access the columns, we'd want to do it
+ * through the columns operations cache.
+ */
+export declare type CachedQueryOptions = {
+    limit: ApiRequestLimit | null;
+    preventCaching: boolean;
+    usePrivateBuffer: boolean;
+    parent: EntryParentNull;
+};
 export declare abstract class CachedQueryHandlerBase {
     protected collectionEntryService: CollectionEntryService;
     protected columnUtil: ColumnUtil;
     protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    protected requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
     protected promiseService: PromiseLibraryInterface;
     protected transaction: AbstractCache;
     /**
@@ -22,34 +33,24 @@ export declare abstract class CachedQueryHandlerBase {
             [queryString: string]: CachedQueryItem;
         };
     };
-    protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, promiseService: PromiseLibraryInterface, transaction: AbstractCache);
+    protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory, 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>;
+    setCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumnsTuple: RequestColumnsTuple, 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>>>;
+    abstract __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CachedQueryOptions, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<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>[];
-    abstract __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, newColumns: ApiRequestColumns, usePrivateBuffer: boolean, force: boolean, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    abstract __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, usePrivateBuffer: boolean, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     /**
      * @description
      * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CacheSyncer CacheSyncer} to function.
@@ -59,7 +60,7 @@ export declare abstract class CachedQueryHandlerBase {
     /**
      * 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>;
+    protected constructCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], requestColumnsTuple: RequestColumnsTuple): CachedQueryItem<ItemTypeType>;
     /**
      * @description
      * Adds the passed {@link ItemEntry ItemEntries} to the Transaction's query cache,

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

@@ -1,16 +1,13 @@
 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';
+import { AbstractCache, ApiFormatter, ApiQuery, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ColumnInfo, ColumnUtil, ErrorHandlerInterface, FieldMap, ItemCache, ItemCacheFactory, ItemEntry, ItemEntryFactory, ItemEntryOptions, ItemTypeColumnId, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory } 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>;
+    changes: FieldMap<ItemTypeType>;
 }
 export declare type ProcessItemEntryChangesResult<ItemTypeType extends ApiEnumItemType> = {
     status: ItemCacheStatus.NO_CHANGES | ItemCacheStatus.NOT_CACHED;
@@ -28,17 +25,19 @@ export declare abstract class ItemHandlerBase {
     protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
     protected transaction: AbstractCache;
     readonly entries: ItemCache;
-    abstract itemChanges: {
-        [itemEntryId: number]: ItemEntryChanges<any>;
+    itemChanges: {
+        [itemEntryId: number]: FieldMap;
     };
     protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
+    lookUpItemField<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(entry: ItemEntry<ItemTypeType>, columnId: ColumnId): undefined | FieldMap<ItemTypeType>[ColumnId];
+    collectFields<ItemTypeType extends ApiEnumItemType>(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
      */
-    abstract copyTransactionItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: TransactionItemEntryChanges<ItemTypeType>, entry: ItemEntry<ItemTypeType>): ItemEntryChanges<ItemTypeType>;
+    copyTransactionItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: FieldMap<ItemTypeType>, entry: ItemEntry<ItemTypeType>): FieldMap<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 !

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

@@ -1,5 +1,5 @@
 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';
+import { AbstractCache, ApiRequestColumnArray, 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}
@@ -15,7 +15,7 @@ export declare class ServerCache extends AbstractCache {
     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>;
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumnArray): PromiseInterface<CollectionResourceParentIdMap>;
     /**
      *
      * @param response
@@ -49,7 +49,6 @@ export declare class ServerCache extends AbstractCache {
      * 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

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

@@ -1,26 +1,27 @@
-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';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CachedQueryOptions, CollectionEntryService, CollectionQuery, ColumnUtil, ErrorHandlerInterface, ItemEntry, PromiseInterface, PromiseLibraryInterface, RequestBufferManager, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, 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>>>;
+    constructor(requestColumnOperationsCacheFactory: RequestColumnsOperationsCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, transaction: ServerCache);
     __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>(itemType: ItemTypeType, queryString: string, newColumns: ApiRequestColumns, usePrivateBuffer: boolean, force: boolean, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, usePrivateBuffer: boolean, batchedLinkedToQuery?: CollectionQuery): 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>>;
-    private expandColumnsWithCachedQueryColumns;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CachedQueryOptions, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * 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.
+     */
+    expandColumnsWithRequiredColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns): ApiRequestColumns;
 }

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

@@ -1,22 +1,18 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiFormatter, ApiQuery, ApiRequestColumns, ApiResponseProcessor, ChangesDelta, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ColumnExpansion, ColumnSet, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, ItemCacheFactory, ItemEntry, ItemEntryChanges, ItemEntryFactory, ItemEntryOptions, ItemHandlerBase, ProcessItemEntryChangesResult, PromiseInterface, PromiseLibraryInterface, QueryParserFactory, QueryService, RequestBufferManager, RequestBufferResponse, RequestColumnExpansionFactory, ServerCache, TransactionItemEntryChanges } from '../../../internal';
+import { ApiFormatter, ApiQuery, ApiRequestColumns, ApiResponseProcessor, ChangesDelta, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ColumnExpansion, ColumnSet, ColumnUtil, ErrorHandlerInterface, ItemCacheFactory, ItemEntry, ItemEntryFactory, ItemEntryOptions, ItemHandlerBase, ProcessItemEntryChangesResult, PromiseInterface, PromiseLibraryInterface, QueryParserFactory, QueryService, RequestBufferManager, RequestBufferResponse, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, ServerCache } from '../../../internal';
 export declare class ServerItemHandler extends ItemHandlerBase {
     private requestBufferManager;
     private queryParserFactory;
     private queryService;
-    private columnSubsetCacheFactory;
+    private requestColumnsOperationsCacheFactory;
     protected transaction: ServerCache;
-    itemChanges: {
-        [itemEntryId: number]: ItemEntryChanges<any>;
-    };
-    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
+    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
      * Processes updates on a cached entry
      */
     processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
-    copyTransactionItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: TransactionItemEntryChanges<ItemTypeType>, entry: ItemEntry<ItemTypeType>): ItemEntryChanges<ItemTypeType>;
     fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     extendItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemEntries: ItemEntry<ItemTypeType>[], newColumns: ApiRequestColumns): PromiseInterface<ItemEntry<ItemTypeType>[]>;

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeColumnIds, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChangesTuple, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumnArray, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryChangesTuple, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeColumnIds, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
 declare type ItemResourceLinks<ItemTypeType extends ApiEnumItemType> = {
     main: ItemResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
@@ -100,7 +100,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Expands the collection with the new request columns, assumes that all collections have the same itemType
      */
-    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumnArray): PromiseInterface<CollectionResourceParentIdMap>;
     registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     createChangesDelta(): ChangesDelta;
     getFirstErrorString(): undefined | string;
@@ -159,14 +159,6 @@ export declare class TransactionCache extends AbstractCache {
      */
     getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
-    /**
-     * @description
-     * Traverses the transaction chain and returns the changes of the item on the first transaction
-     *
-     * @param itemEntryId The entry ID of the ItemEntry you want to get the changes from
-     * @param copyFields If set, will call {@link ApiFormatter.copyFields ApiFormatter.copyFields}, otherwise just returns the object
-     */
-    getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
     /**
      * @description
      * Removes the {@link CollectionResource CollectionResource} from the transaction, preventing the {@link CollectionResource.options.onAdd onAdd} and {@link CollectionResource.options.onRemove onRemove} callbacks from being called.
@@ -281,7 +273,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Gets an already cached {@link ItemEntry ItemEntry} and the changes of this specific transaction for that entry
      */
-    getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): TransactionItemEntryChangesTuple<ItemTypeType>;
+    getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
     /**
      * @description
      * Gets an ItemEntry from the cache, doesn't do a API request, used for saving

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, CachedQueryHandlerBase, CachedQueryItem, CachedQueryItemTree, ChildCollectionOptions, CollectionOptions, CollectionQuery, ColumnSubsetCache, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemTypeMap, ParentIdMap, ParentItemMap, PromiseInterface, TransactionCache, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
+import { ApiQuery, CachedQueryHandlerBase, CachedQueryItem, CachedQueryItemTree, CachedQueryOptions, ChildCollectionOptions, CollectionOptions, CollectionQuery, EntryParentNull, ItemEntry, ItemIdConversionMap, ItemTypeMap, ParentItemMap, PromiseInterface, RequestColumnsOperationsCache, TransactionCache, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
 export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
     private dependencies;
     private itemHandler;
@@ -12,17 +12,28 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
      * @param conversionMap ConversionMap with the updated IDs
      */
     updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
-    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, newColumns: ApiRequestColumns, usePrivateBuffer: boolean, force: boolean, _batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
+     */
+    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, usePrivateBuffer: boolean, _batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): void;
     /**
      * @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(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
-    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    isLocal(options: {
+        parent: EntryParentNull;
+    }, query: ApiQuery): boolean;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CachedQueryOptions, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @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<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptions, batchedQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>[]>;
     __fetchParentCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItemTree<ItemTypeType>>;
     __fetchChildCachedQueryItems(parentItemType: ApiEnumItemType, parentItemIds: ItemId[], collectionOptions: ChildCollectionOptions, batchQueries?: ItemTypeMap<CollectionQuery>): PromiseInterface<ParentItemMap<CachedQueryItemTree>>;
     private createBatchQueryMap;