@rentman/rm-core 63.4.1-blr-01 → 63.4.1

package/dist/types/src/classes/BusinessLogicManager/Subproject/SubprojectOneSubNameAlignBusinessRule.d.ts

@@ -4,12 +4,10 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const projectColumns: readonly ["id", "naam"];
-declare const subprojectColumns: readonly ["id", "project", "naam"];
 type ConditionResult = ItemId[];
 type Dependency = {
-    projectResource: ItemResource<'Project', typeof projectColumns>;
-    subprojectResources: ItemResource<'Subproject', typeof subprojectColumns>[];
+    projectResource: ItemResource<'Project', ['id', 'naam']>;
+    subprojectResources: ItemResource<'Subproject', ['id', 'project', 'naam']>[];
 }[];
 /**
  * @description

package/dist/types/src/classes/BusinessLogicManager/Taak/TaakDeadlineOffsetBusinessLogicRule.d.ts

@@ -7,7 +7,7 @@ import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleCondition
 declare const taakColumns: readonly [{
     readonly deadline_relative_time_period: readonly ["tot", "van"];
 }, "deadline_type", "deadline_relative_offset_amount", "deadline_relative_offset_base", "deadline_relative_offset_direction", "deadline_relative_offset_unit"];
-declare const tijdColumns: readonly ["id", "tot", "van"];
+declare const tijdColumns: readonly ["tot", "van"];
 type ConditionResult = ItemId[];
 type Dependency = {
     taakResources: ItemResource<'Taak', typeof taakColumns>[];
@@ -21,7 +21,7 @@ type Dependency = {
 export declare class TaakDeadlineOffsetBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, taakIds: ConditionResult): Promise<Dependency>;
-    apply(context: BusinessLogicRuleApplyContext, { taakResources, tijdResources, }: Dependency): void;
+    apply(context: BusinessLogicRuleApplyContext, { taakResources, }: Dependency): void;
     calculateTaskTimeWithOffset(context: BusinessLogicRuleApplyContext, selectedDateWithoutOffset: moment.Moment, taskResource: ItemResource<'Taak', any>): moment.Moment;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/Tijd/TijdPropagateNameToFunctiegroepBusinessLogicRule.d.ts

@@ -4,12 +4,10 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const tijdColumns: readonly ["naam", "id"];
-declare const functiegroepColumns: readonly ["schema_pv", "schema_gv", "schema_pt", "schema_gt", "naam"];
 type ConditionResult = ItemId[];
 type Dependency = {
-    tijdResource: ItemResource<'Tijd', typeof tijdColumns>;
-    functiegroepResource: ItemResource<'Functiegroep', typeof functiegroepColumns>;
+    tijdResource: ItemResource<'Tijd', ['naam', 'id']>;
+    functiegroepResource: ItemResource<'Functiegroep', ['naam']>;
 }[];
 /**
  * @description

package/dist/types/src/classes/BusinessLogicManager/Tijd/TijdSubprojectChangedBusinessLogicRule.d.ts

@@ -1,10 +1,6 @@
-import { ItemId } from '@rentman/backend-types';
-import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, CollectionResource, ItemEntry, ItemResource, TransactionCache } from '../../../internal';
+import { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, CollectionResource, ItemResource, TransactionCache } from '../../../internal';
 declare const projectDefaultTimeColumns: readonly ["id", "gebruiksperiode", "planperiode"];
-type ConditionResult = {
-    itemEntry: ItemEntry<'Tijd'>;
-    newValue: ItemId<'Subproject'>;
-}[];
+type ConditionResult = BusinessLogicConditionResult<'Tijd', 'subproject'>[];
 type Dependency = ItemResource<'Project', typeof projectDefaultTimeColumns, {
     Subproject: CollectionResource<'Subproject', typeof projectDefaultTimeColumns>;
 }>;

package/dist/types/src/classes/BusinessLogicManager/Uren/HoursTypeBusinessLogicRuleBase.d.ts

@@ -1,9 +1,10 @@
 import { ItemId } from '@rentman/backend-types';
+import { ItemTypeColumnId } from '../../../types/ItemTypesCollection';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 type ConditionResult = ItemId<'Uren'>[];
 export declare abstract class HoursTypeBusinessLogicRuleBase<DependencyType> extends BusinessLogicRule<ConditionResult, DependencyType> {
-    protected abstract conditionColumnId: 'has_calculated_duration' | 'can_have_activities';
+    protected abstract conditionColumnId: ItemTypeColumnId<'HoursType'>;
     condition(context: BusinessLogicRuleConditionContext): Promise<ConditionResult | typeof BLR_SKIP_RULE>;
 }
 export {};

package/dist/types/src/classes/ChangesDelta.d.ts

@@ -22,10 +22,13 @@ export interface ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> e
  *
  * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
  */
