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

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

@@ -2,22 +2,24 @@ 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 MateriaalPropertiesMap = {
-    [equipmentId: number]: {
-        is_physical: GetFieldValueType<'Materiaal', 'is_physical'>;
-        is_combination: GetFieldValueType<'Materiaal', 'is_combination'>;
-    };
+type MateriaalTypeMap = {
+    [equipmentId: number]: GetFieldValueType<'Materiaal', 'type'>;
 };
 type MateriaalType = 'Planningmateriaal' | 'Inhuurmateriaal';
-type ConditionResult<ItemTypeType extends MateriaalType> = ItemId<ItemTypeType>[];
+type ConditionResult<ItemTypeType extends MateriaalType> = {
+    created: ChangesDeltaItemCreateDelta<ItemTypeType>[];
+    updated: ItemId[];
+};
 type Dependency<ItemTypeType extends MateriaalType> = {
-    itemResources: ItemResource<ItemTypeType, typeof commonEquipmentColumns>[];
-    materiaalPropertiesMap: MateriaalPropertiesMap;
+    createdTuples: ChangesDeltaItemCreateDelta<ItemTypeType>[];
+    updatedItemResources: ItemResource<ItemTypeType, typeof commonEquipmentColumns>[];
+    materiaalTypeMap: MateriaalTypeMap;
 };
 /**
  * @description
@@ -29,6 +31,6 @@ export declare abstract class AantalBusinessLogicRuleBase<ItemTypeType extends M
     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 getMateriaalPropertiesMap;
+    private getMateriaalTypeMap;
 }
 export {};

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

@@ -1,20 +1,19 @@
 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';
-import { BusinessLogicRuleContextBase } from './BusinessLogicRuleContextBase';
+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 PlannedEquipmentItem<ItemTypeType extends PlannedEquipmentItemType> = {
-    Planningmateriaal: ItemResource<'Planningmateriaal', typeof commonEquipmentColumns>;
-    Inhuurmateriaal: ItemResource<'Inhuurmateriaal', typeof commonEquipmentColumns>;
+type LatestEquipmentItem<ItemTypeType extends PlannedEquipmentItemType> = {
+    Planningmateriaal: LatestItem<'Planningmateriaal', typeof commonEquipmentColumns>;
+    Inhuurmateriaal: LatestItem<'Inhuurmateriaal', typeof commonEquipmentColumns>;
 }[ItemTypeType];
-type PlannedEquipmentItemIdMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId, PlannedEquipmentItem<ItemTypeType>>;
-type PlannedEquipmentItemParentMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId | null, PlannedEquipmentItem<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> {
     /**
@@ -27,8 +26,8 @@ interface Dependency<ItemTypeType extends PlannedEquipmentItemType> {
      * 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: PlannedEquipmentItemParentMap<ItemTypeType>;
-    affectedEquipmentItemsById: PlannedEquipmentItemIdMap<ItemTypeType>;
+    affectedEquipmentItemsByParent: LatestEquipmentItemParentMap<ItemTypeType>;
+    affectedEquipmentItemsById: LatestEquipmentItemIdMap<ItemTypeType>;
     equipmentIsPhysicalMap: EquipmentIsPhysicalMap;
 }
 /**
@@ -36,7 +35,7 @@ interface Dependency<ItemTypeType extends PlannedEquipmentItemType> {
  * 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<ItemId<ItemTypeType>[], Dependency<ItemTypeType>> {
+export declare abstract class AantaltotaalBusinessLogicRuleBase<ItemTypeType extends PlannedEquipmentItemType> extends BusinessLogicRule<LatestEquipmentItem<ItemTypeType>[], Dependency<ItemTypeType>> {
     protected abstract readonly itemType: ItemTypeType;
     protected abstract readonly groupingProperties: {
         Planningmateriaal: {
@@ -52,8 +51,8 @@ export declare abstract class AantaltotaalBusinessLogicRuleBase<ItemTypeType ext
         Planningmateriaal: typeof plannedEquipmentColumns;
         Inhuurmateriaal: typeof subhireEquipmentColumns;
     }[ItemTypeType];
-    condition(context: BusinessLogicRuleConditionContext): ItemId<ItemTypeType>[] | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, affectedEquipmentItemIds: ItemId<ItemTypeType>[], context: BusinessLogicRuleContextBase): Promise<Dependency<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;

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

@@ -50,14 +50,15 @@ export declare class BusinessLogicManager {
      * - 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 businessLogicTransaction The transaction the ChangesDelta will be applied on.
-     * @param changesDelta - A changes delta containing source changes.
+     * @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.
      *
-     * @returns A child transaction where the business logic has been applied.
-     *
-     * @private Should only be called by the core.
+     * @private should only be called by the core
      */
-    handleBusinessLogic(transaction: TransactionCache, changesDelta: ChangesDelta): Promise<TransactionCache | null>;
+    handleBusinessLogic(transaction: TransactionCache, mergedChangesDelta: ChangesDelta, previousChangesDelta?: ChangesDelta): Promise<ChangesDelta | null>;
     private findBusinessLogicRuleInstance;
     private applyRules;
     private waitForRuleDependencies;

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

@@ -1,5 +1,6 @@
-import { ApiModuleFunctionResponse } from '@rentman/backend-types';
-import { GetAccountSettignsFn, HasFlagFn } from '../../types/ItemTypesCollection';
+import { ApiItemType, ApiModuleFunctionResponse, ResponseColumn } from '@rentman/backend-types';
+import { ItemEntry } from '../../models/ItemEntry';
+import { GetAccountSettignsFn, GetFieldValueType, HasFlagFn, ItemTypeColumnId } from '../../types/ItemTypesCollection';
 import { TransactionCache } from '../cache/transaction/TransactionCache';
 import { BusinessLogicRuleApplyContext } from './BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from './BusinessLogicRuleConditionContext';
@@ -23,6 +24,12 @@ export interface RuleDependencyResultTuple extends RuleConditionResultTuple {
 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.

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

@@ -1,9 +1,8 @@
 import { ApiItemType } from '@rentman/backend-types';
 import { ItemEntry } from '../../models/ItemEntry';
-import { FieldMap } from '../../types/ItemTypesCollection';
+import { FieldMap, GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
 import { TransactionCache } from '../cache/transaction/TransactionCache';
 import { ChangesDelta } from '../ChangesDelta';
-import { ParentChangesDelta } from '../ParentChangesDelta';
 import { BusinessLogicRuleContextBase } from './BusinessLogicRuleContextBase';
 /**
  * Class that represents the context for the business logic rule `apply()` function.
@@ -13,13 +12,21 @@ export declare class BusinessLogicRuleApplyContext extends BusinessLogicRuleCont
     /**
      * @param destinationChangesDelta - Changes should be written to this changes delta.
      */
-    constructor(transactionCache: TransactionCache, previousChangesDelta: ParentChangesDelta, destinationChangesDelta: ChangesDelta);
+    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

@@ -1,17 +1,29 @@
 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 { ParentChangesDelta } from '../ParentChangesDelta';
-import { BLR_SKIP_RULE } from './BusinessLogicRule';
+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 and previous changes delta are available on the
+ * 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 {
-    constructor(transaction: TransactionCache, previousChangesDelta: ParentChangesDelta);
+    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
@@ -20,7 +32,7 @@ export declare class BusinessLogicRuleConditionContext extends BusinessLogicRule
      * @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>, includeCreatedItems?: boolean): ItemId[] | typeof BLR_SKIP_RULE;
+    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.

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

@@ -1,7 +1,58 @@
-import { TransactionCache } from '../cache/transaction/TransactionCache';
-import { ParentChangesDelta } from '../ParentChangesDelta';
+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: ParentChangesDelta;
-    protected constructor(transaction: TransactionCache, previousChangesDelta: ParentChangesDelta);
+    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/Customfield/CustomFieldLinkedItemTypeBusinessLogicRule.d.ts

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const customfieldColumns: readonly ["defaultvalue"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Customfield', typeof customfieldColumns>[];
+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

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

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const customfieldColumns: readonly ["defaultvalue", "attributes", "type"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Customfield', typeof customfieldColumns>[];
+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

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

@@ -1,51 +1,30 @@
-import { ItemId } from '@rentman/backend-types';
+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';
-export declare const itemTypeFieldMap: {
-    readonly Offerte: {
-        readonly opdrachtgever: "contactpersoon";
-    };
-    readonly Contract: {
-        readonly opdrachtgever: "contactpersoon";
-    };
-    readonly Factuur: {
-        readonly opdrachtgever: "contactpersoon";
-    };
-    readonly Project: {
-        readonly opdrachtgever: "opdrachtgever_persoon";
-        readonly locatie: "locatie_persoon";
-    };
-    readonly Subproject: {
-        readonly locatie: "locatie_persoon";
-    };
-    readonly Inhuur: {
-        readonly locatie: "locatie_persoon";
-        readonly leverancier: "contactpersoon";
-    };
-    readonly ProjectRequest: {
-        readonly aanvrager: "accountmanager";
-    };
-};
-type ItemTypeFieldMap = typeof itemTypeFieldMap;
-type ItemTypeWithContactPerson = keyof ItemTypeFieldMap;
 type ConditionResult = {
-    [ItemTypeType in ItemTypeWithContactPerson]?: Map<ItemEntry<ItemTypeType>, {
-        [ColumnId in keyof ItemTypeFieldMap[ItemTypeType]]?: ItemId<'Contact'>;
+    [ItemTypeType in ApiItemType]?: Map<ItemEntry, {
+        [ColumnId in ItemTypeColumnId<ItemTypeType>]?: ItemId<'Contact'>;
     }>;
 };
-declare const constactColumns: readonly ["id", "contactpersoon"];
-type Dependency = ItemResource<'Contact', typeof constactColumns>[];
+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 contact person related to a
+ * 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, contactResources: Dependency, conditionResult: ConditionResult): void;
+    apply(context: BusinessLogicRuleApplyContext, dependencyResult: Dependency): void;
 }
 export {};

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

@@ -4,14 +4,13 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-export declare const documentTypes: readonly ["Factuur", "Offerte", "Contract", "Bon", "Inhuurbon", "Materiaalbon", "Medewerkerbon", "Aanmaning", "Reparatiebon", "Voertuigbon"];
+declare const documentTypes: readonly ["Factuur", "Offerte", "Contract", "Bon", "Inhuurbon", "Materiaalbon", "Medewerkerbon", "Aanmaning", "Reparatiebon", "Voertuigbon"];
 type DocumentTypes = (typeof documentTypes)[number];
-declare const documentColumns: readonly ["filename", "betreft"];
 type ConditionResult = {
     [key in DocumentTypes]?: ItemId[];
 };
 type Dependency = {
-    [key in DocumentTypes]?: ItemResource<DocumentTypes, typeof documentColumns>[];
+    [key in DocumentTypes]?: ItemResource<DocumentTypes, ['filename', 'betreft']>[];
 };
 export declare class DocumentTemplateBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;

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

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const exemplaarColumns: readonly ["actief"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Exemplaar', typeof exemplaarColumns>[];
+type Dependency = ItemResource<'Exemplaar', ['actief']>[];
 export declare class ExemplaarAanschafdatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;

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

@@ -1,26 +1,21 @@
 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 { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const factuurColumns: readonly ["vervaldatum", "datum", "betalingsconditie"];
-declare const betalingsconditieColumns: readonly ["id", "dagen"];
-type ConditionResult = ItemId<'Factuur'>[];
+import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
+type ConditionResult = BusinessLogicConditionResult<'Factuur', 'betalingsconditie'>[];
 type Dependency = {
-    Factuur: ItemResource<'Factuur', typeof factuurColumns>[];
+    Factuur: ItemResource<'Factuur', ['vervaldatum', 'datum']>[];
     Betalingsconditie: {
-        [conditieId: string]: ItemResource<'Betalingsconditie', typeof betalingsconditieColumns>;
+        [conditieId: string]: ItemResource<'Betalingsconditie', ['dagen']>;
     };
     defaultPaymentConditionId: ItemId | null;
 };
-/**
- * When setting the payment condition of an invoice, set the relevant due date.
- * TODO: Test this.
- */
 export declare class FactuurBetalingsconditieBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, result: ConditionResult): Promise<Dependency>;
+    dependency(transaction: TransactionCache, result: ConditionResult, context: BusinessLogicRuleContextBase): Promise<Dependency>;
     apply(context: BusinessLogicRuleApplyContext, deps: Dependency): void;
 }
 export {};

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

@@ -4,13 +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 factuurColumns: readonly ["id", "taxschema", "vervaldatum", "betalingsconditie", "datum"];
-declare const betalingsconditieColumns: readonly ["id", "dagen"];
+import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
 type ConditionResult = ItemId[];
 type Dependency = {
-    Factuur: ItemResource<'Factuur', typeof factuurColumns>[];
+    Factuur: ItemResource<'Factuur', ['vervaldatum', 'betalingsconditie']>[];
     Betalingsconditie: {
-        [conditieId: string]: ItemResource<'Betalingsconditie', typeof betalingsconditieColumns>;
+        [conditieId: string]: ItemResource<'Betalingsconditie', ['dagen']>;
     };
     latestTaxSchemasByDateMap: {
         [taxschemaId: string]: ItemId<'TaxSchema'>;
@@ -18,7 +17,7 @@ type Dependency = {
 };
 export declare class FactuurDatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult, context: BusinessLogicRuleContextBase): Promise<Dependency>;
     apply(context: BusinessLogicRuleApplyContext, deps: Dependency): void;
 }
 export {};

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

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const factuurColumns: readonly ["nummer"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Factuur', typeof factuurColumns>[];
+type Dependency = ItemResource<'Factuur', ['nummer']>[];
 export declare class FactuurNumberseriesBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;

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

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-type ConditionResult = ItemId<'Files'>[];
-declare const filesColumns: readonly ["name", "friendlyname"];
-type Dependency = ItemResource<'Files', typeof filesColumns>[];
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Files', ['name', 'friendlyname']>[];
 /**
  * @description
  * Automatically appends the file extension again when the user removes it from the name

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

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const functieColumns: readonly ["naamintern", "naamofferte"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Functie', typeof functieColumns>[];
+type Dependency = ItemResource<'Functie', ['naamintern']>[];
 /**
  * @description
  * If the `naamofferte` is set and the user hasn't filled in a `naamintern` we sync the fields

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

@@ -4,9 +4,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const functieColumns: readonly ["afstand", "twoway"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Functie', typeof functieColumns>[];
+type Dependency = ItemResource<'Functie', ['afstand']>[];
 export declare class FunctieTwowayBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;

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

@@ -1,6 +1,6 @@
 import { ItemResource } from '../../../models/ItemResource';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
-export declare const functieTravelDistanceColumns: readonly ["twoway", "afstand", "afstand_van_locatie", {
+export declare const functieTravelDistanceColumns: readonly ["twoway", {
     readonly subproject: readonly [{
         readonly locatie: readonly ["kilometers"];
     }];

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

@@ -1,16 +1,10 @@
-import { ItemId } from '@rentman/backend-types';
-import { ItemEntry } from '../../../models/ItemEntry';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const functieColumns: readonly ["subproject"];
-type ConditionResult = {
-    itemEntry: ItemEntry<'Functiegroep'>;
-    newValue: ItemId<'Subproject'>;
-}[];
-type Dependency = ItemResource<'Functie', typeof functieColumns>[][];
+type ConditionResult = BusinessLogicConditionResult<'Functiegroep', 'subproject'>[];
+type Dependency = ItemResource<'Functie', ['subproject']>[][];
 /**
  * When the subproject field of a function group is updated, set the subproject field of all the functions within the
  * function group to the same value.

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

@@ -1,15 +1,13 @@
 import { ItemId } from '@rentman/backend-types';
 import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, ItemEntry, ItemResource, TransactionCache } from '../../../internal';
-declare const materiaalColumns: readonly ["is_combination"];
-declare const containerContentColumns: readonly ["equipment"];
 export type ConditionResult = ItemId[];
 type Dependency = {
     voorraadmutatieTuples: {
         local: ItemEntry<'Voorraadmutatie'>[];
         remote: ItemEntry<'Voorraadmutatie'>[];
     };
-    materiaalResources: ItemResource<'Materiaal', typeof materiaalColumns>[];
-    containerContentResources: ItemResource<'ContainerContent', typeof containerContentColumns>[];
+    materiaalResources: ItemResource<'Materiaal', ['is_combination']>[];
+    containerContentResources: ItemResource<'ContainerContent', ['equipment']>[];
 };
 export declare class MateriaalBulkToSerialBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;

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

@@ -3,12 +3,10 @@ import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const materiaalColumns: readonly ["is_combination"];
-declare const containerContentColumns: readonly ["equipment"];
 type ConditionResult = ItemId[];
 type Dependency = {
-    materiaalResources: ItemResource<'Materiaal', typeof materiaalColumns>[];
-    containerContentResources: ItemResource<'ContainerContent', typeof containerContentColumns>[];
+    materiaalResources: ItemResource<'Materiaal', ['is_combination']>[];
+    containerContentResources: ItemResource<'ContainerContent', ['equipment']>[];
 };
 export declare class MateriaalSerialToBulkBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;

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

@@ -4,11 +4,11 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const materiaalColumns: readonly ["is_combination", "is_physical"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
+type Dependency = ItemResource<'Materiaal', ['type']>[];
 /**
  * @description
+ * A sales item can never be a case, so if it is we reset it to an item
  * A physical sales item can never be a combination, if it is we set it to a single item
  */
 export declare class MateriaalVerhuurBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {