@rentman/rm-core 0.0.0-RM4-44763

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

@@ -0,0 +1,66 @@
+import { ApiEnumApiType, ApiItemType } from '@rentman/backend-types';
+import moment from 'moment';
+import { ApiEnumApiTypeToTsTypeMap, FieldMap, ItemTypeColumnId, ItemTypeColumnIds, ResponseColumnMap } from '../types/ItemTypesCollection';
+import { ColumnInfo } from './ColumnInfo';
+/**
+ * @description
+ * A service which provides functions to transform data that comes from/goes to the API
+ *
+ * @warning
+ * The code in these functions can be *very hot* on large databases, therefore performance must be kept in mind.
+ * This is also the reason why all column types are written out instead of using the enum
+ */
+export declare abstract class ApiFormatter {
+    static readonly SERVER_DATETIME_FORMAT: string;
+    static readonly SERVER_DATE_FORMAT: string;
+    /**
+     * @description
+     * Returns if a column type is an 'expensive' type, meaning that the action to format the field takes significant CPU time
+     *
+     * ----
+     * @remarks
+     * Currently only used for Moment objects
+     */
+    static isExpensiveFormat(columnType: ApiEnumApiType): boolean;
+    static formatRequestLocal<ItemTypeType extends ApiItemType>(fields: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
+        [columnId: string]: any;
+    };
+    /**
+     * TODO: Since we're never writing to fields directly, we could consider replacing `copyFields` by
+     *  {@link shallowCopyFields}.
+     */
+    static copyFields<ItemTypeType extends ApiItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: Partial<FieldMap<ItemTypeType, ColumnIds>>, destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): FieldMap<ItemTypeType, ColumnIds>;
+    /**
+     * Iterates over source properties, doesn't clone complex objects. Overwrites properties already in `destination`.
+     *
+     * Note: we iterate over the keys of `source` here because this method is typically called when we want to make a
+     * copy of changed fields in a changes delta.
+     */
+    static shallowCopyFields<ItemTypeType extends ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: Partial<FieldMap<ItemTypeType, ColumnIds>>, destination: Partial<FieldMap<ItemTypeType>>, responseColumns: ResponseColumnMap<ItemTypeType>, onMissingColumn?: (columnId: ItemTypeColumnId<ItemTypeType>) => void): Partial<FieldMap<ItemTypeType, ColumnIds>>;
+    static setDefaultValues<ItemTypeType extends ApiItemType = any>(destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Compares the given fields, returns `true` when the fields are equal
+     */
+    static compareFields<ColumnType extends ApiEnumApiType>(columnType: ColumnType, first?: ApiEnumApiTypeToTsTypeMap[ColumnType], second?: ApiEnumApiTypeToTsTypeMap[ColumnType]): boolean;
+    static compareFloats(a: number, b: number): boolean;
+    static compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
+    static compareDurations(first: moment.Duration, second: moment.Duration): boolean;
+    static formatResponseValue(columnType: string, value: any): any;
+    static formatRequestValue(columnType: string, value: any): any;
+    static formatResponseDate(value: null | any): moment.Moment;
+    static formatResponseDuration(value: null | number): moment.Duration;
+    static formatResponseColor(value: string | null): string | null;
+    static formatRequestDateTime(value: moment.Moment): string | null;
+    static formatRequestDate(value: moment.Moment): string | null;
+    static formatRequestDuration(value: moment.Duration): number;
+    static formatRequestColor(value: string | null): string | null;
+    static getDefaultValue(columnType: ApiEnumApiType): any;
+    static hasValue(columnType: ApiEnumApiType, value: any): boolean;
+    static isDefaultValue(columnType: ApiEnumApiType, value: any): boolean;
+    static clone(columnType: string, value: any): any;
+    static getCloneFunction(columnType: string): typeof ApiFormatter.cloneDuration | typeof ApiFormatter.cloneDate;
+    static cloneDuration(duration: moment.Duration): moment.Duration;
+    static cloneDate(date: moment.Moment): moment.Moment;
+    static identity<T>(input: T): T;
+}

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