-export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta<any>, ChangesDeltaItemDeleteDelta<any>> {
+export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemDeleteDelta<any>> {
     logMissingColumnErrors: boolean;
     private errorHandler;
     private itemCreateService;
+    updated: {
+        [itemEntryId: number]: ChangesDeltaItemUpdateDelta<any>;
+    };
     created: CreatedChangesDelta;
     /**
      * Only contains remote items, when rolling back local items the whole entries are deleted.
@@ -34,11 +37,9 @@ export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemCreat
         [itemEntryId: number]: ItemEntryChangesTuple<any>;
     };
     constructor(logMissingColumnErrors: boolean, queryItemTypes: Iterable<ApiItemType> | undefined, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
-    /**
-     * We declare this method to provide the `ItemType` type variable to the result.
-     */
-    getUpdatedTuplesIterator: <ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes) => IterableIterator<ChangesDeltaItemUpdateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
-    getCreatedTuplesIterator<ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes): IterableIterator<ChangesDeltaItemCreateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
+    getCreatedTuplesIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): IterableIterator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
+    getUpdatedTuplesIterator<ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes): Generator<ChangesDeltaItemUpdateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
+    merge(otherChangesDelta: ChangesDelta): ChangesDelta;
     /**
      * @description
      * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
@@ -48,6 +49,7 @@ export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemCreat
      * - If you want to set a parent set the proper field, you can't pass it as a separate object
      */
     setItemCreated<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, values: Partial<FieldMap<ItemTypeType>>, templateOptions?: Partial<RequestParameters<ItemTypeType>>): Promise<this>;
+    setItemCreatedByTuple<ItemTypeType extends ApiItemType>(itemCreateTuple: ChangesDeltaItemCreateDelta<ItemTypeType>, updatedFields: Partial<FieldMap<ItemTypeType>>): ChangesDelta;
     setItemUpdated<ItemTypeType extends ApiItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansion?: ColumnExpansion<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode): this;
     setItemDeleted(entry: ItemEntry, __isCascaded?: boolean): this;
     setItemsDeleted(deleted: ItemEntry[]): this;
@@ -73,7 +75,7 @@ export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemCreat
      * @internal
      */
     _setItemCreated<ItemTypeType extends ApiItemType>(itemId: ItemId, fields: Partial<FieldMap<ItemTypeType>>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isApiResponse?: boolean): this;
-    setItemRestored<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): this;
+    setItemRestored<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): void;
     isEmpty(): boolean;
     toJSON(): any;
 }

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

@@ -1,5 +1,15 @@
 import { ApiItemType, ItemId } from '@rentman/backend-types';
