@rentman/rm-core 66.2.0 → 66.4.0

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

@@ -7,6 +7,7 @@ export type TransactionOptions = {
      * Sets the TransactionCache to 'transparent' mode, whenever {@link AbstractCache.createChild createChild} is called it will actually be called on the parent
      */
     transparent: boolean;
+    autoSave: boolean;
 };
 export declare abstract class AbstractCache {
     dependencies: AbstractCacheDependencyInterface;
@@ -18,7 +19,7 @@ export declare abstract class AbstractCache {
     protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
     getChildren(): TransactionCache[];
     getDescendantsIterator(): IterableIterator<TransactionCache>;
-    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>): TransactionCache;
     onChildDestroy(transactionCache: TransactionCache): void;
     /**
      * @description

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

@@ -20,7 +20,7 @@ export declare class ServerCache extends AbstractCache {
     constructor(dependencies: ServerCacheDependencyInterface, apiFieldsOnDeleteRule: typeof ApiFieldsOnDeleteRule, core: RmCore);
     onDeltaApplied(callback: OnDeltaAppliedCallback): DeregFunction;
     getServerCache(): ServerCache;
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>): TransactionCache;
     getActiveItemEntries(): ActiveItemEntries;
     processResponseByItemType<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType> | null, responseColumns: ResponseColumnItemTypeMap, responseItems: Iterable<FieldMap<ItemTypeType>>, changesDelta: ChangesDelta, itemUpdateModeMap?: {
         [itemId: string]: ChangesDeltaItemUpdateMode;

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

@@ -1,5 +1,6 @@
 import { WritableSignal } from '@angular/core';
 import { ApiItemType, ItemId } from '@rentman/backend-types';
+import moment from 'moment';
 import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumnArray, ApiRequestColumns, CachedQueryItem, ChangesDelta, ChangesDeltaResult, ChildChangesDelta, ChildCollectionResources, CollectionQuery, CollectionResource, ConversionMap, CreateRequestParameterMap, DeregFunction, FieldMap, ItemAggregatedChangesListener, ItemChangesListener, ItemEntry, ItemIdConversionMap, ItemOptions, ItemResource, ItemResourcesItemTypeMap, ItemsByQueryOptions, ItemTypeMap, LimitedCollectionResource, ModuleChangesCompilationResult, NewItemOptions, OnAfterCreateCallback, ParentChangesDelta, ParentIdMap, RmCore, RootCollectionOptions, ServerCache, TimeoutPromiseHandler, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionEventHandler, TransactionItemHandler, TransactionOptions, TransactionValidator, TransactionValidatorFactory } from '../../../internal';
 import { TransactionValidatorWithDependencies } from './TransactionValidatorWithDependencies';
 type ItemResourceLinks<ItemTypeType extends ApiItemType, ColumnIds extends ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionResources | undefined> = {
@@ -84,6 +85,13 @@ export declare class TransactionCache extends AbstractCache {
      */
     tabRequestParameters: {};
     hasChangesSignal: WritableSignal<boolean>;
+    aiChanges: WritableSignal<{
+        created: Set<ItemEntry['id']>;
+        deleted: Set<ItemEntry['id']>;
+        fields: Partial<{
+            [itemEntryId: number]: Set<string>;
+        }>;
+    }>;
     /**
      * @description
      * The transaction's parent
@@ -94,10 +102,13 @@ export declare class TransactionCache extends AbstractCache {
     readonly eventHandler: TransactionEventHandler;
     readonly validator?: TransactionValidator;
     validatorWithDependencies?: TransactionValidatorWithDependencies<any>;
-    private readonly options;
+    readonly options: TransactionOptions;
+    lastSaveSignal: WritableSignal<moment.Moment | null>;
+    private autoSaveEffect?;
+    private autoSaveInFlightSignal;
     private actionsQueue;
     private pendingActionLabels;
-    private transactionStateSignal;
+    readonly transactionStateSignal: WritableSignal<TransactionState>;
     isPendingSignal: any;
     isDestroyedSignal: WritableSignal<boolean>;
     isValidSignal: import("@angular/core").Signal<boolean>;
@@ -159,8 +170,8 @@ export declare class TransactionCache extends AbstractCache {
      * Note that the transaction can *not* be mutated while it is pending. If you need to apply changes on the
      * transaction while it is pending, use the `applyChangesDelta` parameter passed to the promise function.
      */
-    setPending<Result>(promise: Promise<Result> | ((applyChangesDelta: (changesDelta: ChangesDelta) => Promise<ChangesDeltaResult>) => Promise<Result>)): Promise<Result>;
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    setPending<Result>(promise: Promise<Result> | ((applyChangesDelta: (changesDelta: ChangesDelta) => Promise<ChangesDeltaResult>) => Promise<Result>), isDoneByAi: boolean): Promise<Result>;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>): TransactionCache;
     createBusinessLogicChild(): TransactionCache;
     destroy(): void;
     /**
@@ -216,7 +227,7 @@ export declare class TransactionCache extends AbstractCache {
      *
      * This method waits for other transaction processes to complete, see {@link enqueueAction}.
      */