@@ -0,0 +1,18 @@
+import { ApiItemType, BackendApiQuery, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestColumns, ApiRequestItemMap, ApiRequestLimit, ApiRequestServiceInterface, ApiResponseProcessor, ApiResponseProcessorFactory, FieldMap, RequestParameters } from '../internal';
+export declare class ApiRequestService {
+    private externalApiRequestService;
+    private apiResponseProcessorFactory;
+    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
+    template<ItemTypeType extends ApiItemType = any>(itemType: ItemTypeType, params?: Partial<RequestParameters<ItemTypeType>>): Promise<ApiResponseProcessor>;
+    create<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, values: Partial<FieldMap<ItemTypeType>>, columns: ApiRequestColumnMap, parentType?: ApiItemType, parentId?: ItemId, uniqueTransactionId?: string): Promise<ApiResponseProcessor>;
+    delete<ItemTypeType extends ApiItemType>(itemType: ApiItemType, itemIds: ItemId[], uniqueTransactionId?: string): Promise<ApiResponseProcessor<ItemTypeType>>;
+    updateItems<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, items: ApiRequestItemMap, columns: ApiRequestColumnMap, uniqueTransactionId?: string): Promise<ApiResponseProcessor<ItemTypeType>>;
+    requestSkeleton<ItemTypeType extends ApiItemType = ApiItemType>(params: any, requestCanceler?: Promise<any>): Promise<ApiResponseProcessor<ItemTypeType>>;
+    columns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, columns: {
+        [itemType: string]: ApiRequestColumns | true;
+    }, params?: any): Promise<ApiResponseProcessor<ItemTypeType>>;
+    query<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, query: BackendApiQuery<ItemTypeType>, columns: ApiRequestColumnMap, limit?: ApiRequestLimit<ItemTypeType>): Promise<ApiResponseProcessor<ItemTypeType>>;
+    module<ResponseType = unknown>(module: string, method: string, params: Record<string, unknown>): Promise<ResponseType>;
+    processResponse<ItemTypeType extends ApiItemType = ApiItemType>(request: any): Promise<ApiResponseProcessor<ItemTypeType>>;
+}

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

@@ -0,0 +1,31 @@
+import { ApiItemType, ItemId, ResponseColumn, UnknownResponseColumn } from '@rentman/backend-types';
+import { ApiResponse, ColumnInfo, DerivedStringToRequestColumnPath, FieldMap, ItemTypeMap, ResolveDerivedValue, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
+export declare class ApiResponseProcessor<RequestItemType extends ApiItemType = any> {
+    response: ApiResponse<RequestItemType>;
+    itemType: RequestItemType;
+    columns: ItemTypeMap<UnknownResponseColumn[]>;
+    links: ApiResponse<RequestItemType>['links'];
+    cacheable: boolean;
+    map: any;
+    items: ApiResponse<RequestItemType>['items'];
+    columnIndexMap: {
+        [itemType: string]: {
+            [columnId: string]: number;
+        };
+    };
+    columnMap: ResponseColumnItemTypeMap;
+    constructor(response: ApiResponse<RequestItemType>);
+    static addLazyFormattingFunction<Fields extends FieldMap<any>, ColumnId extends keyof Fields>(columnId: ColumnId, columnType: string, initialValue: any, destination: Fields): void;
+    fetchColumnObject(itemType: ApiItemType): ResponseColumnMap;
+    fetchDerivedValue<T extends string, DefaultValue = undefined>(initialItemId: ItemId, columnPath: T, defaultValue?: DefaultValue): ResolveDerivedValue<RequestItemType, DerivedStringToRequestColumnPath<T>>;
+    fetchDerivedValue<T extends readonly string[], DefaultValue = undefined>(initialItemId: ItemId, columnPath: T, defaultValue?: DefaultValue): ResolveDerivedValue<RequestItemType, T>;
+    fetchValue(itemType: ApiItemType, itemId: ItemId, columnId: string): any;
+    fetchColumnArray<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType): ResponseColumn<ItemTypeType>[];
+    fetchDerivedObject(itemType: ApiItemType, itemId: ItemId, rootColumns: ColumnInfo[]): {};
+    fetchDerivedValues(value: any, column: ColumnInfo, destination: any): void;
+    fetchObject<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType> | undefined;
+    fetchObjectArray<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): FieldMap<ItemTypeType>[];
+    fetchColumnsObject(): ResponseColumnItemTypeMap;
+    private createColumnMaps;
+    private replaceTempItemTypeIdsWithLocalIds;
+}

package/dist/types/src/classes/BusinessLogicManager/AantalBusinessLogicRuleBase.d.ts