-import { FieldMap, GetFieldValueType, ItemEntry, ItemEntryService, ItemTypeColumnId } from '../internal';
+import { ChangesDelta, ChildChangesDelta, FieldMap, GetFieldValueType, ItemEntry, ItemEntryService, ItemTypeColumnId } from '../internal';
+export type ChangesDeltaResult = {
+    /**
+     * The changes delta included in the changes delta result is not necessarily the same as the one being passed to
+     * the `applyChangesDelta()` method, as business logic rules might have been applied.
+     * TODO: Separate results for changes delta and child changes delta.
+     */
+    changesDelta: ChangesDelta | ChildChangesDelta;
+    created: ItemEntry[];
+    allChildrenDonePromise: Promise<void>;
+};
 export type ChangesDeltaItemUpdateMode = 
 /**
  * For create/update responses you always want to overwrite whatever is cached
@@ -31,10 +41,10 @@ export interface ChangesDeltaBaseItemUpdateDelta<ItemTypeType extends ApiItemTyp
 export interface ChangesDeltaBaseItemDeleteDelta<ItemTypeType extends ApiItemType> {
     entry: ItemEntry<ItemTypeType>;
 }
-export declare abstract class ChangesDeltaBase<ItemCreateDeltaType = unknown, ItemUpdateDeltaType extends ChangesDeltaBaseItemUpdateDelta<any> = ChangesDeltaBaseItemUpdateDelta<any>, ItemDeleteDeltaType extends ChangesDeltaBaseItemDeleteDelta<any> = ChangesDeltaBaseItemDeleteDelta<any>> {
+export declare abstract class ChangesDeltaBase<ItemDeleteDeltaType extends ChangesDeltaBaseItemDeleteDelta<any> = ChangesDeltaBaseItemDeleteDelta<any>> {
     protected itemEntryService: ItemEntryService;
     updated: {
-        [itemEntryId: number]: ItemUpdateDeltaType;
+        [itemEntryId: number]: ChangesDeltaBaseItemUpdateDelta<any>;
     };
     protected deleted: {
         [ItemType in ApiItemType]?: Map<ItemEntry<ItemType>, ItemDeleteDeltaType>;
@@ -52,15 +62,8 @@ export declare abstract class ChangesDeltaBase<ItemCreateDeltaType = unknown, It
      * When set, only collections of this item type will be matched.
      */
     _queryItemTypeSet?: Set<ApiItemType>;
-    constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
+    protected constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
     addQueryItemType(itemType: ApiItemType): void;
-    abstract getCreatedTuplesIterator(...itemTypes: ApiItemType[]): IterableIterator<ItemCreateDeltaType>;
-    getUpdatedTuplesIterator(...itemTypes: ApiItemType[]): IterableIterator<ItemUpdateDeltaType>;
-    protected getItemEntryIdMapIterator<ValueType extends {
-        entry: ItemEntry<any>;
-    }>(itemTypes: ApiItemType[], itemEntryIdMap: {
-        [itemEntryId: number]: ValueType;
-    }): Generator<ValueType>;
     getUpdatedValue<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemEntry: ItemEntry<ItemTypeType>, columnId: ColumnId): GetFieldValueType<ItemTypeType, ColumnId> | undefined;
     hasDeletedItem<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): boolean;
     hasUpdatedValue<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, columnId: ItemTypeColumnId<ItemTypeType>): boolean;

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

