@rentman/rm-core 8.0.3 → 8.1.1

package/dist/types/classes/ApiFormatter.d.ts

@@ -1,7 +1,7 @@
-import { ApiEnumApiType, ApiEnumApiTypeTsTypeMapping, ApiEnumItemType, ApiFields, ResponseColumn } from '@rentman/backend-types';
+import { ApiEnumApiType, ApiEnumItemType, ApiFields, ResponseColumn } from '@rentman/backend-types';
 import moment from 'moment';
 import { ColumnInfo } from '../classes';
-import { FieldMap } from '../types';
+import { ApiEnumApiTypeToTsTypeMap, FieldMap } from '../types';
 declare type GetChangesResult<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> = {
     oldValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
     newValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
@@ -42,7 +42,7 @@ export declare class ApiFormatter {
      * @description
      * Compares the given fields, returns `true` when the fields are equal
      */
-    compareFields<ColumnType extends ApiEnumApiType>(columnType: ColumnType, first?: ApiEnumApiTypeTsTypeMapping[ColumnType], second?: ApiEnumApiTypeTsTypeMapping[ColumnType]): boolean;
+    compareFields<ColumnType extends ApiEnumApiType>(columnType: ColumnType, first?: ApiEnumApiTypeToTsTypeMap[ColumnType], second?: ApiEnumApiTypeToTsTypeMap[ColumnType]): boolean;
     compareFloats(a: number, b: number): boolean;
     compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
     compareDurations(first: moment.Duration, second: moment.Duration): boolean;

package/dist/types/classes/ChangesDelta.d.ts

@@ -7,6 +7,7 @@ import { ColumnSet } from './ColumnSet';
 import { CreatedChangesDelta } from './CreatedChangesDelta';
 import { ItemCreateService } from './ItemCreateService';
 import { ItemEntryService } from './ItemEntryService';
+export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
 /**
  * @description
  * ChangesDelta used to apply changes from outside of the core to a transaction
@@ -22,6 +23,9 @@ export declare class ChangesDelta extends ChangesDeltaBase {
     private errorHandler;
     private itemCreateService;
     created: CreatedChangesDelta;
+    deleted: {
+        [itemType: string]: ChangesDeltaItemDeleteDelta[];
+    };
     constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
     /**
      * @description
@@ -32,6 +36,8 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * - If you want to set a parent set the proper field, you can't pass it as a separate object
      */
     setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemType: ItemTypeType, values: Fields): PromiseInterface<this>;
+    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
+    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
     /**
      * @description
      * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
@@ -57,6 +63,6 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * @description
      * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
      */
-    setItemMoved(entry: ItemEntry, to: EntryParent): this;
+    setItemMoved(entry: ItemEntry, to: EntryParent, updateModified?: boolean, updateInitial?: boolean): this;
     isEmpty(): boolean;
 }

package/dist/types/classes/ChangesDeltaBase.d.ts

@@ -1,8 +1,10 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemEntry } from '../models';
 import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemIdConversionMap } from '../types';
+import { TransactionItemEntryChanges } from './cache/transaction/TransactionItemHandler';
 import { ItemEntryService } from './ItemEntryService';
 export declare type ChangesDeltaResult = {
+    itemIdConversionMap: ItemIdConversionMap;
     created: ItemEntry[];
 };
 /**
@@ -16,17 +18,44 @@ export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiEnumItem
         fields: FieldMap<ItemTypeType>;
         parent: EntryParentNull;
     };
+    /**
+     * @description
+     * Should be set to `true` when either the changes are made by the user, or when it's the direct result (not derived value) of a create/update API call
+     */
+    updateModified: boolean;
+    /**
+     * @description
+     * Should be set to `true` when the changes are a result of an API call
+     */
+    updateInitial: boolean;
 };