@@ -0,0 +1,36 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../models/ItemResource';
+import { GetFieldValueType } from '../../types/ItemTypesCollection';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
+import { BLR_SKIP_RULE, BusinessLogicRule } from './BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from './BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from './BusinessLogicRuleConditionContext';
+import { BusinessLogicRuleContextBase } from './BusinessLogicRuleContextBase';
+export declare const commonEquipmentColumns: readonly ["id", "aantal", "parent", "materiaal"];
+type MateriaalTypeMap = {
+    [equipmentId: number]: GetFieldValueType<'Materiaal', 'type'>;
+};
+type MateriaalType = 'Planningmateriaal' | 'Inhuurmateriaal';
+type ConditionResult<ItemTypeType extends MateriaalType> = {
+    created: ChangesDeltaItemCreateDelta<ItemTypeType>[];
+    updated: ItemId[];
+};
+type Dependency<ItemTypeType extends MateriaalType> = {
+    createdTuples: ChangesDeltaItemCreateDelta<ItemTypeType>[];
+    updatedItemResources: ItemResource<ItemTypeType, typeof commonEquipmentColumns>[];
+    materiaalTypeMap: MateriaalTypeMap;
+};
+/**
+ * @description
+ * If Planningmateriaal 'aantal' is changed make sure it is rounded for rental items.
+ * Note: We're assuming 'aantal' is fractional only for sets & set's content here.
+ */
+export declare abstract class AantalBusinessLogicRuleBase<ItemTypeType extends MateriaalType> extends BusinessLogicRule<ConditionResult<ItemTypeType>, Dependency<ItemTypeType>> {
+    protected readonly itemType: ItemTypeType;
+    condition({ previousChangesDelta, transaction, }: BusinessLogicRuleConditionContext): ConditionResult<ItemTypeType> | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult<ItemTypeType>, context: BusinessLogicRuleContextBase): Promise<Dependency<ItemTypeType>>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency<ItemTypeType>): void;
+    private getMateriaalTypeMap;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/AantaltotaalBusinessLogicRuleBase.d.ts

@@ -0,0 +1,60 @@
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from './BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from './BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from './BusinessLogicRuleConditionContext';
+import { BusinessLogicRuleContextBase, LatestItem } from './BusinessLogicRuleContextBase';
+declare const commonEquipmentColumns: readonly ["id", "aantal", "aantaltotaal", "parent", "materiaal"];
+export declare const plannedEquipmentColumns: readonly ["id", "aantal", "aantaltotaal", "parent", "materiaal", "categorie"];
+export declare const subhireEquipmentColumns: readonly ["id", "aantal", "aantaltotaal", "parent", "materiaal", "inhuurgroep"];
+type PlannedEquipmentItemType = 'Planningmateriaal' | 'Inhuurmateriaal';
+type LatestEquipmentItem<ItemTypeType extends PlannedEquipmentItemType> = {
+    Planningmateriaal: LatestItem<'Planningmateriaal', typeof commonEquipmentColumns>;
+    Inhuurmateriaal: LatestItem<'Inhuurmateriaal', typeof commonEquipmentColumns>;
+}[ItemTypeType];
+type LatestEquipmentItemIdMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId, LatestEquipmentItem<ItemTypeType>>;
+type LatestEquipmentItemParentMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId | null, LatestEquipmentItem<ItemTypeType>[]>;
+type EquipmentIsPhysicalMap = Map<ItemId<'Materiaal'> | null, boolean>;
+interface Dependency<ItemTypeType extends PlannedEquipmentItemType> {
+    /**
+     * Because the fractional total quantity is not stored with the item (only the ceiled value is), we need to
+     * calculate it starting at the root item(s) of the items we'd like to update.
+     */
+    rootItemIds: Iterable<ItemId<ItemTypeType>>;
+    /**
+     * We're requesting all planned equipment items in affected groups because we need both the ancestors and the
+     * descendants of the created / updated items. The ancestors to determine the root items, and the descendants
+     * because their total quantity will change as well.
+     */
+    affectedEquipmentItemsByParent: LatestEquipmentItemParentMap<ItemTypeType>;
+    affectedEquipmentItemsById: LatestEquipmentItemIdMap<ItemTypeType>;
+    equipmentIsPhysicalMap: EquipmentIsPhysicalMap;
+}
+/**
+ * @description
+ * If Planningmateriaal total is changed recalculate the fields
+ * Note: We're assuming 'aantal' is fractional only for sets here.
+ */
+export declare abstract class AantaltotaalBusinessLogicRuleBase<ItemTypeType extends PlannedEquipmentItemType> extends BusinessLogicRule<LatestEquipmentItem<ItemTypeType>[], Dependency<ItemTypeType>> {
+    protected abstract readonly itemType: ItemTypeType;
+    protected abstract readonly groupingProperties: {
+        Planningmateriaal: {
+            itemType: 'MateriaalCat';
+            columnId: 'categorie';
+        };
+        Inhuurmateriaal: {
+            itemType: 'Inhuurgroep';
+            columnId: 'inhuurgroep';
+        };
+    }[ItemTypeType];
+    protected abstract readonly requestColumns: {
+        Planningmateriaal: typeof plannedEquipmentColumns;
+        Inhuurmateriaal: typeof subhireEquipmentColumns;
+    }[ItemTypeType];
+    condition(context: BusinessLogicRuleConditionContext): Promise<LatestEquipmentItem<ItemTypeType>[] | typeof BLR_SKIP_RULE>;
+    dependency(_transaction: TransactionCache, affectedEquipmentItems: LatestEquipmentItem<ItemTypeType>[], context: BusinessLogicRuleContextBase): Promise<Dependency<ItemTypeType>>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency<ItemTypeType>): void;
+    private fetchEquipmentIsPhysicalMap;
+    private updatePlannedEquipmentItem;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Afspraak/AfspraakRecureindBusinessLogicRule.d.ts

