@rentman/rm-core 63.4.1 → 64.0.0

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

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

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

@@ -1,19 +1,20 @@
 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, LatestItem } from './BusinessLogicRuleContextBase';
+import { BusinessLogicRuleContextBase } 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>;
+type PlannedEquipmentItem<ItemTypeType extends PlannedEquipmentItemType> = {
+    Planningmateriaal: ItemResource<'Planningmateriaal', typeof commonEquipmentColumns>;
+    Inhuurmateriaal: ItemResource<'Inhuurmateriaal', typeof commonEquipmentColumns>;
 }[ItemTypeType];
-type LatestEquipmentItemIdMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId, LatestEquipmentItem<ItemTypeType>>;
-type LatestEquipmentItemParentMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId | null, LatestEquipmentItem<ItemTypeType>[]>;
+type PlannedEquipmentItemIdMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId, PlannedEquipmentItem<ItemTypeType>>;
+type PlannedEquipmentItemParentMap<ItemTypeType extends PlannedEquipmentItemType> = Map<ItemId | null, PlannedEquipmentItem<ItemTypeType>[]>;
 type EquipmentIsPhysicalMap = Map<ItemId<'Materiaal'> | null, boolean>;
 interface Dependency<ItemTypeType extends PlannedEquipmentItemType> {
     /**
@@ -26,8 +27,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: LatestEquipmentItemParentMap<ItemTypeType>;
-    affectedEquipmentItemsById: LatestEquipmentItemIdMap<ItemTypeType>;
+    affectedEquipmentItemsByParent: PlannedEquipmentItemParentMap<ItemTypeType>;
+    affectedEquipmentItemsById: PlannedEquipmentItemIdMap<ItemTypeType>;
     equipmentIsPhysicalMap: EquipmentIsPhysicalMap;
 }
 /**
@@ -35,7 +36,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<LatestEquipmentItem<ItemTypeType>[], Dependency<ItemTypeType>> {
+export declare abstract class AantaltotaalBusinessLogicRuleBase<ItemTypeType extends PlannedEquipmentItemType> extends BusinessLogicRule<ItemId<ItemTypeType>[], Dependency<ItemTypeType>> {
     protected abstract readonly itemType: ItemTypeType;
     protected abstract readonly groupingProperties: {
         Planningmateriaal: {
@@ -51,8 +52,8 @@ export declare abstract class AantaltotaalBusinessLogicRuleBase<ItemTypeType ext
         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>>;
+    condition(context: BusinessLogicRuleConditionContext): ItemId<ItemTypeType>[] | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, affectedEquipmentItemIds: ItemId<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,15 +50,14 @@ 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 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.
+     * @param businessLogicTransaction The transaction the ChangesDelta will be applied on.
+     * @param changesDelta - A changes delta containing source changes.
      *
-     * @private should only be called by the core
+     * @returns A child transaction where the business logic has been applied.
+     *
+     * @private Should only be called by the core.
      */
-    handleBusinessLogic(transaction: TransactionCache, mergedChangesDelta: ChangesDelta, previousChangesDelta?: ChangesDelta): Promise<ChangesDelta | null>;
+    handleBusinessLogic(transaction: TransactionCache, changesDelta: ChangesDelta): Promise<TransactionCache | null>;
     private findBusinessLogicRuleInstance;
     private applyRules;
     private waitForRuleDependencies;

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

@@ -1,6 +1,5 @@
-import { ApiItemType, ApiModuleFunctionResponse, ResponseColumn } from '@rentman/backend-types';
-import { ItemEntry } from '../../models/ItemEntry';
-import { GetAccountSettignsFn, GetFieldValueType, HasFlagFn, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { ApiModuleFunctionResponse } from '@rentman/backend-types';
+import { GetAccountSettignsFn, HasFlagFn } from '../../types/ItemTypesCollection';
 import { TransactionCache } from '../cache/transaction/TransactionCache';
 import { BusinessLogicRuleApplyContext } from './BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from './BusinessLogicRuleConditionContext';
@@ -24,12 +23,6 @@ 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,8 +1,9 @@
 import { ApiItemType } from '@rentman/backend-types';
 import { ItemEntry } from '../../models/ItemEntry';
-import { FieldMap, GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { FieldMap } 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.
@@ -12,21 +13,13 @@ export declare class BusinessLogicRuleApplyContext extends BusinessLogicRuleCont
     /**
      * @param destinationChangesDelta - Changes should be written to this changes delta.
      */
-    constructor(transactionCache: TransactionCache, previousChangesDelta: ChangesDelta, mergedChangesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta);
+    constructor(transactionCache: TransactionCache, previousChangesDelta: ParentChangesDelta, 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,29 +1,17 @@
 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 { ParentChangesDelta } from '../ParentChangesDelta';
+import { BLR_SKIP_RULE } 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
+ * Please note that, while the transaction 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>;
+    constructor(transaction: TransactionCache, previousChangesDelta: ParentChangesDelta);
     /**
      * 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
@@ -32,7 +20,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>): ItemId[] | typeof BLR_SKIP_RULE;
+    getItemIdsWithUpdatedField<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, columnId: ItemTypeColumnId<ItemTypeType>, includeCreatedItems?: boolean): 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,58 +1,7 @@
-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>;
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { ParentChangesDelta } from '../ParentChangesDelta';
 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;
+    readonly previousChangesDelta: ParentChangesDelta;
+    protected constructor(transaction: TransactionCache, previousChangesDelta: ParentChangesDelta);
 }

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

@@ -4,8 +4,9 @@ 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', ['defaultvalue']>[];
+type Dependency = ItemResource<'Customfield', typeof customfieldColumns>[];
 /**
  * @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,8 +4,9 @@ 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', ['defaultvalue', 'attributes', 'type']>[];
+type Dependency = ItemResource<'Customfield', typeof customfieldColumns>[];
 /**
  * @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,30 +1,51 @@
-import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { 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 ApiItemType]?: Map<ItemEntry, {
-        [ColumnId in ItemTypeColumnId<ItemTypeType>]?: ItemId<'Contact'>;
+    [ItemTypeType in ItemTypeWithContactPerson]?: Map<ItemEntry<ItemTypeType>, {
+        [ColumnId in keyof ItemTypeFieldMap[ItemTypeType]]?: ItemId<'Contact'>;
     }>;
 };
-declare const dependencyColumns: readonly ["id", "contactpersoon"];
-type Dependency = {
-    conditionResult: ConditionResult;
-    contactMap: {
-        [contactId: string]: ItemResource<'Contact', typeof dependencyColumns>;
-    };
-};
+declare const constactColumns: readonly ["id", "contactpersoon"];
+type Dependency = ItemResource<'Contact', typeof constactColumns>[];
 /**
- * This business rule is responsible for setting the default contactperson related to a
+ * This business rule is responsible for setting the default contact person 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;
+    apply(context: BusinessLogicRuleApplyContext, contactResources: Dependency, conditionResult: ConditionResult): void;
 }
 export {};

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

@@ -4,13 +4,14 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const documentTypes: readonly ["Factuur", "Offerte", "Contract", "Bon", "Inhuurbon", "Materiaalbon", "Medewerkerbon", "Aanmaning", "Reparatiebon", "Voertuigbon"];
+export 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, ['filename', 'betreft']>[];
+    [key in DocumentTypes]?: ItemResource<DocumentTypes, typeof documentColumns>[];
 };
 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,8 +4,9 @@ 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', ['actief']>[];
+type Dependency = ItemResource<'Exemplaar', typeof exemplaarColumns>[];
 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,21 +1,26 @@
 import { ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
-type ConditionResult = BusinessLogicConditionResult<'Factuur', 'betalingsconditie'>[];
+declare const factuurColumns: readonly ["vervaldatum", "datum", "betalingsconditie"];
+declare const betalingsconditieColumns: readonly ["id", "dagen"];
+type ConditionResult = ItemId<'Factuur'>[];
 type Dependency = {
-    Factuur: ItemResource<'Factuur', ['vervaldatum', 'datum']>[];
+    Factuur: ItemResource<'Factuur', typeof factuurColumns>[];
     Betalingsconditie: {
-        [conditieId: string]: ItemResource<'Betalingsconditie', ['dagen']>;
+        [conditieId: string]: ItemResource<'Betalingsconditie', typeof betalingsconditieColumns>;
     };
     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, context: BusinessLogicRuleContextBase): Promise<Dependency>;
+    dependency(transaction: TransactionCache, result: ConditionResult): Promise<Dependency>;
     apply(context: BusinessLogicRuleApplyContext, deps: Dependency): void;
 }
 export {};

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

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

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

@@ -4,8 +4,9 @@ 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', ['nummer']>[];
+type Dependency = ItemResource<'Factuur', typeof factuurColumns>[];
 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,8 +4,9 @@ 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<'Files', ['name', 'friendlyname']>[];
+type ConditionResult = ItemId<'Files'>[];
+declare const filesColumns: readonly ["name", "friendlyname"];
+type Dependency = ItemResource<'Files', typeof filesColumns>[];
 /**
  * @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,8 +4,9 @@ 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', ['naamintern']>[];
+type Dependency = ItemResource<'Functie', typeof functieColumns>[];
 /**
  * @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,8 +4,9 @@ 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', ['afstand']>[];
+type Dependency = ItemResource<'Functie', typeof functieColumns>[];
 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", {
+export declare const functieTravelDistanceColumns: readonly ["twoway", "afstand", "afstand_van_locatie", {
     readonly subproject: readonly [{
         readonly locatie: readonly ["kilometers"];
     }];

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

@@ -1,10 +1,16 @@
+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, BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-type ConditionResult = BusinessLogicConditionResult<'Functiegroep', 'subproject'>[];
-type Dependency = ItemResource<'Functie', ['subproject']>[][];
+declare const functieColumns: readonly ["subproject"];
+type ConditionResult = {
+    itemEntry: ItemEntry<'Functiegroep'>;
+    newValue: ItemId<'Subproject'>;
+}[];
+type Dependency = ItemResource<'Functie', typeof functieColumns>[][];
 /**
  * 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,13 +1,15 @@
 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', ['is_combination']>[];
-    containerContentResources: ItemResource<'ContainerContent', ['equipment']>[];
+    materiaalResources: ItemResource<'Materiaal', typeof materiaalColumns>[];
+    containerContentResources: ItemResource<'ContainerContent', typeof containerContentColumns>[];
 };
 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,10 +3,12 @@ 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', ['is_combination']>[];
-    containerContentResources: ItemResource<'ContainerContent', ['equipment']>[];
+    materiaalResources: ItemResource<'Materiaal', typeof materiaalColumns>[];
+    containerContentResources: ItemResource<'ContainerContent', typeof containerContentColumns>[];
 };
 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', ['type']>[];
+type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
 /**
  * @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> {