@@ -1,4 +1,4 @@
-import { ApiRequestService, ChangesCompilation, ChangesDeltaFactory, ErrorHandlerInterface, ItemIdConversionMap, RequestBufferManager, RequestColumnExpansionFactory, TransactionCache } from '../internal';
+import { ApiRequestService, ChangesCompilationFactory, ChangesDeltaFactory, ErrorHandlerInterface, ItemIdConversionMap, RequestBufferManager, RequestColumnExpansionFactory, TransactionCache } from '../internal';
 export type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
 /**
  * @description
@@ -6,17 +6,17 @@ export type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void
  */
 export declare class ChangesProcessor {
     private apiRequestService;
+    private changesCompilationFactory;
     private changesDeltaFactory;
     private errorHandler;
     private requestBufferManager;
     private requestColumnExpansionFactory;
     private transaction;
-    private changesCompilation;
     private breakUpByParent?;
     private onAfterCreateCallback?;
     private itemIdConversionMap;
     private serverCache;
-    constructor(apiRequestService: ApiRequestService, changesDeltaFactory: ChangesDeltaFactory, errorHandler: ErrorHandlerInterface, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, changesCompilation: ChangesCompilation, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    constructor(apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, changesDeltaFactory: ChangesDeltaFactory, errorHandler: ErrorHandlerInterface, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
     /**
      * @description
      * Executes the requests in the order of:

package/dist/types/src/classes/ChildChangesDelta.d.ts

@@ -1,18 +1,9 @@
-import { ApiItemType, ItemId } from '@rentman/backend-types';
-import { ChangesDeltaBase, ChangesDeltaBaseItemDeleteDelta, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, FieldMap, GetFieldValueType, ItemEntry, ItemTypeColumnId } from '../internal';
+import { ApiItemType } from '@rentman/backend-types';
+import { ChangesDeltaBase, ChangesDeltaBaseItemDeleteDelta, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, FieldMap, ItemEntry, ItemEntryService } from '../internal';
 export type ChildChangesDeltaItemCreateDelta<ItemTypeType extends ApiItemType = any> = {
     entry: ItemEntry<ItemTypeType>;
     fields: FieldMap<ItemTypeType>;
 };
-export type ChangesDeltaResult = {
-    /**
-     * The changes delta included in the changes delta result is not necessarily the same as the one being passed to
-     * the `applyChangesDelta()` method, as business logic rules might have been applied.
-     */
-    changesDelta: ChildChangesDelta;
-    created: ItemEntry[];
-    allChildrenDonePromise: Promise<void>;
-};
 export interface ChildChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemUpdateDelta<ItemTypeType> {
     entry: ItemEntry<ItemTypeType>;
     changes: {
@@ -31,16 +22,14 @@ export interface ChildChangesDeltaItemDeleteDelta<ItemTypeType extends ApiItemTy
  *
  * Use this when calling {@link TransactionCache.applyChangesFromChild}.
  */
-export declare class ChildChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemCreateDelta<any>, ChildChangesDeltaItemUpdateDelta<any>, ChildChangesDeltaItemDeleteDelta<any>> {
+export declare class ChildChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemDeleteDelta<any>> {
+    updated: {
+        [itemEntryId: number]: ChildChangesDeltaItemUpdateDelta<any>;
+    };
     created: {
         [itemEntryId: string]: ChildChangesDeltaItemCreateDelta;
     };
-    /**
-     * We declare this method to provide the `ItemType` type variable to the result.
-     */
-    getUpdatedTuplesIterator: <ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes) => IterableIterator<ChildChangesDeltaItemUpdateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
-    getCreatedTuplesIterator<ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes): IterableIterator<ChildChangesDeltaItemCreateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
-    getCreatedValueByItemId<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId<ItemTypeType>, columnId: ColumnId): GetFieldValueType<ItemTypeType, ColumnId> | undefined;
+    constructor(itemEntryService: ItemEntryService);
     setItemUpdated<ItemTypeType extends ApiItemType>(entry: ItemEntry<ItemTypeType>, fields: Readonly<Partial<FieldMap<ItemTypeType>>>, mode?: ChangesDeltaItemUpdateMode): this;
     setItemDeleted(tuple: ChildChangesDeltaItemDeleteDelta<any>): this;
     setItemsDeleted(deleted: ChildChangesDeltaItemDeleteDelta<any>[]): this;

package/dist/types/src/classes/CreatedChangesDelta.d.ts

@@ -12,10 +12,10 @@ export declare class CreatedChangesDelta {
     remove(itemType: ApiItemType, itemId: ItemId): boolean;
     add<ItemTypeType extends ApiItemType>(itemId: ItemId, fields: Partial<FieldMap<ItemTypeType>>, columns: ColumnSet<ItemTypeType>): void;
     isEmpty(): boolean;
-    getTuplesIterator<ItemTypes extends ApiItemType[]>(itemTypes: ItemTypes): Generator<ChangesDeltaItemCreateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
+    getTuplesIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): IterableIterator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
     forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ApiItemType) => void): void;
+    forEachOfItemType(itemType: ApiItemType, callback: (tuple: ChangesDeltaItemCreateDelta) => void): void;
     contains(itemType: ApiItemType): boolean;
     getTupleByItemId<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId): ChangesDeltaItemCreateDelta<ItemTypeType> | undefined;
     matchTuplesToQueryGraph<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryGraph: RootQueryNode<ItemTypeType>, matchesAccumulator: MatchesAccumulator<ChangesDeltaItemCreateDelta<ItemTypeType>>): MatchesAccumulator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
-    [Symbol.iterator](): Generator<ChangesDeltaItemCreateDelta>;
 }