@@ -0,0 +1,5 @@
+import { RecurrentItemRecureindBusinessLogicRule } from '../RecurrentItem/RecurrentItemRecureindBusinessLogicRule';
+export declare class AfspraakRecureindBusinessLogicRule extends RecurrentItemRecureindBusinessLogicRule<'Afspraak', 'tot'> {
+    protected itemType: "Afspraak";
+    protected toField: "tot";
+}

package/dist/types/src/classes/BusinessLogicManager/Beschikbaarheid/BeschikbaarheidRecureindBusinessLogicRule.d.ts

@@ -0,0 +1,5 @@
+import { RecurrentItemRecureindBusinessLogicRule } from '../RecurrentItem/RecurrentItemRecureindBusinessLogicRule';
+export declare class BeschikbaarheidRecureindBusinessLogicRule extends RecurrentItemRecureindBusinessLogicRule<'Beschikbaarheid', 'plantot'> {
+    protected itemType: "Beschikbaarheid";
+    protected toField: "plantot";
+}

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

@@ -0,0 +1,66 @@
+import { ApiModuleFunctionResponse } from '@rentman/backend-types';
+import { ErrorHandlerInterface } from '../../interfaces/ErrorHandlerInterface';
+import { HasFlagFn } from '../../types/ItemTypesCollection';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { ChangesDelta } from '../ChangesDelta';
+import { BusinessLogicRule, BusinessLogicRuleConditionConfirmFn, BusinessLogicRuleConfirmFnWithDependency } from './BusinessLogicRule';
+import { BusinessLogicRuleConstructor } from './businessLogicRule.decorator';
+/**
+ * @description
+ * The BusinessLogicManager is responsible for calling all business rules with a ChangesDelta and storing their results for the {@link BusinessLogicRule business logic phases}.
+ */
+export declare class BusinessLogicManager {
+    private errorHandler;
+    /**
+     * We set the business logic rule instances using a constructor parameter to facilitate testing of combinations
+     * of rules.
+     */
+    private readonly businessLogicRuleInstances;
+    constructor(errorHandler: ErrorHandlerInterface, 
+    /**
+     * We set the business logic rule instances using a constructor parameter to facilitate testing of combinations
+     * of rules.
+     */
+    businessLogicRuleInstances: readonly BusinessLogicRule<any, any, any>[]);
+    static constructBusinessLogicRules(locals: ApiModuleFunctionResponse<'locals', 'getLocals'>, hasFlagFn: HasFlagFn, businessLogicRuleClasses?: readonly BusinessLogicRuleConstructor[]): BusinessLogicRule<any, any, any>[];
+    /**
+     * @description
+     * Allows the implementer to add a confirm function which is called after the condition of the business rule has fired
+     * And before the dependency is fetched, preventing unnessesary dependecy calls
+     * With this confirm the process can be aborted without applying the changes from the delta
+     */
+    setBusinessLogicRuleConfirmation<BusinessLogicRuleType extends BusinessLogicRule<any, any, any>>(businessLogicRuleClass: BusinessLogicRuleConstructor<BusinessLogicRuleType>, confirmFunction: BusinessLogicRuleType extends BusinessLogicRule<infer Condition, any, infer Options> ? BusinessLogicRuleConditionConfirmFn<Condition, Options> : never): void;
+    /**
+     * @description
+     * Allows the implementer to add a confirm function which is called after the dependency of the business rule is fetched
+     * And before the apply step is fired.
+     * With this confirm the process can be aborted without applying the changes from the delta
+     */
+    setBusinessLogicRulePostDependencyConfirmation<BusinessLogicRuleType extends BusinessLogicRule<any, any, any>>(businessLogicRuleClass: BusinessLogicRuleConstructor<BusinessLogicRuleType>, confirmFunction: BusinessLogicRuleType extends BusinessLogicRule<infer Condition, infer Dependency, infer Options> ? BusinessLogicRuleConfirmFnWithDependency<Condition, Dependency, Options> : never): void;
+    /**
+     * @description
+     * Handles the business logic for a given ChangesDelta. It will provide a *new* ChangesDelta on which the business
+     * rules can apply their data, so that if new changes are made on *only those new changes* the business logic can be
+     * run again.
+     *
+     * example:
+     * - `Functie.twoway` changes the `Functie.afstand` field
+     * - In a second iteration (recursive call) the `Functie.afstand` field updates `Functie.prijs`
+     *   (by doing `Functie.afstand` * `Functie.kilometerprijs`)
+     * - In a third iteration (2nd recursive call) the `Functie.kilometerprijs` has no business logic, so the function
+     *   exits early (`rulesToRun.size === 0`) and the recursion ends
+     *
+     * @param transaction The transaction the ChangesDelta will be applied on
+     * @param mergedChangesDelta - A changes delta containing the source changes, plus the changes made during *all*
+     * previous rule application cycles.
+     * @param previousChangesDelta - A changes delta containing source changes, *or* the changes made during the last
+     * rule application cycle only. Should be used to determine whether the business logic rule should run.
+     *
+     * @private should only be called by the core
+     */
+    handleBusinessLogic(transaction: TransactionCache, mergedChangesDelta: ChangesDelta, previousChangesDelta?: ChangesDelta): Promise<ChangesDelta | null>;
+    private findBusinessLogicRuleInstance;
+    private applyRules;
+    private waitForRuleDependencies;
+    private extractRulesToRun;
+}

