@rentman/rm-core 8.0.2 → 8.1.0

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
@@ -52,11 +58,11 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      *
      * @internal
      */
-    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): this;
+    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean): this;
     /**
      * @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/ChangesProcessor.d.ts

@@ -1,5 +1,5 @@
-import { ApiRequestService, CollectionEntryService, ItemEntryService } from '../classes';
-import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
+import { ApiRequestService, ItemEntryService } from '../classes';
+import { ChangesCompilationFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemIdConversionMap, PromiseInterface } from '../types';
@@ -13,19 +13,17 @@ export declare class ChangesProcessor {
     private changesDeltaFactory;
     private apiRequestService;
     private changesCompilationFactory;
-    private columnExpansionFactory;
     private createRequestFactory;
     private errorHandler;
     private promiseService;
     private requestColumnExpansionFactory;
-    private collectionEntryService;
     private itemEntryService;
     private transaction;
     private breakUpByParent?;
     private onAfterCreateCallback?;
     private itemIdConversionMap;
     private serverCache;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
     /**
      * @description
      * Executes the requests in the order of:

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/CreatedChangesDelta.d.ts

@@ -5,12 +5,13 @@ export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ApiEnumItem
     itemId: ItemId;
     fields: FieldMap<ItemTypeType>;
     columns: ColumnSet<ItemTypeType>;
+    isRoot: boolean;
 };
 export declare class CreatedChangesDelta {
     private tuples;
     constructor();
     remove(itemType: ApiEnumItemType, itemId: ItemId): boolean;
-    add<ItemTypeType extends ApiEnumItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>): void;
+    add<ItemTypeType extends ApiEnumItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, isRoot?: boolean): void;
     isEmpty(): boolean;
     forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ApiEnumItemType, index: number) => void): void;
     contains(itemType: ApiEnumItemType): boolean;

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/ItemCreateService.d.ts

@@ -20,6 +20,6 @@ export declare class ItemCreateService {
      * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
      */
     createItemsFromValues<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<Partial<FieldMap<ItemTypeType, ColumnIds>>>, parent?: EntryParentNull): PromiseInterface<void>;
-    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback, isRoot?: boolean): void;
     processTemplateLinkItems<ParentItemType extends ApiEnumItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
 }

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/QueryParserIdUpdater.d.ts

@@ -1,16 +1,16 @@
 import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap } from '../types';
 import { QueryParserBase } from './QueryParserBase';
-export declare class QueryParserIdUpdater extends QueryParserBase<void> {
+export declare class QueryParserIdUpdater extends QueryParserBase<boolean> {
     private itemIdConversionMap;
     constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
-    protected parseEmptyQuery(): void;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): void;
-    protected parseSubFieldQuery(): void;
-    protected parseSearchQuery(): void;
-    protected parseCustomQuery(): void;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): void;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): void;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): void;
+    protected parseEmptyQuery(): boolean;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): boolean;
+    protected parseSubFieldQuery(): boolean;
+    protected parseSearchQuery(): boolean;
+    protected parseCustomQuery(): boolean;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): boolean;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): boolean;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): boolean;
     private parseConditions;
 }

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,7 +2,7 @@ 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';
@@ -10,7 +10,6 @@ import { ColumnUtil } from '../ColumnUtil';
 import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
 import { ItemCache } from '../ItemCache';
 import { AbstractCache } from './AbstractCache';
-import { ServerItemEntryChanges } from './server/ServerItemHandler';
 import { TransactionItemEntryChanges } from './transaction/TransactionItemHandler';
 export declare enum ItemCacheStatus {
     CACHED = "cached",
@@ -34,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);
     /**
@@ -58,12 +57,12 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Fetches an ItemEntry with the given itemId
      */
-    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Processes the passed {@link ChangesDeltaItemUpdateDelta update delta} on the transaction, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed
      */
-    abstract processItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): 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
@@ -104,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): 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.