-export declare type ChangesDeltaItemDeleteDelta = ItemEntry[];
 export declare abstract class ChangesDeltaBase {
     protected itemEntryService: ItemEntryService;
     updated: {
         [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
     };
-    deleted: {
-        [itemType: string]: ChangesDeltaItemDeleteDelta;
-    };
     itemIdConversionMap: ItemIdConversionMap;
+    /**
+     * Only contains remote items, when rolling back local items the whole entries are deleted.
+     */
+    restored: {
+        [itemEntryId: number]: {
+            entry: ItemEntry;
+            changes: TransactionItemEntryChanges;
+        };
+    };
+    /**
+     * @private
+     * @warning
+     * Do not set in frontend
+     */
+    __isUndo: boolean;
+    /**
+     * @private
+     * @warning
+     * Do not set in frontend
+     */
+    __isRedo: boolean;
     /**
      * @private
      */
@@ -44,8 +73,7 @@ export declare abstract class ChangesDeltaBase {
      * @private
      */
     _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[]): void;
-    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull): this;
-    setItemDeleted(deleted: ItemEntry): this;
-    setItemsDeleted(deleted: ItemEntry[]): this;
+    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, updateModified?: boolean, updateInitial?: boolean): this;
+    setItemRestored(itemEntry: ItemEntry, transactionItemEntryChanges: TransactionItemEntryChanges): void;
     isEmpty(): boolean;
 }

package/dist/types/classes/CollectionMatcherBase.d.ts

@@ -3,7 +3,7 @@ import { AbstractCache, CollectionQuery, FieldMap, QueryService } from '../';
 import { QueryMatcherFactory } from '../factories/';
 import { ItemEntry } from '../models';
 import { GroupedCollectionMatcherResult } from './cache/CollectionMatcherCachedQueryProcessor';