package/dist/types/src/classes/BusinessLogicManager/BusinessLogicRule.d.ts

@@ -0,0 +1,81 @@
+import { ApiItemType, ApiModuleFunctionResponse, ResponseColumn } from '@rentman/backend-types';
+import { ItemEntry } from '../../models/ItemEntry';
+import { GetFieldValueType, HasFlagFn, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { BusinessLogicRuleApplyContext } from './BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from './BusinessLogicRuleConditionContext';
+import { BusinessLogicRuleContextBase } from './BusinessLogicRuleContextBase';
+export declare const BLR_SKIP_RULE: unique symbol;
+export declare const BLR_CONTINUE_WITH_DEFAULTS: unique symbol;
+/**
+ * As the 'condition' function can return any value, we introduce a unique identifier to return when a business
+ * logic rule confirm function has been rejected, and changes should be abandoned.
+ */
+export declare const BLR_ABANDON_CHANGES: unique symbol;
+export interface RuleConditionResultTuple {
+    ruleInstance: BusinessLogicRule<any, any, any>;
+    conditionResult: any;
+    confirmResult?: any;
+}
+export interface RuleDependencyResultTuple extends RuleConditionResultTuple {
+    dependencyResult: any;
+    confirmResult?: any;
+}
+type MaybePromise<T> = T | Promise<T>;
+export type BusinessLogicRuleConditionConfirmFn<ConditionResult, ConfirmResult> = (conditionResult: ConditionResult, transaction: TransactionCache) => MaybePromise<ConfirmResult | typeof BLR_SKIP_RULE | typeof BLR_ABANDON_CHANGES | typeof BLR_CONTINUE_WITH_DEFAULTS>;
+export type BusinessLogicRuleConfirmFnWithDependency<ConditionResult, Dependency, ConfirmResult> = (conditionResult: ConditionResult, dependency: Dependency, transaction: TransactionCache) => MaybePromise<ConfirmResult | typeof BLR_SKIP_RULE | typeof BLR_ABANDON_CHANGES | typeof BLR_CONTINUE_WITH_DEFAULTS>;
+export type BusinessLogicConditionResult<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>> = {
+    itemEntry: ItemEntry<ItemTypeType>;
+    responseColumn: ResponseColumn<ItemTypeType, ColumnId>;
+    oldValue: GetFieldValueType<ItemTypeType, ColumnId>;
+    newValue: GetFieldValueType<ItemTypeType, ColumnId>;
+};
+/**
+ * @description
+ * A business rule is a class that does some data transformation depending on other fields.
+ * You can hook into any data change using the {@link BusinessLogicRule.condition `condition`} function (also deletes/creates)
+ *
+ * All business rule logic is always run in these phases:
+ * 1. condition checking - handled by the {@link BusinessLogicRule.condition `condition`} function
+ * 2. dependency fetching - handled by the {@link BusinessLogicRule.dependency `dependency`} function
+ * 3. rule applying - handled by the {@link BusinessLogicRule.apply `apply`} function
+ */
+export declare abstract class BusinessLogicRule<ConditionResult, DependencyType, ConfirmResult = undefined> {
+    protected readonly locals: ApiModuleFunctionResponse<'locals', 'getLocals'>;
+    protected readonly hasFlag: HasFlagFn;
+    confirm: BusinessLogicRuleConditionConfirmFn<ConditionResult, ConfirmResult> | null;
+    postDependencyConfirm: BusinessLogicRuleConfirmFnWithDependency<ConditionResult, DependencyType, ConfirmResult> | null;
+    constructor(locals: ApiModuleFunctionResponse<'locals', 'getLocals'>, hasFlag: HasFlagFn);
+    /**
+     * @description
+     * The {@link BusinessLogicRule.dependency `dependency`} function gets the result of the
+     * {@link BusinessLogicRule.condition `condition`} function and has to ensure that the data that the
+     * {@link BusinessLogicRule.apply `apply`} function reads/writes is fetched (because you cannot write columns you don't have).
+     *
+     * @param transaction The transaction that the delta is being applied on
+     * @param conditionResult The result of the {@link BusinessLogicRule.condition `condition`} call
+     */
+    abstract dependency(transaction: TransactionCache, conditionResult: ConditionResult, context: BusinessLogicRuleContextBase): Promise<DependencyType>;
+    /**
+     * @description
+     * The {@link BusinessLogicRule.apply `apply`} function gets the result of the
+     * {@link BusinessLogicRule.dependency `dependency`} function and is responsible for actually doing the business
+     * logic. In this function other fields can be updated or new items can be created.
+     *
+     * @remark
+     * Do not alter data in the `changesDelta` but use the `destinationChangesDelta`, this is so that for the changed
+     * values in the `destinationChangesDelta` business logic can also be done.
+     *
+     * @param dependencies The result of the {@link BusinessLogicRule.dependency `dependency`} function
+     */
+    abstract apply(context: BusinessLogicRuleApplyContext, dependencies: DependencyType, conditionResult: ConditionResult, confirmResult: ConfirmResult): void;
+    /**
+     * @description
+     * The {@link BusinessLogicRule.condition `condition`} function should extract the items from the {@link ChangesDelta `ChangesDelta`} so that the {@link BusinessLogicRule.dependency `dependency`} function can fetch the required data for the business rule.
+     * This function can return `undefined` if the rule does not apply to the items in the given ChangesDelta.
+     *
+     * @protected
+     */
+    abstract condition(context: BusinessLogicRuleConditionContext): Promise<ConditionResult | typeof BLR_SKIP_RULE> | ConditionResult | typeof BLR_SKIP_RULE;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/BusinessLogicRuleApplyContext.d.ts

@@ -0,0 +1,32 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ItemEntry } from '../../models/ItemEntry';
+import { FieldMap, GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { ChangesDelta } from '../ChangesDelta';
+import { BusinessLogicRuleContextBase } from './BusinessLogicRuleContextBase';
+/**
+ * Class that represents the context for the business logic rule `apply()` function.
+ */
+export declare class BusinessLogicRuleApplyContext extends BusinessLogicRuleContextBase {
+    readonly destinationChangesDelta: ChangesDelta;
+    /**
+     * @param destinationChangesDelta - Changes should be written to this changes delta.
+     */
+    constructor(transactionCache: TransactionCache, previousChangesDelta: ChangesDelta, mergedChangesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta);
+    /**
+     * An alias for `destinationChangesDelta.setItemUpdated().
+     *
+     * In most cases, `setUpdatedValue()`, would be preferred, because it only sets the value when differs from the
+     * current value.
+     */
+    setItemUpdated<ItemTypeType extends ApiItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>): void;
+    /**
+     * An alias for `destinationChangesDelta.setItemsDeleted().
+     */
+    setItemsDeleted<ItemTypeType extends ApiItemType>(entries: ItemEntry<ItemTypeType>[]): void;
+    /**
+     * Convenience function to write an updated value to the destination changes delta. Only sets the value when differs
+     * from the current value.
+     */
+    setUpdatedValue<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(entry: ItemEntry<ItemTypeType>, columnId: ColumnId, newValue: GetFieldValueType<ItemTypeType, ColumnId>): void;
+}

package/dist/types/src/classes/BusinessLogicManager/BusinessLogicRuleConditionContext.d.ts

@@ -0,0 +1,41 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ErrorHandlerInterface } from '../../interfaces/ErrorHandlerInterface';
+import { GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { ChangesDelta, ChangesDeltaItemUpdateDelta } from '../ChangesDelta';
+import { BLR_SKIP_RULE, BusinessLogicConditionResult } from './BusinessLogicRule';
+import { BusinessLogicRuleContextBase } from './BusinessLogicRuleContextBase';
+/**
+ * Class that represents the context for the business logic rule `condition()` function.
+ *
+ * Please note that, while the transaction, merged changes delta and previous changes delta are available on the
+ * class instance, using the helper functions is preferred.
+ */
+export declare class BusinessLogicRuleConditionContext extends BusinessLogicRuleContextBase {
+    private errorHandler;
+    constructor(transaction: TransactionCache, previousChangesDelta: ChangesDelta, mergedChangesDelta: ChangesDelta, errorHandler: ErrorHandlerInterface);
+    /**
+     * @description
+     * This function will compare the stored changes with the given changes, and return a
+     * {@link BusinessLogicConditionResult} if the fields have been changed, `null` otherwise.
+     * If either the source or changed field is `undefined` it will always return `null` (not changed)
+     *
+     * @param tuple The {@link ChangesDelta.updated update tuple} from a ChangesDelta
+     * @param columnId The columnId of the field that should've been changed for the ID to be included
+     */
+    fieldChanged<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(tuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, columnId: ColumnId): null | BusinessLogicConditionResult<ItemTypeType, ColumnId>;
+    /**
+     * This function is a utility function that will return the {@link ItemId ItemIds} of updated items in the
+     * {@link ChangesDelta ChangesDelta} which match the {@link ApiItemType ItemType} and of which the provided
+     * column's field has changed.
+     *
+     * @param itemType The ItemType of the item you want to compare a field from
+     * @param columnId The columnId of the field that should've been changed for the ID to be included
+     */
+    getItemIdsWithUpdatedField<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, columnId: ItemTypeColumnId<ItemTypeType>): ItemId[] | typeof BLR_SKIP_RULE;
+    /**
+     * Like {@link getItemIdsWithUpdatedField}, but allows for a new value to be provided. Only IDs of items where the
+     * field has been updated to the new value will be included in the result.
+     */
+    getItemIdsWithFieldUpdatedTo<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemType: ItemTypeType, columnId: ColumnId, newValue: GetFieldValueType<ItemTypeType, ColumnId>): ItemId[] | typeof BLR_SKIP_RULE;
+}

