@rentman/rm-core 2.0.14 → 2.0.16

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

@@ -1,5 +1,5 @@
 import { ItemEntry } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemType } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
 import { ItemEntryService } from './ItemEntryService';
 export declare type ChangesDeltaResult = {
     rollback: () => void;
@@ -26,7 +26,23 @@ export declare abstract class ChangesDeltaBase {
     deleted: {
         [itemType: string]: ChangesDeltaItemDeleteDelta;
     };
+    /**
+     * @private
+     */
+    _queryResults: {
+        [itemType: string]: {
+            [queryString: string]: ItemId[];
+        };
+    };
     protected constructor(itemEntryService: ItemEntryService);
+    /**
+     * @description
+     * Adds a hint for the {@link CollectionMatcherBase CollectionMatcherBase] to the ChangesDelta, when the CollectionMatcher encounters a collection
+     * with the exact query, it will use the hint instead of running the matcher
+     *
+     * @private
+     */
+    _setQueryResult(itemType: ItemType, queryString: string, itemIds: ItemId[]): void;
     setItemUpdated<ItemEntryType extends ItemEntry>(entry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>, columnExpansionResult?: ColumnExpansionResult<ItemEntryType['itemType']> | null, parent?: EntryParentNull): void;
     setItemDeleted(deleted: ItemEntry): void;
     setItemsDeleted(deleted: ItemEntry[]): void;

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

@@ -29,6 +29,7 @@ export declare class CollectionCache {
      */
     getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
     getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
+    getByQueryString<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string): CollectionEntry<ItemTypeType> | null;
     getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
     /**
      * @deprecated

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

@@ -1,4 +1,4 @@
-import { RequestColumnExpansionFactory } from '../factories';
+import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
 import { PromiseLibraryInterface } from '../interfaces';
 import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
@@ -9,17 +9,20 @@ export declare class RequestBuffer {
     private promiseLibrary;
     private apiRequestService;
     private requestColumnExpansionFactory;
+    private changesDeltaFactory;
     private serverCache;
     private itemType;
     private deferred;
     private requestColumnExpansion;
     private singleItemIds;
     private queries;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, serverCache: ServerCache, itemType: ItemType);
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemType);
     containsId(itemId: ItemId): boolean;
     containsQuery(queryString: string): boolean;
     addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     flush(): PromiseInterface<RequestBufferResponse>;
     getPromise(): PromiseInterface<RequestBufferResponse>;
+    private hasMultipleQueries;
+    private getFirstQueryString;
 }

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

@@ -1,4 +1,4 @@
-import { RequestColumnExpansionFactory } from '../factories';
+import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
@@ -12,12 +12,13 @@ export declare class RequestBufferManager {
     private requestColumnExpansionFactory;
     private keyService;
     private errorHandler;
+    private changesDeltaFactory;
     private pendingBufferMap;
     private pendingTrueBufferMap;
     private pendingQueryBufferMap;
     private pendingTemplateBufferMap;
     private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, errorHandler: ErrorHandlerInterface);
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, errorHandler: ErrorHandlerInterface, changesDeltaFactory: ChangesDeltaFactory);
     setServerCache(serverCache: ServerCache): void;
     containsId(itemType: ItemType, itemId: ItemId): boolean;
     containsQuery(itemType: ItemType, queryString: string): boolean;

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

@@ -70,6 +70,12 @@ export declare abstract class AbstractCache {
     protected constructor(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, 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, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface);
     createChild(id?: string): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
+    abstract getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
+    /**
+     * @description
+     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
+     */
+    abstract getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
     /**
      * @description
      * Returns this transaction and all parents

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

@@ -13,9 +13,13 @@ export declare abstract class CollectionHandlerBase {
     protected transaction: AbstractCache;
     entries: CollectionCache;
     collectionChanges: {
-        [collectionEntryId: number]: ItemEntry[];
+        [itemType: string]: {
+            [queryString: string]: ItemEntry[];
+        };
     };
     protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionCacheFactory: CollectionCacheFactory, transaction: AbstractCache);
+    setCollectionChanges<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    getCollectionChanges<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string): undefined | Array<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Creates a new {@link CollectionEntry CollectionEntry} and stores it in this transaction's {@link CollectionCache CollectionCache}

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

@@ -41,7 +41,7 @@ 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, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
+    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta): 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
@@ -93,6 +93,7 @@ export declare class ServerCache extends AbstractCache {
     applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
     getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
 }

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, _isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: 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>>>;

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

@@ -120,6 +120,7 @@ export declare class TransactionCache extends AbstractCache {
      * 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>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
     /**
      * @description
      * Traverses the transaction chain and returns the changes of the item on the first transaction
@@ -351,6 +352,11 @@ export declare class TransactionCache extends AbstractCache {
      * Gets an ItemEntry from the cache by ItemId
      */
     getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    /**
+     * @description
+     * Gets an CollectionEntry from the cache, doesn't do a API request, used for saving
+     */
+    getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
     /**
      * @description
      * Gets an CollectionEntry from the cache, doesn't do a API request, used for saving

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

@@ -78,11 +78,12 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @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
      *
      * @returns
      * The previous changes {@link FieldMap FieldMap}
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType> | null;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
     cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): PromiseInterface<ChangesDeltaResult>;
     cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;

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

@@ -7,7 +7,7 @@ export declare abstract class CollectionResource<ItemTypeType extends ItemType =
     entry: CollectionEntry<ItemTypeType>;
     options: CollectionResourceOptions<ItemTypeType>;
     transaction: TransactionCache;
-    items: T[];
+    items: Readonly<T[]>;
     columns: ResponseColumnItemTypeMap;
     protected itemIdMap: ItemResourceItemIdMap<T>;
     private readonly onChange;

package/package.json

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