package/dist/types/src/classes/ParentChangesDelta.d.ts

@@ -1,5 +1,5 @@
 import { ApiItemType } from '@rentman/backend-types';
-import { ChangesDeltaBase, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, ChildChangesDeltaItemCreateDelta, FieldMap, ItemEntry } from '../internal';
+import { ChangesDeltaBase, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, ChildChangesDeltaItemCreateDelta, FieldMap, ItemEntry, ItemEntryService } from '../internal';
 export interface ParentChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemUpdateDelta<ItemTypeType> {
     entry: ItemEntry<ItemTypeType>;
     changes: {
@@ -19,15 +19,14 @@ export interface ParentChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemT
  *
  * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent}
  */
-export declare class ParentChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemCreateDelta<any>, ParentChangesDeltaItemUpdateDelta<any>> {
+export declare class ParentChangesDelta extends ChangesDeltaBase {
+    updated: {
+        [itemEntryId: number]: ParentChangesDeltaItemUpdateDelta<any>;
+    };
     created: {
         [itemEntryId: string]: ChildChangesDeltaItemCreateDelta;
     };
-    /**
-     * We declare this method to provide the `ItemType` type variable to the result.
-     */
-    getUpdatedTuplesIterator: <ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes) => IterableIterator<ParentChangesDeltaItemUpdateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
-    getCreatedTuplesIterator<ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes): IterableIterator<ChildChangesDeltaItemCreateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
+    constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
     /**
      * @param entry
      * @param fields

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

@@ -1,5 +1,5 @@
 import { ApiItemType } from '@rentman/backend-types';
-import { ApiRequestService, ChangesDeltaFactory, ColumnCache, ErrorHandlerInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, SocketMessage, TransactionCacheFactory } from '../internal';
+import { ApiRequestService, ChangesDeltaFactory, ChangesDeltaResult, ColumnCache, ErrorHandlerInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, SocketMessage, TransactionCacheFactory } from '../internal';
 export declare class SocketMessageHandler {
     private changesDeltaFactory;
     private columnCache;
@@ -10,9 +10,7 @@ export declare class SocketMessageHandler {
     private readonly logPrefix;
     private readonly requestBufferManager;
     constructor(changesDeltaFactory: ChangesDeltaFactory, columnCache: ColumnCache, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, transactionCacheFactory: TransactionCacheFactory, apiRequestService: ApiRequestService, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory);
-    onMessagesReceived(messages: SocketMessage<any>[], flushTimeout?: number): Promise<{
-        allChildrenDonePromise: Promise<void>;
-    }>;
+    onMessagesReceived(messages: SocketMessage<any>[], flushTimeout?: number): Promise<ChangesDeltaResult>;
     refreshItemsOfType(itemType: ApiItemType): Promise<void>;
     private handleDelete;
     private logFetchedItems;

package/dist/types/src/classes/Util.d.ts

@@ -25,7 +25,6 @@ export interface Deferred<T> {
     resolve(value?: T | PromiseLike<T>): void;
     reject(reason?: any): void;
 }
-export declare function promiseWrapTimeout<T>(promise: Promise<T>, createError: () => Error, timeMilliseconds: number): Promise<T>;
 export declare function promiseCreateDeferred<T>(): Deferred<T>;
 export declare function isRegExp(value: any): boolean;
 export declare function isBoolean(value: any): value is boolean;

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

@@ -1,6 +1,6 @@
 import { ApiItemType } from '@rentman/backend-types';
 import { RmCore } from '../../core';
-import { AbstractCacheDependencyInterface, CachedQueryHandlerBase, CachedQueryItem, ChangesDelta, ChangesDeltaItemCreateDelta, ChildChangesDelta, CollectionQuery, EntryParentNull, FieldMap, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, ParentChangesDelta, ServerCache, TransactionCache, TransactionValidatorFactory } from '../../internal';
+import { AbstractCacheDependencyInterface, CachedQueryHandlerBase, CachedQueryItem, ChangesDelta, ChangesDeltaItemCreateDelta, ChildChangesDelta, CollectionQuery, EntryParentNull, FieldMap, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, ServerCache, TransactionCache, TransactionValidatorFactory } from '../../internal';
 export type TransactionOptions = {
     /**
      * @description
@@ -52,6 +52,11 @@ export declare abstract class AbstractCache {
      * Gets an already cached {@link ItemEntry ItemEntry} and the changes of this specific transaction for that entry
      */
     getLocalItemEntryChangesTuple<ItemTypeType extends ApiItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
+    /**
+     * @description
+     * Applies changes from a child transaction to a parent
+     */
+    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): Promise<ItemIdConversionMap>;
     /**
      * @description
      * Called by a parent transaction, propagates changes downwards to all child caches

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

@@ -1,5 +1,5 @@
 import { ApiFieldsOnDeleteRule, ApiItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestColumnMap, ApiRequestColumns, ApiResponseProcessor, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemUpdateMode, CollectionQuery, CollectionResource, ConversionMap, DeregFunction, EntryParent, FieldMap, ItemEntry, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, RequestBufferManager, RequestColumnExpansion, ResponseColumnItemTypeMap, ResponseItemUpdateModeMap, RmCore, ServerCacheDependencyInterface, ServerCachedQueryHandler, ServerItemHandler, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+import { AbstractCache, ApiRequestColumnMap, ApiRequestColumns, ApiResponseProcessor, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemUpdateMode, ChangesDeltaResult, CollectionQuery, CollectionResource, ConversionMap, DeregFunction, EntryParent, FieldMap, ItemEntry, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, RequestBufferManager, RequestColumnExpansion, ResponseColumnItemTypeMap, ResponseItemUpdateModeMap, RmCore, ServerCacheDependencyInterface, ServerCachedQueryHandler, ServerItemHandler, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
 type OnDeltaAppliedCallback = (delta: ChangesDeltaBase) => unknown;
 export type ActiveItemEntries = Set<ItemEntry>;
 /**
@@ -64,9 +64,7 @@ export declare class ServerCache extends AbstractCache {
      * `applyChangesDelta` also ensures any required derived values are properly fetched
      * (which `applyChangesFromParent` doesn't)
      */