package/dist/types/src/classes/BusinessLogicManager/BusinessLogicRuleContextBase.d.ts

@@ -0,0 +1,58 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ChangesDelta, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, FieldMap, GetFieldValueType, ItemEntry, ItemTypeColumnId, TransactionCache } from '../../internal';
+export type LatestItemColumnsArray<ItemTypeType extends ApiItemType> = readonly ItemTypeColumnId<ItemTypeType>[];
+export type UpdatedLatestItem<ItemTypeType extends ApiItemType, ColumnIds extends LatestItemColumnsArray<ItemTypeType>> = {
+    itemEntry: ItemEntry<ItemTypeType>;
+    updatedTuple?: ChangesDeltaItemUpdateDelta<ItemTypeType>;
+    fields: FieldMap<ItemTypeType, ColumnIds>;
+};
+/**
+ * A 'latest' item can either be:
+ * - A created changes delta (for created items).
+ * - An object containing an item entry and a `fields` property (for updated items). The `fields` property will
+ *  read updated values from the changes delta if available.
+ *
+ * In both cases, we can access the latest values through the `fields` property.
+ */
+export type LatestItem<ItemTypeType extends ApiItemType, ColumnIds extends LatestItemColumnsArray<ItemTypeType>> = UpdatedLatestItem<ItemTypeType, ColumnIds> | ChangesDeltaItemCreateDelta<ItemTypeType>;
+export declare abstract class BusinessLogicRuleContextBase {
+    readonly transaction: TransactionCache;
+    readonly previousChangesDelta: ChangesDelta;
+    readonly mergedChangesDelta: ChangesDelta;
+    /**
+     * @param transaction - The transaction the business logic rule is being applied on.
+     * @param previousChangesDelta - A changes delta containing source changes, *or* the changes made during the last
+     * rule application cycle only. Should be used to determine whether the business logic rule should run.
+     * @param mergedChangesDelta - A changes delta containing the source changes, plus the changes made during *all*
+     * previous rule application cycles.
+     */
+    protected constructor(transaction: TransactionCache, previousChangesDelta: ChangesDelta, mergedChangesDelta: ChangesDelta);
+    /**
+     * This function will get the latest value of the given itemEntry by first looking in the merged changes delta.
+     * It will return the value found in the transaction chain otherwise.
+     *
+     * You could assume this function never returns `undefined` if you fetch the resource in your dependency function.
+     */
+    getLatestValue<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(entry: ItemEntry<ItemTypeType>, columnId: ColumnId): GetFieldValueType<ItemTypeType, ColumnId> | undefined;
+    isUpdatedLatestItem<ItemTypeType extends ApiItemType, ColumnIds extends LatestItemColumnsArray<ItemTypeType>>(latestItem: LatestItem<ItemTypeType, ColumnIds>): latestItem is UpdatedLatestItem<ItemTypeType, ColumnIds>;
+    collectFields<ItemTypeType extends ApiItemType>(latestItem: LatestItem<ItemTypeType, any>): FieldMap<ItemTypeType>;
+    /**
+     * The equivalent of `getLinkCollections` on the transaction. Returns an array of 'latest' items for each parent
+     * ID. Covers the merged changes delta as well as the transaction. Currently doesn't take deleted items into account.
+     *
+     * TODO: Instead of replicating transaction functionality in the business rule context, we should apply business
+     *  logic rules on a child transaction.
+     */
+    fetchLatestItemsByParent<ParentItemType extends ApiItemType, ItemTypeType extends ApiItemType, ColumnIds extends LatestItemColumnsArray<ItemTypeType>>(parentItemType: ParentItemType, parentItemIds: ItemId<ParentItemType>[], itemType: ItemTypeType, requestColumns: ColumnIds): Promise<Map<ItemId<ParentItemType>, LatestItem<ItemTypeType, ColumnIds>[]>>;
+    /**
+     * This method should only be used when we're sure the items do not occur in the created changes. Generally,
+     * {@link fetchLatestItemsById} should be used instead.
+     */
+    fetchUpdatedLatestItemsById<ItemTypeType extends ApiItemType, ColumnIds extends LatestItemColumnsArray<ItemTypeType>>(itemType: ItemTypeType, itemIds: ItemId[], requestColumns: ColumnIds): Promise<UpdatedLatestItem<ItemTypeType, ColumnIds>[]>;
+    /**
+     * Returns an array of {@link LatestItem}s, taking both changes on the transaction and the merged changes delta into
+     * account.
+     */
+    fetchLatestItemsById<ItemTypeType extends ApiItemType, ColumnIds extends LatestItemColumnsArray<ItemTypeType>>(itemType: ItemTypeType, itemIds: Iterable<ItemId>, requestColumns: ColumnIds): Promise<LatestItem<ItemTypeType, ColumnIds>[]>;
+    private constructLatestItems;
+}

