@rentman/rm-core 63.4.1 → 64.0.1

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

@@ -4,10 +4,12 @@ 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', ['id', 'naam']>;
-    subprojectResources: ItemResource<'Subproject', ['id', 'project', 'naam']>[];
+    projectResource: ItemResource<'Project', typeof projectColumns>;
+    subprojectResources: ItemResource<'Subproject', typeof subprojectColumns>[];
 }[];
 /**
  * @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 ["tot", "van"];
+declare const tijdColumns: readonly ["id", "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, }: Dependency): void;
+    apply(context: BusinessLogicRuleApplyContext, { taakResources, tijdResources, }: 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,10 +4,12 @@ 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', ['naam', 'id']>;
-    functiegroepResource: ItemResource<'Functiegroep', ['naam']>;
+    tijdResource: ItemResource<'Tijd', typeof tijdColumns>;
+    functiegroepResource: ItemResource<'Functiegroep', typeof functiegroepColumns>;
 }[];
 /**
  * @description

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

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

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

@@ -1,10 +1,9 @@
 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: ItemTypeColumnId<'HoursType'>;
+    protected abstract conditionColumnId: 'has_calculated_duration' | 'can_have_activities';
     condition(context: BusinessLogicRuleConditionContext): Promise<ConditionResult | typeof BLR_SKIP_RULE>;
 }
 export {};

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

@@ -22,13 +22,10 @@ export interface ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> e
  *
  * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
  */