-    applyChangesDelta(changesDelta: ChangesDelta): Promise<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta, isDoneByAi?: boolean): Promise<ChangesDeltaResult>;
     /**
      * See {@link applyChangesDelta}. We're introducing a separate method here to facilitate handling the resulting
      * promise.

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

@@ -45,7 +45,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * The fields will come from the parent transaction, if avaiable.
      */
     constructInitialProxy<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): FieldMap<ItemTypeType>;
-    getItemEntriesWithChangesIterator(): Generator<ItemEntry<any>>;
+    getItemEntriesWithChangesIterator(itemType?: ApiItemType): Generator<ItemEntry<any>>;
     /**
      * Processes the changes on the transaction, and stores the changes as well as the previous values in
      * `parentChangesDelta`. Also handles changes listeners and validators.
@@ -56,7 +56,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      */
     processUpdatesFromDelta(updated: {
         [itemEntryId: number]: ChangesDeltaBaseItemUpdateDelta<any>;
-    }, createItemChangesIfNoneExist: boolean, parentChangesDelta: ParentChangesDelta): void;
+    }, createItemChangesIfNoneExist: boolean, parentChangesDelta: ParentChangesDelta): Map<ItemEntry['id'], Set<string>>;
     updateLocalItemIdReferences(itemType: ApiItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta: ChangesDeltaBase): void;
     registerFieldChangeCallback<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, callback: ItemChangesListener<ItemTypeType>): DeregFunction;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;

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

@@ -1,3 +1,4 @@
+import { Injector } from '@angular/core';
 import { ApiFieldsOnDeleteRule, ItemId } from '@rentman/backend-types';
 import { ApiRequestService } from './classes/ApiRequestService';
 import { BusinessLogicManager } from './classes/BusinessLogicManager/BusinessLogicManager';
@@ -56,6 +57,6 @@ export declare class RmCore {
      * We specify an `apiFieldsOnDeleteRule` parameter in order to easily mock it in unit tests. This prevents
      * issues where a mocked API response does not contain required fields that are added at a later point in time.
      */
-    apiFieldsOnDeleteRule?: typeof ApiFieldsOnDeleteRule);
+    apiFieldsOnDeleteRule: typeof ApiFieldsOnDeleteRule | undefined, rootInjector: Injector);
 }
 export declare function identity<T extends any>(value: T): T;

package/dist/types/src/factories/TransactionCacheFactory.d.ts

@@ -7,6 +7,6 @@ export declare class TransactionCacheFactory {
      * Todo[cache] Store a map of all transactions by transaction id ?
      */
     getById(id: string): TransactionCache | undefined;
-    construct(id?: string, validatorFactory?: TransactionValidatorFactory, transactionOptions?: TransactionOptions): TransactionCache;
+    construct(id?: string, validatorFactory?: TransactionValidatorFactory, transactionOptions?: Partial<TransactionOptions>): TransactionCache;
     getServerCache(): ServerCache;
 }

package/dist/types/src/interfaces/AbstractCacheDependencyInterface.d.ts

@@ -1,3 +1,4 @@
+import { Injector } from '@angular/core';
 import { ApiRequestService } from '../classes/ApiRequestService';
 import { BusinessLogicManager } from '../classes/BusinessLogicManager/BusinessLogicManager';
 import { ColumnCache } from '../classes/ColumnCache';
@@ -43,4 +44,5 @@ export interface AbstractCacheDependencyInterface {
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
     templateCache: TemplateCache;
+    rootInjector: Injector;
 }

package/package.json

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