package/dist/types/src/classes/BusinessLogicManager/Contact/ContactAddressBusinessLogicRule.d.ts

@@ -0,0 +1,22 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const ADDRESS_FIELDS: readonly ["straat", "huisnummer", "postcode", "stad", "provincie", "land"];
+declare const ADDRESS_PREFIXES: readonly ["bezoek", "post", "factuur"];
+type RequestColumns = ({
+    [Prefix in typeof ADDRESS_PREFIXES[number]]: {
+        [Field in typeof ADDRESS_FIELDS[number]]: `${Prefix}${Field}`;
+    }[typeof ADDRESS_FIELDS[number]];
+}[typeof ADDRESS_PREFIXES[number]])[];
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Contact', RequestColumns>[];
+export declare class ContactAddressBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, contactIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, contactResources: Dependency): void;
+    private addressEqualsVisitingAddress;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Customfield/CustomFieldLinkedItemTypeBusinessLogicRule.d.ts

@@ -0,0 +1,18 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Customfield', ['defaultvalue']>[];
+/**
+ * @description
+ * If the 'type' field changes we reset the 'defaultvalue' and 'attribute' fields so that they do not contain invalid values
+ */
+export declare class CustomFieldLinkedItemTypeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, customFieldResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Customfield/CustomFieldTypeBusinessLogicRule.d.ts