-    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<{
-        allChildrenDonePromise: Promise<void>;
-    }>;
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry;
     getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType>;
     containsLocalItemEntryByItemId(itemType: ApiItemType, itemId: ItemEntry['itemId']): boolean;

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

@@ -93,8 +93,7 @@ export declare class TransactionCache extends AbstractCache {
     readonly validator?: TransactionValidator;
     validatorWithDependencies?: TransactionValidatorWithDependencies<any>;
     private readonly options;
-    private actionsQueue;
-    private numPendingActions;
+    private changesDeltasBeingApplied;
     private transactionStateSignal;
     isSavingSignal: import("@angular/core").Signal<boolean>;
     isReadySignal: import("@angular/core").Signal<boolean>;
@@ -107,21 +106,6 @@ export declare class TransactionCache extends AbstractCache {
      * For debugging purposes
      */
     id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
-    /**
-     * Ideally, in order for transaction changes to be deterministic, we only want to have a single process mutating the
-     * transaction. These can be:
-     * - a child transaction saving (calling `applyChangesFromChild`);
-     * - this transaction saving (which might cause changes coming down from the server cache);
-     * - a user applying changes to the transaction.
-     *
-     * Note that `applyChangesFromParent` should not enqueue an action, because this method is called when processing
-     * user changes and saving the transaction. This could potentially cause inconsistencies, when changes come down
-     * from the parent transaction, though the chance is very small.
-     *
-     * @param state When set, immediately set the transaction state property, overwriting any previous state. The state
-     * reverts to `Ready` when all pending actions have been completed.
-     */
-    private enqueueAction;
     /**
      * @deprecated use rootItemSignal instead
      *
@@ -167,15 +151,13 @@ export declare class TransactionCache extends AbstractCache {
      */
     isPending(): boolean;
     /**
-     * When this method is called multiple times, the transaction state is set to `pending` until all promises are
-     * settled.
-     *
-     * 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.
+     * @description
+     * Sets the transactionstate to pending, must recieve a promise as a parameter, on promise resolve, transactionstate gets put back to ready
+     * If the transaction is already in state saving, we use that and let the save function return it to ready
+     * @param promise
      */
-    setPending<Result>(promise: Promise<Result> | ((applyChangesDelta: (changesDelta: ChangesDelta) => Promise<ChangesDeltaResult>) => Promise<Result>)): Promise<Result>;
+    setPending(promise: Promise<any>): Promise<any>;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
-    createBusinessLogicChild(): TransactionCache;
     destroy(): void;
     /**
      * @deprecated use isDestroyedSignal instead
@@ -222,31 +204,21 @@ export declare class TransactionCache extends AbstractCache {
      */
     applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<void>;
     /**
-     * Applies changes from the user on the transaction. This will:
-     * 1. create a child transaction;
-     * 2. apply the changes on the child transaction;
-     * 3. run business logic on the child transaction;
-     * 4. apply the resulting changes on this transaction using `applyChangesFromChild`.
+     * Applies changes to this transaction and its children.
      *
-     * This method waits for other transaction processes to complete, see {@link enqueueAction}.
-     */
-    applyChangesDelta(changesDelta: ChangesDelta): Promise<ChangesDeltaResult>;
-    /**
-     * See {@link applyChangesDelta}. We're introducing a separate method here to facilitate handling the resulting
-     * promise.
-     */
-    private doApplyChangesFromUser;
-    /**
-     * This method is called:
-     * - when initially constructing the business logic child transaction;
-     * - when applying the changes resulting from running a business logic cycle.
+     * The difference between {@link TransactionCache.applyChangesFromParent} and {@link TransactionCache.applyChangesDelta}
+     * is that applyChangesFromParent assumes the change has already been processed on the parent, and applyChangesDelta
+     * will process the changes itself.
      *
-     * It does not consider children.
+     * Please note that the resulting promise resolves before deletes have been processed. Deletes are processed after
+     * the changes have been applied to child transactions. This is reflected by the `allChildrenDonePromise` on the
+     * result.
      *
-     * The result of this method will be used to trigger a (new) business logic cycle. It should not contain changes
-     * already present on the transaction.
+     * However, {@link TransactionCache.save} waits until the complete changes delta has been applied, so calling `save`
+     * after `applyChangesDelta` should not cause any problems.
      */
-    applyChangesDirectly(changesDelta: ChangesDelta): Promise<ParentChangesDelta>;
+    applyChangesDelta(changesDelta: ChangesDelta | ChildChangesDelta): Promise<ChangesDeltaResult>;
+    private trackChangesDeltaBeingApplied;
     getRootTransaction(): TransactionCache;
     getServerCache(): ServerCache;
     getCollectionChangesRecursively<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>): CachedQueryItem<ItemTypeType> | undefined;
@@ -259,19 +231,10 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Saves the transaction, this has a different effect depending on the transaction's parent.
      *
-     * - If the parent is another {@link TransactionCache TransactionCache} it will merge the changes of the child
-     * transaction in the parent transaction
-     * - If the parent is the {@link ServerCache ServerCache} it will save the changes to the API
-     *
-     * Note that, when saving, we need to await:
-     * - any changes being made on this transaction;
-     * - any changes being made on the parent transaction.
+     * - If the parent is another {@link TransactionCache TransactionCache} it will merge the changes of the child transaction in the the parent transaction
+     * - If the parent is the {@link ServerCache ServerCache} it will save the changes to the APi
      */
     save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): Promise<ItemIdConversionMap>;
