@rentman/rm-core 8.0.2 → 8.1.0

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
@@ -309,7 +310,7 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, isNew?: boolean): ItemResource<ItemTypeType>;
     createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType, ColumnIds>>;
     processLinkedItems<ItemTypeType extends ApiEnumItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
     createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ItemIdConversionMap, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
 import { ItemEntry } from '../../../models';
 import { CollectionOptions } from '../../../models/CollectionOptions';
 import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
@@ -9,6 +9,7 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
     private itemHandler;
     protected transaction: TransactionCache;
     constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap, isCalledAfterSave: boolean): void;
     __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;

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

@@ -17,6 +17,7 @@ export declare class TransactionCollectionHandler {
         };
     };
     constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
     expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
     addResource(resource: CollectionResource): void;
     clearResource(resource: CollectionResource): void;

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

@@ -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,27 +58,26 @@ 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
      *
      * @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): 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>>>;
-    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
      */
-    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
+    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ChangesDeltaResult>;
     fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
     resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
@@ -94,5 +94,4 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private getColumnDifference;
     private expandLocalItemEntry;
     private getLocalValues;
-    private updateLocalItemIdReferences;
 }

package/dist/types/factories/ChangesDeltaFactory.d.ts

@@ -1,13 +1,15 @@
-import { ItemEntryService } from '../classes';
-import { ChangesDelta } from '../classes/ChangesDelta';
-import { InternalChangesDelta } from '../classes/InternalChangesDelta';
-import { ItemCreateService } from '../classes/ItemCreateService';
+import { ApiFormatter, ChangesDelta, ConversionMapService, InternalChangesDelta, ItemCreateService, ItemEntryService } from '../classes';
+import { ParentChangesDelta } from '../classes/ParentChangesDelta';
 import { ErrorHandlerInterface } from '../interfaces';
 export declare class ChangesDeltaFactory {
+    private apiFormatter;
+    private conversionMapService;
     private errorHandler;
-    private itemEntryService;
     private itemCreateService;
-    constructor(errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemCreateService: ItemCreateService);
+    private itemEntryService;
+    constructor(apiFormatter: ApiFormatter, conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
     construct(): ChangesDelta;
+    cloneCreatedChanges(sourceChangesDelta: ChangesDelta, destinationChangesDelta?: ChangesDelta): ChangesDelta;
     constructInternalDelta(): InternalChangesDelta;
+    constructParentDelta(): ParentChangesDelta;
 }

package/dist/types/factories/ChangesProcessorFactory.d.ts

@@ -1,22 +1,19 @@
-import { ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
+import { ApiRequestService, ChangesProcessor, ItemEntryService, OnAfterCreateCallback } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ChangesCompilationFactory } from './ChangesCompilationFactory';
 import { ChangesDeltaFactory } from './ChangesDeltaFactory';
-import { ColumnExpansionFactory } from './ColumnExpansionFactory';
 import { CreateRequestFactory } from './CreateRequestFactory';
 import { RequestColumnExpansionFactory } from './RequestColumnExpansionFactory';
 export declare class ChangesProcessorFactory {
     private changesDeltaFactory;
     private apiRequestService;
     private changesCompilationFactory;
-    private columnExpansionFactory;
     private createRequestFactory;
     private errorHandler;
     private promiseService;
     private requestColumnExpansionFactory;
-    private collectionEntryService;
     private itemEntryService;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService);
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService);
     construct(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): ChangesProcessor;
 }

package/dist/types/factories/RequestColumnExpansionFactory.d.ts

@@ -1,6 +1,9 @@
-import { ColumnUtil, RequestColumnExpansion } from '../classes';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ColumnUtil, RequestColumnExpansion } from '../classes';
+import { ApiRequestColumnMap, ApiRequestColumns } from '../types';
 export declare class RequestColumnExpansionFactory {
     private columnUtil;
     constructor(columnUtil: ColumnUtil);
     construct(): RequestColumnExpansion;
+    expandColumnsWithCachedQueryColumns(transaction: AbstractCache, itemType: ApiEnumItemType, requestColumns?: ApiRequestColumns, requestColumnExpansion?: RequestColumnExpansion): ApiRequestColumnMap;
 }

package/dist/types/factories/TemplateFactory.d.ts

@@ -2,10 +2,10 @@ import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnUtil } from '../classes';
 import { ColumnSetFactory } from '../factories';
 import { Template } from '../models';
-import { ApiRequestColumnMap, ApiResponse, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumnMap, ApiResponse, ItemTypeMap, ResponseColumnItemTypeMap } from '../types';
 export declare class TemplateFactory {
     columnSetFactory: ColumnSetFactory;
     columnUtil: ColumnUtil;
     constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
-    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap): Template<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ItemTypeMap<ResponseColumnItemTypeMap>): Template<ItemTypeType>;
 }

package/dist/types/interfaces/TransactionItemHandlerDependencyInterface.d.ts

@@ -1,4 +1,4 @@
-import { ApiFormatter, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService } from '../classes';
+import { ApiFormatter, CollectionEntryService, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService } from '../classes';
 import { TemplateCache } from '../classes/TemplateCache';
 import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
 import { ErrorHandlerInterface } from './ErrorHandlerInterface';
@@ -23,4 +23,5 @@ export interface TransactionItemHandlerDependencyInterface {
     promiseService: PromiseLibraryInterface;
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     templateCache: TemplateCache;
+    collectionEntryService: CollectionEntryService;
 }

package/dist/types/models/Template.d.ts

@@ -1,12 +1,13 @@
 import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
 import { ColumnSet } from '../classes';
 import { TemplateFactory } from '../factories';
-import { ApiRequestColumnMap, ApiResponse, FieldMap, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumnMap, ApiResponse, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap } from '../types';
 export declare class Template<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any> {
     itemType: ItemTypeType;
     response: ApiResponse;
+    additionalRequestColumns: ApiRequestColumnMap;
     responseColumns: ResponseColumnItemTypeMap;
     columns: ColumnSet<ItemTypeType>;
-    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap);
+    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ItemTypeMap<ResponseColumnItemTypeMap>);
     getFields(): FieldMap<ItemTypeType, ColumnIds>;
 }

package/dist/types/types/ItemTypesCollection.d.ts

@@ -211,7 +211,7 @@ export declare type CollectionQuery = {
     object: BackendApiQuery;
     string: string;
 };
-export declare type CollectionResourceParentIdMap<ItemTypeType extends ApiEnumItemType = any> = ParentIdMap<CollectionResource<ItemTypeType>>;
+export declare type CollectionResourceParentIdMap<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any> = ParentIdMap<CollectionResource<ItemTypeType, ColumnIds>>;
 export declare type ResponseColumnMap<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any> = {
     [ColumnId in ColumnIds[number]]: GetColumnType<ItemTypeType, ColumnId>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "8.0.2",
+  "version": "8.1.0",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/types/index.d.ts",