@rentman/rm-core 2.0.6 → 2.0.8

package/dist/src/classes/ChangesProcessor.d.ts

@@ -1,4 +1,4 @@
-import { ApiFormatter, ApiRequestService, CollectionEntryService, ItemEntryService } from '../classes';
+import { ApiRequestService, CollectionEntryService, ItemEntryService } from '../classes';
 import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
@@ -10,7 +10,6 @@ export declare type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap)
  * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
  */
 export declare class ChangesProcessor {
-    private apiFormatter;
     private changesDeltaFactory;
     private apiRequestService;
     private changesCompilationFactory;
@@ -26,7 +25,7 @@ export declare class ChangesProcessor {
     private onAfterCreateCallback?;
     private itemIdConversionMap;
     private serverCache;
-    constructor(apiFormatter: ApiFormatter, 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, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
     /**
      * @description
      * Executes the requests in the order of:

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

@@ -101,7 +101,7 @@ export declare abstract class AbstractCache {
      * @internal
      */
     abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
-    abstract getParent(itemEntry: ItemEntry, fromInitial?: boolean): EntryParentNull;
+    abstract getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
     /**
@@ -115,6 +115,7 @@ export declare abstract class AbstractCache {
      */
     abstract getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
     abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    protected getParentFromFields<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParentNull;
     /**
      * @description
      * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes

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

@@ -21,6 +21,13 @@ export declare abstract class ItemHandlerBase {
     readonly entries: ItemCache;
     abstract itemChanges: ServerItemEntryChanges | TransactionItemEntryChanges;
     protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
+    /**
+     * @description
+     * Copies the passed ItemEntryChanges into a format the implementing ItemHandler can put in his ItemChanges
+     * @param itemEntryChanges
+     * @param entry
+     */
+    abstract copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): any;
     /**
      * @description
      * Fetches the ItemEntries for the given query, does not look in the cache, since we don't know which ItemIds belong to the query !
@@ -66,11 +73,6 @@ export declare abstract class ItemHandlerBase {
      * Clears the entry from this transaction, removing it from the {@link ItemCache ItemCache} and removing all changes
      */
     clearItemEntry(entry: ItemEntry): void;
-    /**
-     * @description
-     * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}
-     */
-    protected createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
      * Recursively fetches derived values as separate requests, instead of as columns of a primary item
@@ -78,6 +80,11 @@ export declare abstract class ItemHandlerBase {
      */
     fetchDerivedValuesByColumn<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | Array<ItemEntry<ItemTypeType>>>;
     resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, changesDelta?: ChangesDeltaBase): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}
+     */
+    protected createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
      * Gets the value of the given column, will look into the current delta before attempting to read itemChanges

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

@@ -52,7 +52,18 @@ export declare class ServerCache extends AbstractCache {
      * Gets the fields required to set the parent
      */
     getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
-    getParent(itemEntry: ItemEntry): EntryParentNull;
+    /**
+     * @description
+     * Gets the entry's parent
+     *
+     * @param itemEntry The entry to get the parent from
+     * @param _fromInitial Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
+     * @param _providedFields Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
+     *
+     * @remark
+     * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
+     */
+    getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     /**
      * @description

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

@@ -4,7 +4,7 @@ import { ItemEntry, ItemEntryOptions } from '../../../models';
 import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../../types';
 import { ChangesDelta, ChangesDeltaItemCreateDelta } from '../../ChangesDelta';
 import { ChangesDeltaItemUpdateDelta } from '../../ChangesDeltaBase';
-import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse } from '../../index';
+import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse, TransactionItemEntryChanges } from '../../index';
 import { ItemHandlerBase } from '../ItemHandlerBase';
 import { ServerCache } from './ServerCache';
 export declare type ServerItemEntryChanges<ItemTypeType extends ItemType = any> = FieldMap<ItemTypeType>;
@@ -24,15 +24,10 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      * Processes updates on a cached entry
      */
     processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
+    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): ServerItemEntryChanges;
     fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.
-     * Will create a new {@link ItemEntry ItemEntry} if the ItemEntry didn't exist yet
-     */
-    private fetchItemEntryData;
     /**
      * @description
      * Fetches the data for the ItemEntries linked to the parent Items
@@ -46,4 +41,10 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      * 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 ItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemId: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>): void;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.
+     * Will create a new {@link ItemEntry ItemEntry} if the ItemEntry didn't exist yet
+     */
+    private fetchItemEntryData;
 }

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

@@ -383,7 +383,6 @@ export declare class TransactionCache extends AbstractCache {
         remote: true;
     }): ItemResourcesItemTypeMap<RemoteViewResource<ItemTypeType>>;
     processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface): ItemResourcesItemTypeMap<LocalViewResource<ItemTypeType>>;
-    private createCollectionResources;
     createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;
@@ -407,11 +406,12 @@ export declare class TransactionCache extends AbstractCache {
      * Returns this transaction and all parents
      */
     getTransactionChain(): AbstractCache[];
+    getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+    private createCollectionResources;
     /**
      * @description
      * Fetches all required columns to match/fit in collections
      */
     private expandItemsFromDelta;
-    getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
 }
 export {};

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

@@ -36,6 +36,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
         [itemEntryId: number]: ItemResource[];
     };
     constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, transaction: TransactionCache);
+    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
@@ -81,7 +82,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @returns
      * The previous changes {@link FieldMap FieldMap}
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType> | null;
     cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): PromiseInterface<ChangesDeltaResult>;
     cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): ItemId;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
@@ -94,8 +95,6 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
     resolveLocalItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    private getColumnDifference;
-    private resolveLocal;
     createLocalEntries(changesDelta: ChangesDelta, parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntry?: <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>) => boolean, // return true to include item
     modifyFieldsCallback?: <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>, itemIdConversionMap: ItemIdConversionMap) => void): void;
     expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
@@ -109,6 +108,8 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      */
     fetchLocalItemEntryData<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
     fetchLocalItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    private getColumnDifference;
+    private resolveLocal;
     private expandLocalItemEntry;
     private getLocalValues;
 }

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

@@ -1,4 +1,4 @@
-import { ApiFormatter, ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
+import { ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ChangesCompilationFactory } from './ChangesCompilationFactory';
@@ -7,7 +7,6 @@ import { ColumnExpansionFactory } from './ColumnExpansionFactory';
 import { CreateRequestFactory } from './CreateRequestFactory';
 import { RequestColumnExpansionFactory } from './RequestColumnExpansionFactory';
 export declare class ChangesProcessorFactory {
-    private apiFormatter;
     private changesDeltaFactory;
     private apiRequestService;
     private changesCompilationFactory;
@@ -18,6 +17,6 @@ export declare class ChangesProcessorFactory {
     private requestColumnExpansionFactory;
     private collectionEntryService;
     private itemEntryService;
-    constructor(apiFormatter: ApiFormatter, 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, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService);
     construct(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): ChangesProcessor;
 }

package/package.json

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