-import { InternalChangesDelta } from './InternalChangesDelta';
+import { ParentChangesDelta } from './ParentChangesDelta';
 export declare type CollectionMatcherMatches<ItemTypeType extends ApiEnumItemType = any> = {
     [itemId: number]: {
         item: ItemEntry<ItemTypeType>;
@@ -16,7 +16,7 @@ export declare abstract class CollectionMatcherBase {
     protected transaction: AbstractCache;
     protected constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
     expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
-    processDelta(internalChangesDelta: InternalChangesDelta): this;
+    processDelta(parentChangesDelta: ParentChangesDelta): this;
     protected groupItemEntries<ItemTypeType extends ApiEnumItemType>(matches: CollectionMatcherMatches<ItemTypeType>): GroupedCollectionMatcherResult<ItemTypeType>;
     protected abstract _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
 }

package/dist/types/classes/ConversionMapService.d.ts

@@ -15,7 +15,7 @@ export declare class ConversionMapService {
     constructor(keyService: KeyService);
     createLocalConversionMap(itemType: ApiEnumItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
     expandLocalConversionMap(parentType: ApiEnumItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
-    expandConversionMap(itemEntry: ItemEntry, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
+    expandConversionMap(itemType: ApiEnumItemType, itemId: ItemId, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
     batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
     getConversionValue(itemType: ApiEnumItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
     /**

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

@@ -1,12 +1,17 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
 import { ItemEntry } from '../models';
 import { EntryParent, FieldMap, ItemIdConversionMap } from '../types';
+import { TransactionItemEntryChanges } from './cache/transaction/TransactionItemHandler';
 import { ChangesDeltaBase } from './ChangesDeltaBase';
 import { ItemEntryService } from './ItemEntryService';
 export declare type InternalCreateDelta<ItemTypeType extends ApiEnumItemType = any> = {
     entry: ItemEntry<ItemTypeType>;
     fields: FieldMap<ItemTypeType>;
 };
+export declare type InternalChangesDeltaItemDeleteDelta = {
+    entry: ItemEntry;
+    changes: TransactionItemEntryChanges;
+};
 /**
  * @description
  * ChangesDelta used internally by the core
@@ -16,12 +21,15 @@ export declare type InternalCreateDelta<ItemTypeType extends ApiEnumItemType = a
  * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the InternalChangesDelta
  * assumes 'created' entries are already existing, so it has a different format.
  *
- * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent} and {@link TransactionCache.applyChangesFromChild applyChangesFromChild}
+ * Use this when calling {@link TransactionCache.applyChangesFromChild applyChangesFromChild}
  */
 export declare class InternalChangesDelta extends ChangesDeltaBase {
     created: {
         [itemEntryId: string]: InternalCreateDelta;
     };
+    deleted: {
+        [itemType: string]: InternalChangesDeltaItemDeleteDelta[];
+    };
     moved: {
         [itemEntryId: number]: {
             entry: ItemEntry;
@@ -30,6 +38,9 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
     };
     itemIdConversionMap: ItemIdConversionMap;
     constructor(itemEntryService: ItemEntryService);
+    setItemDeleted(tuple: InternalChangesDeltaItemDeleteDelta): this;
+    setItemsDeleted(deleted: InternalChangesDeltaItemDeleteDelta[]): this;
+    private itemIsDeleted;
     setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
     /**
      * @remark

package/dist/types/classes/ParentChangesDelta.d.ts

@@ -0,0 +1,47 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ItemEntry } from '../models';
+import { EntryParent, FieldMap, ItemIdConversionMap } from '../types';
+import { ChangesDeltaItemDeleteDelta } from './ChangesDelta';
+import { ChangesDeltaBase } from './ChangesDeltaBase';
+import { ItemEntryService } from './ItemEntryService';
+export declare type InternalCreateDelta<ItemTypeType extends ApiEnumItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    fields: FieldMap<ItemTypeType>;
+};
+export declare type ParentChangesDeltaItemDeleteDelta = ItemEntry;
+/**
+ * @description
+ * ChangesDelta used internally by the core
+ *
+ * ----------
+ *
+ * The difference between {@link ParentChangesDelta ParentChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ParentChangesDelta
+ * assumes 'created' entries are already existing, and deletedEntries don't have changes (since you cannot undo an action that happened on a parent on a child transaction)
+ *
+ * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent}
+ */
+export declare class ParentChangesDelta extends ChangesDeltaBase {
+    created: {
+        [itemEntryId: string]: InternalCreateDelta;
+    };
+    deleted: {
+        [itemType: string]: ParentChangesDeltaItemDeleteDelta[];
+    };
+    moved: {
+        [itemEntryId: number]: {
+            entry: ItemEntry;
+            to: EntryParent;
+        };
+    };
+    itemIdConversionMap: ItemIdConversionMap;
+    constructor(itemEntryService: ItemEntryService);
+    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
+    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
+    setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: 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)
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent): void;
+    isEmpty(): boolean;
+}

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

@@ -1,12 +1,14 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
+import { RmCore } from '../core';
 import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
-import { EntryParentNull, PromiseInterface } from '../types';
+import { ApiResponse, EntryParentNull, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
 import { ColumnHandler } from './ColumnHandler';
 import { ColumnUtil } from './ColumnUtil';
 export declare class TemplateCache {
+    private core;
     private columnUtil;
     private promiseService;
     private columnHandler;
@@ -15,19 +17,20 @@ export declare class TemplateCache {
     private requestColumnExpansionFactory;
     private apiRequestService;
     private pendingTemplateBufferMap;
-    templates: {
-        [itemType: string]: Template<any>;
+    templateResponses: {
+        [itemType: string]: ApiResponse;
     };
-    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
+    constructor(core: RmCore, columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
     /**
      * @description
-     * Fetches a {@link Template template}, {@link TransactionItemHandler.createItems TransactionItemHandler.createItems} is a convenience function for this
+     * Fetches a {@link Template template}, use {@link ItemCreateService.createItemsFromValues createItemsFromValues} to easily create new items from a set of values.
+     * The best way to process the template's values is to call {@link ItemCreateService.processTemplate processTemplate}
      *
      * @param itemType The {@link ApiEnumItemType ItemType} of the template item
      * @param itemId Used for caching, multiple concurrent template calls for the same itemId will return the same template
      * @param templateOptions
      * @param templateColumns Additional columns to be fetched, will be stored in the template - warning - the Template won't have values for those columns
-     * @param entryParentOrParentItemType An optional {@link EntryParentNull entry parent} or {@link ItemType parent itemType}, if the parent is passed the templateColumns will be expanded with the proper link columns (Through {@link ColumnUtil.getColumnsFromLink ColumnUtil.getColumnsFromLink})
+     * @param entryParentOrParentItemType An optional {@link EntryParentNull entry parent} or {@link ApiEnumItemType parent itemType}, if the parent is passed the templateColumns will be expanded with the proper link columns (Through {@link ColumnUtil.getColumnsFromLink ColumnUtil.getColumnsFromLink})
      *
      * @example
      * ```
@@ -51,13 +54,13 @@ export declare class TemplateCache {
      *              for (const itemResource of selectedItems) {
      *                  changesDelta.setItemCreated(
      *                      core.keyService.getLocalId(),
-     *                      template.fields,
+     *                      template.getFields(),
      *                      template.columns,
      *                      parent,
      *                  );
      *              }
      *
-     *              transaction.applyChangesDelta(changesDelta);
+     *              return transaction.applyChangesDelta(changesDelta);
      *          );
      *  ```
      */

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

@@ -4,10 +4,11 @@ import { AbstractCacheDependencyInterface } from '../../interfaces';
 import { ItemEntry } from '../../models';
 import { ApiRequestColumn, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, ItemIdConversionMap, PromiseInterface } from '../../types';
 import { ChangesDelta } from '../ChangesDelta';
-import { ChangesDeltaResult } from '../ChangesDeltaBase';
+import { ChangesDeltaBase, ChangesDeltaResult } from '../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../ChangesProcessor';
 import { InternalChangesDelta } from '../InternalChangesDelta';
 import { ItemCache } from '../ItemCache';
+import { ParentChangesDelta } from '../ParentChangesDelta';
 import { CachedQueryItem } from './CachedQueryHandlerBase';
 import { ItemHandlerBase } from './ItemHandlerBase';
 import { ServerCache } from './server/ServerCache';
@@ -17,6 +18,13 @@ import { TransactionCache } from './transaction/TransactionCache';
 import { TransactionCachedQueryHandler } from './transaction/TransactionCachedQueryHandler';
 import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
 import { TransactionValidatorFactory } from './transaction/TransactionValidator';
+export declare type TransactionOptions = {
+    /**
+     * @description
+     * Sets the TransactionCache to 'transparent' mode, whenever {@link AbstractCache.createChild createChild} is called it will actually be called on the parent
+     */
+    transparent: boolean;
+};
 export declare abstract class AbstractCache {
     dependencies: AbstractCacheDependencyInterface;
     core: RmCore;
@@ -25,7 +33,7 @@ export declare abstract class AbstractCache {
     readonly cachedQueryHandler: TransactionCachedQueryHandler | ServerCachedQueryHandler;
     parent: AbstractCache | null;
     protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
-    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
+    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
     /**
      * @description
@@ -68,7 +76,7 @@ export declare abstract class AbstractCache {
      *
      * @internal
      */
-    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
+    abstract applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate: boolean): void;
     abstract getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
@@ -90,14 +98,15 @@ export declare abstract class AbstractCache {
      *
      * @private
      */
-    protected _applyChangesDelta(changesDelta: ChangesDelta): {
+    protected _applyChangesDelta(changesDelta: ChangesDelta | InternalChangesDelta): {
         result: ChangesDeltaResult;
-        internalChangesDelta: InternalChangesDelta;
-        matchingDelta: InternalChangesDelta;
+        parentChangesDelta: ParentChangesDelta;
+        matchingDelta: ParentChangesDelta;
+        undoFunctions: Array<(changesDelta: InternalChangesDelta) => void>;
     };
     /**
      * @description
      * Ensures that for all updated items in the delta the required derived values are present
      */
-    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDelta): PromiseInterface<void>;
+    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDeltaBase): PromiseInterface<void>;
 }

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

@@ -2,16 +2,14 @@ import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, PromiseInterface } from '../../types';
+import { ApiQuery, FieldMap, PromiseInterface } from '../../types';
 import { ApiFormatter } from '../ApiFormatter';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
 import { ColumnInfo } from '../ColumnInfo';
 import { ColumnUtil } from '../ColumnUtil';
 import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
-import { InternalChangesDelta } from '../InternalChangesDelta';
 import { ItemCache } from '../ItemCache';
 import { AbstractCache } from './AbstractCache';
-import { ServerItemEntryChanges } from './server/ServerItemHandler';
 import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
 export declare enum ItemCacheStatus {
     CACHED = "cached",
@@ -35,7 +33,7 @@ export declare abstract class ItemHandlerBase {
     protected transaction: AbstractCache;
     readonly entries: ItemCache;
     abstract itemChanges: {
-        [itemEntryId: string]: ServerItemEntryChanges | TransactionItemEntryChanges;
+        [itemEntryId: string]: any;
     };
     protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
     /**
@@ -64,7 +62,7 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Processes the passed {@link ChangesDeltaItemUpdateDelta update delta} on the transaction, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed
      */
-    abstract processItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean, changesDelta?: InternalChangesDelta): ProcessItemEntryChangesResult<ItemTypeType>;
+    abstract processItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
     /**
      * @description
      * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
@@ -105,5 +103,4 @@ export declare abstract class ItemHandlerBase {
      * Gets the value of the given column, will look into the current delta before attempting to read itemChanges
      */
     protected getItemIdByColumn<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
-    expandColumnsWithCachedQueryColumns(itemType: ApiEnumItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
 }

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

@@ -1,12 +1,13 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ChangesDelta, InternalChangesDelta, TransactionCache, TransactionValidatorFactory } from '../..';
+import { ChangesDelta, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../..';
 import { RmCore } from '../../../core';
 import { ServerCacheDependencyInterface } from '../../../interfaces/ServerCacheDependencyInterface';
 import { ItemEntry } from '../../../models';
-import { ApiRequestColumn, ApiRequestColumnMap, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, PromiseInterface } from '../../../types';
+import { ApiRequestColumn, ApiRequestColumnMap, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, ItemTypeMap, PromiseInterface } from '../../../types';
 import { ApiResponseProcessor } from '../../ApiResponseProcessor';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
+import { ParentChangesDelta } from '../../ParentChangesDelta';
 import { AbstractCache } from '../AbstractCache';
 import { CachedQueryItem } from '../CachedQueryHandlerBase';
 import { ServerCachedQueryHandler } from './ServerCachedQueryHandler';
@@ -25,14 +26,24 @@ export declare class ServerCache extends AbstractCache {
     parent: null;
     constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
     getServerCache(): ServerCache;
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
     expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
+    /**
+     *
+     * @param response
+     * @param requestColumnMap
+     * @param isCalledAfterSocketUpdate
+     * @param changesDelta
+     * @param conversionMap
+     * @param directRequestItemMap Should be a map of ItemType->ItemId of items that were directly part of the create/update request (queries should be excluded from this because we don't want to overwrite the user's changes (derived values are also queries))
+     */
+    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, directRequestItemMap?: ItemTypeMap<Record<string, boolean>>, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
     /**
      * @description
-     * Applies the changes of the changesDelta created by the API call ({@link ChangesProcessor ChangesProcessor}/{@link SocketMessageHandler SocketMessageHandler}, or manually through a module function) on all caches
+     * Applies changes to this transaction and its children
+     * ServerCache.applyChangesFromParent should be used when processing an API update/create/delete
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
+    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
     /**
      * @description
      * Gets the fields required to set the parent
@@ -74,9 +85,9 @@ export declare class ServerCache extends AbstractCache {
     /**
      * @description
      * Applies changes to this transaction and its children
-     * Differs from {@link TransactionCache.applyChangesDelta TransactionCache.applyChangesDelta} in the handling of deleted entries and the applyChangesFromParent call
+     * ServerCache.applyChangesDelta should be used when processing an API response which should create new entries on the ServerCache (such as a Query)
      */
-    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
     getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;

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

@@ -25,7 +25,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      * @description
      * Processes updates on a cached entry
      */
-    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): ServerItemEntryChanges;
     fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
@@ -43,7 +43,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      * General way to process an API response.
      * Will call {@link ChangesDelta.setItemCreated setItemCreated} if an entry doesn't exist yet, and otherwise {@link ChangesDelta.setItemUpdated setItemUpdated} if it does.
      */
-    processApiResponse<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemIdOfExistingItem: ItemId, itemIdInResponse: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>): void;
+    processApiResponse<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemIdOfExistingItem: ItemId, itemIdInResponse: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>, updateModified?: boolean): void;
     /**
      * @description
      * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ChangesDelta, InternalChangesDelta, ServerCache, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../..';
+import { ChangesDelta, InternalChangesDelta, ServerCache, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../..';
 import { RmCore } from '../../../core';
 import { AbstractCacheDependencyInterface } from '../../../interfaces/AbstractCacheDependencyInterface';
 import { CollectionResource, ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
@@ -8,6 +8,7 @@ import { ApiQuery, ApiRequestColumn, ApiRequestColumns, CollectionDefinition, Co
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
 import { ModuleChangesCompilationResult } from '../../ModuleChangesCompilation';
+import { ParentChangesDelta } from '../../ParentChangesDelta';
 import { AbstractCache } from '../AbstractCache';
 import { CachedQueryItem } from '../CachedQueryHandlerBase';
 import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
@@ -20,6 +21,7 @@ export declare enum TransactionErrorLevel {
     warning = "warning",
     error = "error"
 }
+export declare type UndoFunction = () => PromiseInterface<ChangesDeltaResult>;
 /**
  * @description
  * The {@link TransactionCache TransactionCache} is responsible for keeping track of newly created {@link ItemEntry ItemEntries}
@@ -91,14 +93,20 @@ export declare class TransactionCache extends AbstractCache {
     readonly collectionHandler: TransactionCollectionHandler;
     readonly eventHandler: TransactionEventHandler;
     private readonly validator?;
+    private readonly options;
     private _isValid;
+    private historyStep;
+    private undoDeltas;
+    private appliedDeltas;
     constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
     /**
      * @description
      * For debugging purposes
      */
-    id?: string | undefined, validatorFactory?: TransactionValidatorFactory);
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
+    id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
+    undo(): ReturnType<UndoFunction>;
+    redo(): ReturnType<TransactionCache['applyChangesDelta']>;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
     destroy(): void;
     expandCollectionResource(collectionResource: CollectionResource, newColumns: ApiRequestColumns): PromiseInterface<void>;
     /**
@@ -138,11 +146,8 @@ export declare class TransactionCache extends AbstractCache {
      *
      * ------------------
      * Use {@link TransactionCache.applyChangesDelta applyChangesDelta} if you want to apply changes from outside the core
-     *
-     * @param internalChangesDelta Changes to be applied
-     * @param isCalledAfterApiSave If 'isCalledAfterApiSave' is true local changes will always be overwritten (instead of only when there are no changes)
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
+    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<void>;
     /**
      * @description
      * Applies changes to this transaction and its children
@@ -151,12 +156,8 @@ export declare class TransactionCache extends AbstractCache {
      *
      * 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 itself (result vs cause)
-     *
-     * ------------------
-     *
-     * Differs from {@link ServerCache.applyChangesDelta ServerCache.applyChangesDelta} in the handling of deleted entries and the applyChangesFromParent call
      */
-    applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta | InternalChangesDelta): PromiseInterface<ChangesDeltaResult>;
     getServerCache(): ServerCache;
     /**
      * @description

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

@@ -4,7 +4,7 @@ import { ItemEntry, ItemEntryOptions } from '../../../models';
 import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { ChangesDeltaItemCreateDelta, ColumnSubsetCache, InternalChangesDelta } from '../../index';
+import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
 import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
 import { TransactionValidator } from './TransactionValidator';
@@ -35,6 +35,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
         };
     };
     constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    updateLocalItemIdReferences(itemType: ApiEnumItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta?: ChangesDeltaBase, isCalledAfterSave?: boolean): void;
     registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
@@ -57,11 +58,9 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     detectEntryChanges(itemEntryId: ItemEntry['id']): boolean;
     /**
      * @description
-     * Processes on a cached entry, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed, unless forceOverwrite is set
+     * Processes on a cached entry, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed unless `createItemChangesIfNoneExist` is set
      *
      * @param itemEntryChangesTuple The changes tuple
-     * @param forceOverwrite Instead of calling {@link ApiFormatter.mergeCopyFields mergeCopyFields}, {@link ApiFormatter.copyFields copyFields} will be used (because API values are always right)
-     * @param updateInitial Should be `true` if called by applyChangesFromParent
      * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
      * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
      * @param changesDelta Will be used to check which items should/shouldn't be updated when updating local ID references
@@ -69,7 +68,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @returns
      * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
      */
-    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean, changesDelta?: InternalChangesDelta): ProcessItemEntryChangesResult<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
     cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
     cloneItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
     fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
@@ -95,5 +94,4 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private getColumnDifference;
     private expandLocalItemEntry;
     private getLocalValues;
-    private updateLocalItemIdReferences;
 }