@@ -0,0 +1,18 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Customfield', ['defaultvalue', 'attributes', 'type']>[];
+/**
+ * @description
+ * If the 'type' field changes we reset the 'defaultvalue' and 'attribute' fields so that they do not contain invalid values
+ */
+export declare class CustomFieldTypeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, customFieldResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/DefaultContactPersonUpdateBusinessLogicRule.d.ts

@@ -0,0 +1,30 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ItemEntry } from '../../models/ItemEntry';
+import { ItemResource } from '../../models/ItemResource';
+import { ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from './BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from './BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from './BusinessLogicRuleConditionContext';
+type ConditionResult = {
+    [ItemTypeType in ApiItemType]?: Map<ItemEntry, {
+        [ColumnId in ItemTypeColumnId<ItemTypeType>]?: ItemId<'Contact'>;
+    }>;
+};
+declare const dependencyColumns: readonly ["id", "contactpersoon"];
+type Dependency = {
+    conditionResult: ConditionResult;
+    contactMap: {
+        [contactId: string]: ItemResource<'Contact', typeof dependencyColumns>;
+    };
+};
+/**
+ * This business rule is responsible for setting the default contactperson related to a
+ * selected contact for itemTypes that have fields for this.
+ */
+export declare class DefaultContactPersonUpdateBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependencyResult: Dependency): void;
+}
+export {};