@rentman/rm-core 2.0.3 → 2.0.5

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

@@ -33,6 +33,10 @@ export declare class ApiFormatter {
     copyFields<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
     shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
     setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    /**
+     * @description
+     * Compares the given fields, returns `true` when the fields are equal
+     */
     compareFields(columnType: string, first?: any, second?: any): boolean;
     compareFloats(a: number, b: number): boolean;
     compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;

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

@@ -1,4 +1,4 @@
-import { ApiFormatter } from '../classes';
+import { ApiFormatter, ApiRequestService } from '../classes';
 import { RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
@@ -15,7 +15,8 @@ export declare class SocketMessageHandler {
     private transactionCacheFactory;
     private promiseService;
     private requestColumnExpansionFactory;
-    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    private apiRequestService;
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
     onMessageReceived(message: SocketMessage): any;
     private formatMessageValues;
     private createCollectionMap;

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

@@ -100,7 +100,7 @@ export declare abstract class AbstractCache {
      *
      * @internal
      */
-    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean): void;
+    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
     abstract getParent(itemEntry: ItemEntry, fromInitial?: boolean): EntryParentNull;
     abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;

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

@@ -51,10 +51,10 @@ export declare abstract class CollectionHandlerBase {
      * Adds the passed {@link ItemEntry ItemEntries} to the collection's changes on the transaction,
      * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
      */
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
-    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[]): void | never[];
-    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    protected _addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean, isCalledAfterSocketUpdate: boolean): void;
+    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
+    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[], isCalledAfterSocketUpdate?: boolean): void | never[];
+    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
     /**
      * @description
      * Expands the option's {@link CollectionEntryOptions.columns columns} with the columns required for the {@link CollectionMatcher CollectionMatcher} to function.

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

@@ -21,6 +21,6 @@ export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType
 export declare class CollectionMatcherCacheProcessor extends CollectionMatcher {
     private apiRequestService;
     constructor(apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
-    removeFromAndAddToCollections(): void;
+    removeFromAndAddToCollections(isCalledAfterSocketUpdate?: boolean): void;
     private groupItemEntries;
 }

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

@@ -41,12 +41,12 @@ export declare class ServerCache extends AbstractCache {
     parent: null;
     constructor(changesProcessorFactory: ChangesProcessorFactory, core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiFormatter: ApiFormatter, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, linkTreeService: LinkTreeServiceInterface);
     getServerCache(): ServerCache;
-    processResponse(response: ApiResponseProcessor): PromiseInterface<ChangesDeltaResult>;
+    processResponse(response: ApiResponseProcessor, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): 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
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean): void;
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): void;
     /**
      * @description
      * Gets the fields required to set the parent
@@ -79,7 +79,7 @@ export declare class ServerCache extends AbstractCache {
      * 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
      */
-    applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
     getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;

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

@@ -26,7 +26,7 @@ export declare class ServerCollectionHandler extends CollectionHandlerBase {
     extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
     expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
     protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
     protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
     /**

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

@@ -23,7 +23,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      * @description
      * Processes updates on a cached entry
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
     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>>>;

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

@@ -92,7 +92,7 @@ export declare class TransactionCache extends AbstractCache {
      * @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): void;
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): void;
     /**
      * @description
      * Applies changes to this transaction and its children
@@ -114,8 +114,12 @@ export declare class TransactionCache extends AbstractCache {
      *
      * @param itemEntry The entry to get the parent from
      * @param fromInitial If `true` the parent values will be read from {@link TransactionItemEntryChanges.initial initial} (Useful for when you've moved an entry)
+     * @param providedFields Use the provided fields instead of the cached fields, used by {@link CollectionResource.getParent CollectionResource.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(itemEntry: ItemEntry, fromInitial?: boolean): EntryParentNull;
+    getParent<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     /**
      * @description
      * Traverses the transaction chain and returns the changes of the item on the first transaction
@@ -358,13 +362,13 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<EditResource<ItemTypeType>> & {
         edit: true;
     }, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<RemoteViewResource<ItemTypeType>> & {
         remote: true;
     }, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<LocalViewResource<ItemTypeType>>, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
     createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
         edit: true;
     }): Array<EditResource<ItemTypeType>>;

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

@@ -49,7 +49,7 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
     fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
     expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
     isLocal(options: CollectionEntryOptions): boolean;
     expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
     /**

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

@@ -76,11 +76,12 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @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
      *
      * @returns
      * The previous changes {@link FieldMap FieldMap}
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
     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>>>;

package/dist/src/models/CollectionResource.d.ts

@@ -15,7 +15,7 @@ export declare abstract class CollectionResource<ItemTypeType extends ItemType =
     onConstruct(): void;
     getIdArray(): ItemId[];
     getItemById(itemId: number): T;
-    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, _isInitialCall?: boolean): T[];
+    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean): T[];
     /**
      * @description
      * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.

package/dist/src/models/CollectionResourceOptions.d.ts

@@ -10,6 +10,7 @@ export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
     remoteItems: boolean;
     editCollection: boolean;
     enableSave: boolean;
+    callOnAddWithInitialItems: boolean;
     /**
      * @deprecated
      * You should use itemResource.onChange and compare previous.id with fields.id

package/dist/src/models/ItemResource.d.ts

@@ -1,7 +1,7 @@
 import { TransactionCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions } from '../models';
-import { FieldMap, ItemType, ResponseColumn } from '../types';
+import { EntryParentNull, FieldMap, ItemType, ResponseColumn } from '../types';
 export declare abstract class ItemResource<ItemTypeType extends ItemType = any> {
     protected readonly factory: ItemResourceFactory;
     readonly entry: ItemEntry<ItemTypeType>;
@@ -15,6 +15,15 @@ export declare abstract class ItemResource<ItemTypeType extends ItemType = any>
     initial: Readonly<FieldMap<ItemTypeType>>;
     protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, transaction: TransactionCache);
     onConstruct(): void;
+    /**
+     * Fetches the ItemResource's parent with the current fields
+     *
+     * ----------------
+     *
+     * @remark
+     * Use this if you need to get the parent after an item has been deleted
+     */
+    getParent(fromInitial?: boolean): EntryParentNull;
     /**
      * @deprecated
      * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead

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

@@ -12,7 +12,7 @@ export declare type EntryParentNull = EntryParent | null;
 export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
     [key: string]: any;
 };
-export declare type ItemOptionsInterface = ItemEntryOptionsInterface & ItemResourceOptionsInterface;
+export declare type ItemOptionsInterface<ItemResourceType extends ItemResource<any> = ItemResource> = ItemEntryOptionsInterface & ItemResourceOptionsInterface<ItemResourceType>;
 export declare type CollectionOptionsInterface<ItemTypeType extends ItemType = any> = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface<ItemTypeType>;
 export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
@@ -27,9 +27,9 @@ export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> e
 export declare type OnChangeFunction<ItemResourceType extends ItemResource<any> = ItemResource<any>> = (itemResource: ItemResourceType, previous: FieldMap<ItemResourceType['entry']['itemType']>, 
 /**
  * @description
- * Returns 'true' if the field changed
+ * Returns 'false' if the field changed
  */
-compareField: (field: keyof FieldMap<ItemResourceType['entry']['itemType']>) => boolean) => void;
+compareField: (field: keyof FieldMap<ItemResourceType['entry']['itemType']>) => boolean, isCalledAfterSocketUpdate: boolean) => void;
 export declare const enum StateKeyType {
     New = "new",
     Duplicate = "duplicate"

package/package.json

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