-export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemDeleteDelta<any>> {
+export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta<any>, 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.
@@ -37,9 +34,11 @@ export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemDelet
         [itemEntryId: number]: ItemEntryChangesTuple<any>;
     };
     constructor(logMissingColumnErrors: boolean, queryItemTypes: Iterable<ApiItemType> | undefined, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
-    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;
+    /**
+     * 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]>>;
     /**
      * @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
@@ -49,7 +48,6 @@ export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemDelet
      * - 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;
@@ -75,7 +73,7 @@ export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemDelet
      * @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>): void;
+    setItemRestored<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): this;
     isEmpty(): boolean;
     toJSON(): any;
 }

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

@@ -1,15 +1,5 @@
 import { ApiItemType, ItemId } from '@rentman/backend-types';
-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>;
-};
+import { FieldMap, GetFieldValueType, ItemEntry, ItemEntryService, ItemTypeColumnId } from '../internal';
 export type ChangesDeltaItemUpdateMode = 
 /**
  * For create/update responses you always want to overwrite whatever is cached
@@ -41,10 +31,10 @@ export interface ChangesDeltaBaseItemUpdateDelta<ItemTypeType extends ApiItemTyp
 export interface ChangesDeltaBaseItemDeleteDelta<ItemTypeType extends ApiItemType> {
     entry: ItemEntry<ItemTypeType>;
 }
-export declare abstract class ChangesDeltaBase<ItemDeleteDeltaType extends ChangesDeltaBaseItemDeleteDelta<any> = ChangesDeltaBaseItemDeleteDelta<any>> {
+export declare abstract class ChangesDeltaBase<ItemCreateDeltaType = unknown, ItemUpdateDeltaType extends ChangesDeltaBaseItemUpdateDelta<any> = ChangesDeltaBaseItemUpdateDelta<any>, ItemDeleteDeltaType extends ChangesDeltaBaseItemDeleteDelta<any> = ChangesDeltaBaseItemDeleteDelta<any>> {
     protected itemEntryService: ItemEntryService;
     updated: {
-        [itemEntryId: number]: ChangesDeltaBaseItemUpdateDelta<any>;
+        [itemEntryId: number]: ItemUpdateDeltaType;
     };
     protected deleted: {
         [ItemType in ApiItemType]?: Map<ItemEntry<ItemType>, ItemDeleteDeltaType>;
@@ -62,8 +52,15 @@ export declare abstract class ChangesDeltaBase<ItemDeleteDeltaType extends Chang
      * When set, only collections of this item type will be matched.
      */
     _queryItemTypeSet?: Set<ApiItemType>;
-    protected constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
+    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, ChangesCompilationFactory, ChangesDeltaFactory, ErrorHandlerInterface, ItemIdConversionMap, RequestBufferManager, RequestColumnExpansionFactory, TransactionCache } from '../internal';
+import { ApiRequestService, ChangesCompilation, 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, changesCompilationFactory: ChangesCompilationFactory, changesDeltaFactory: ChangesDeltaFactory, errorHandler: ErrorHandlerInterface, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    constructor(apiRequestService: ApiRequestService, changesDeltaFactory: ChangesDeltaFactory, errorHandler: ErrorHandlerInterface, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, changesCompilation: ChangesCompilation, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
     /**
      * @description
      * Executes the requests in the order of:

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

@@ -1,9 +1,18 @@
-import { ApiItemType } from '@rentman/backend-types';
-import { ChangesDeltaBase, ChangesDeltaBaseItemDeleteDelta, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, FieldMap, ItemEntry, ItemEntryService } from '../internal';
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ChangesDeltaBase, ChangesDeltaBaseItemDeleteDelta, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, FieldMap, GetFieldValueType, ItemEntry, ItemTypeColumnId } 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: {
@@ -22,14 +31,16 @@ export interface ChildChangesDeltaItemDeleteDelta<ItemTypeType extends ApiItemTy
  *
  * Use this when calling {@link TransactionCache.applyChangesFromChild}.
  */
-export declare class ChildChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemDeleteDelta<any>> {
-    updated: {
-        [itemEntryId: number]: ChildChangesDeltaItemUpdateDelta<any>;
-    };
+export declare class ChildChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemCreateDelta<any>, ChildChangesDeltaItemUpdateDelta<any>, ChildChangesDeltaItemDeleteDelta<any>> {
     created: {
         [itemEntryId: string]: ChildChangesDeltaItemCreateDelta;
     };
-    constructor(itemEntryService: ItemEntryService);
+    /**
+     * 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;
     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<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): IterableIterator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
+    getTuplesIterator<ItemTypes extends ApiItemType[]>(itemTypes: ItemTypes): Generator<ChangesDeltaItemCreateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
     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, ItemEntryService } from '../internal';
+import { ChangesDeltaBase, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, ChildChangesDeltaItemCreateDelta, FieldMap, ItemEntry } from '../internal';
 export interface ParentChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemUpdateDelta<ItemTypeType> {
     entry: ItemEntry<ItemTypeType>;
     changes: {
@@ -19,14 +19,15 @@ export interface ParentChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemT
  *
  * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent}
  */
-export declare class ParentChangesDelta extends ChangesDeltaBase {
-    updated: {
-        [itemEntryId: number]: ParentChangesDeltaItemUpdateDelta<any>;
-    };
+export declare class ParentChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemCreateDelta<any>, ParentChangesDeltaItemUpdateDelta<any>> {
     created: {
         [itemEntryId: string]: ChildChangesDeltaItemCreateDelta;
     };
-    constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
+    /**
+     * 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]>>;
     /**
      * @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, ChangesDeltaResult, ColumnCache, ErrorHandlerInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, SocketMessage, TransactionCacheFactory } from '../internal';
+import { ApiRequestService, ChangesDeltaFactory, ColumnCache, ErrorHandlerInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, SocketMessage, TransactionCacheFactory } from '../internal';
 export declare class SocketMessageHandler {
     private changesDeltaFactory;
     private columnCache;
@@ -10,7 +10,9 @@ 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<ChangesDeltaResult>;
+    onMessagesReceived(messages: SocketMessage<any>[], flushTimeout?: number): Promise<{
+        allChildrenDonePromise: Promise<void>;
+    }>;
     refreshItemsOfType(itemType: ApiItemType): Promise<void>;
     private handleDelete;
     private logFetchedItems;

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

@@ -25,6 +25,7 @@ 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, OnAfterCreateCallback, ParentChangesDelta, ServerCache, TransactionCache, TransactionValidatorFactory } from '../../internal';
+import { AbstractCacheDependencyInterface, CachedQueryHandlerBase, CachedQueryItem, ChangesDelta, ChangesDeltaItemCreateDelta, ChildChangesDelta, CollectionQuery, EntryParentNull, FieldMap, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, ParentChangesDelta, ServerCache, TransactionCache, TransactionValidatorFactory } from '../../internal';
 export type TransactionOptions = {
     /**
      * @description
@@ -52,11 +52,6 @@ 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, ChangesDeltaResult, 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, 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,7 +64,9 @@ 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<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<{
+        allChildrenDonePromise: Promise<void>;
+    }>;
     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,7 +93,8 @@ export declare class TransactionCache extends AbstractCache {
     readonly validator?: TransactionValidator;
     validatorWithDependencies?: TransactionValidatorWithDependencies<any>;
     private readonly options;
-    private changesDeltasBeingApplied;
+    private actionsQueue;
+    private numPendingActions;
     private transactionStateSignal;
     isSavingSignal: import("@angular/core").Signal<boolean>;
     isReadySignal: import("@angular/core").Signal<boolean>;
@@ -106,6 +107,21 @@ 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
      *
@@ -151,13 +167,15 @@ export declare class TransactionCache extends AbstractCache {
      */
     isPending(): boolean;
     /**
-     * @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
+     * 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.
      */
-    setPending(promise: Promise<any>): Promise<any>;
+    setPending<Result>(promise: Promise<Result> | ((applyChangesDelta: (changesDelta: ChangesDelta) => Promise<ChangesDeltaResult>) => Promise<Result>)): Promise<Result>;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    createBusinessLogicChild(): TransactionCache;
     destroy(): void;
     /**
      * @deprecated use isDestroyedSignal instead
@@ -204,21 +222,31 @@ export declare class TransactionCache extends AbstractCache {
      */
     applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): Promise<void>;
     /**
-     * Applies changes to this transaction and its children.
+     * 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`.
      *
-     * 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.
+     * 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.
      *
-     * 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.
+     * It does not consider children.
      *
-     * However, {@link TransactionCache.save} waits until the complete changes delta has been applied, so calling `save`
-     * after `applyChangesDelta` should not cause any problems.
+     * 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.
      */
-    applyChangesDelta(changesDelta: ChangesDelta | ChildChangesDelta): Promise<ChangesDeltaResult>;
-    private trackChangesDeltaBeingApplied;
+    applyChangesDirectly(changesDelta: ChangesDelta): Promise<ParentChangesDelta>;
     getRootTransaction(): TransactionCache;
     getServerCache(): ServerCache;
     getCollectionChangesRecursively<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>): CachedQueryItem<ItemTypeType> | undefined;
@@ -231,10 +259,19 @@ 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 the parent transaction
-     * - If the parent is the {@link ServerCache ServerCache} it will save the changes to the APi
+     * - 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.
      */
     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}.
      */
@@ -305,10 +342,20 @@ export declare class TransactionCache extends AbstractCache {
      */
     fetchTitle(itemType: ApiItemType, itemId: ItemId): Promise<string>;
     /**
-     * @description
-     * Merges the passed child Transaction into this transaction and then propagates them to the other child transactions
+     * 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.)
      */
-    applyChangesFromChild(childTransaction: TransactionCache): Promise<ItemIdConversionMap>;
+    applyChangesFromChild(childTransaction: Pick<TransactionCache, 'getDelta' | 'cachedQueryHandler'>, tabRequestParameters: any): Promise<ChangesDeltaResult>;
+    private doApplyChangesFromChild;
     /**
      * @description
      * Gets an ItemEntry from the cache, doesn't do a API request, used for saving
@@ -333,7 +380,6 @@ 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,7 +12,6 @@ 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';
@@ -31,7 +30,6 @@ export declare class RmCore {
     version: string;
     apiRequestService: ApiRequestService;
     apiResponseProcessorFactory: ApiResponseProcessorFactory;
-    changesCompilationFactory: ChangesCompilationFactory;
     changesDeltaFactory: ChangesDeltaFactory;
     collectionResourceFactory: CollectionResourceFactory;
     columnCache: ColumnCache;

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

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

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

@@ -86,7 +86,6 @@ 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",
+  "version": "64.0.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.849.0-25-g7d7a8df2b6",
+    "@rentman/backend-types": "^4.852.0-ga86275b6a5",
     "@stylistic/eslint-plugin-ts": "^2.7.2",
     "@types/eslint__js": "^8.42.3",
     "clean-webpack-plugin": "^0.1.19",

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

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