-    /**
-     * See {@link save}. We're introducing a separate method here to facilitate handling the resulting promise.
-     */
-    private doSave;
     /**
      * Rejects when another user is holding the lock, as opposed to {@link LockService.fetchLock}.
      */
@@ -342,20 +305,10 @@ export declare class TransactionCache extends AbstractCache {
      */
     fetchTitle(itemType: ApiItemType, itemId: ItemId): Promise<string>;
     /**
-     * Merges the passed child transaction into this transaction and then propagates the changes to the other child
-     * transactions.
-     *
-     * This method is called when saving a child transaction and when applying user changes (after business logic is
-     * done.)
-     *
-     * This method assumes derived for updated and created items are already resolved.
-     *
-     * @param childTransaction - Note that we're passing the transaction itself here, as we should only read the changes
-     * before processing them. This assures that, when `applyChangesFromChild` is queued multiple times, the changes
-     * are only applied once. (However, this is largely a theoretical issue.)
+     * @description
+     * Merges the passed child Transaction into this transaction and then propagates them to the other child transactions
      */
-    applyChangesFromChild(childTransaction: Pick<TransactionCache, 'getDelta' | 'cachedQueryHandler'>, tabRequestParameters: any): Promise<ChangesDeltaResult>;
-    private doApplyChangesFromChild;
+    applyChangesFromChild(childTransaction: TransactionCache): Promise<ItemIdConversionMap>;
     /**
      * @description
      * Gets an ItemEntry from the cache, doesn't do a API request, used for saving
@@ -380,6 +333,7 @@ export declare class TransactionCache extends AbstractCache {
     clearItemError(itemEntryId: ItemEntry['id'], columnId?: string, errorKey?: string): void;
     clearItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey?: string): void;
     clearItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string): void;
+    private doApplyChangesDelta;
     private updateSignals;
     /**
      * This method:

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

@@ -12,6 +12,7 @@ import { QueryService } from './classes/QueryService';
 import { SocketMessageHandler } from './classes/SocketMessageHandler';
 import { TemplateCache } from './classes/TemplateCache';
 import { ApiResponseProcessorFactory } from './factories/ApiResponseProcessorFactory';
+import { ChangesCompilationFactory } from './factories/ChangesCompilationFactory';
 import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
 import { CollectionResourceFactory } from './factories/CollectionResourceFactory';
 import { ColumnExpansionFactory } from './factories/ColumnExpansionFactory';
@@ -30,6 +31,7 @@ export declare class RmCore {
     version: string;
     apiRequestService: ApiRequestService;
     apiResponseProcessorFactory: ApiResponseProcessorFactory;
+    changesCompilationFactory: ChangesCompilationFactory;
     changesDeltaFactory: ChangesDeltaFactory;
     collectionResourceFactory: CollectionResourceFactory;
     columnCache: ColumnCache;

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

@@ -0,0 +1,5 @@
+import { ChangesCompilation, TransactionCache } from '../internal';
+export declare class ChangesCompilationFactory {
+    constructor();
+    construct(transaction: TransactionCache): ChangesCompilation;
+}

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

@@ -1,5 +1,6 @@
-import { AbstractCacheDependencyInterface, ApiRequestService, ItemCreateService } from '../internal';
+import { AbstractCacheDependencyInterface, ApiRequestService, ChangesCompilationFactory, ItemCreateService } from '../internal';
 export interface ServerCacheDependencyInterface extends AbstractCacheDependencyInterface {
     apiRequestService: ApiRequestService;
     itemCreateService: ItemCreateService;
+    changesCompilationFactory: ChangesCompilationFactory;
 }

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

@@ -86,6 +86,7 @@ export * from './classes/BusinessLogicManager/registeredBusinessLogicRules';
 export * from './classes/BusinessLogicManager/BusinessLogicManager';
 export * from './classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/TimeColumnUtil';
 export * from './factories/ApiResponseProcessorFactory';
+export * from './factories/ChangesCompilationFactory';
 export * from './factories/CollectionResourceFactory';
 export * from './factories/ColumnExpansionFactory';
 export * from './factories/ColumnInfoFactory';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "63.4.1-blr-01",
+  "version": "63.4.1",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/types/src/index.d.ts",
@@ -15,7 +15,7 @@
   "devDependencies": {
     "@angular/core": "^20",
     "@eslint/js": "^9.8.0",
-    "@rentman/backend-types": "^4.852.0-ga86275b6a5",
+    "@rentman/backend-types": "4.849.0-25-g7d7a8df2b6",
     "@stylistic/eslint-plugin-ts": "^2.7.2",
     "@types/eslint__js": "^8.42.3",
     "clean-webpack-plugin": "^0.1.19",