@legalplace/wizardx-core 2.6.3 → 2.7.0

package/src/redux/middlewares/evaluationsWatcherMiddleware.test.ts

@@ -1,323 +0,0 @@
-import evaluationsWatcherMiddleware from './evaluationsWatcherMiddleware';
-import { updateVariableAction, updateOptionAction } from '../actions/inputs';
-import { StateType } from '../../types/State.type';
-import { fetchModelSucceededAction } from '../actions/app';
-import {
-  updateOptionConditionsAction,
-  updateVariableConditionsAction,
-} from '../actions/conditions';
-
-let mockState: {
-  inputs: StateType.Inputs;
-  references: {
-    variables: StateType.References.Variables;
-    relations: {
-      options: StateType.References.Relations['options'];
-    };
-    evaluations: StateType.References['evaluations'];
-  };
-} = {
-  inputs: {
-    variables: {
-      4: [32],
-      5: [67],
-      6: [''],
-      7: [22],
-    },
-    options: {
-      10: [false],
-    },
-  },
-  references: {
-    variables: {
-      '6': {
-        id: 6,
-        label: 'A+B',
-        type: 'eval',
-        placeholderLength: 16,
-        step: '*',
-        eval: {
-          formula: '[var:4]+[var:5]+[var:7]',
-          decimals: 0,
-        },
-      },
-      '8': {
-        id: 8,
-        label: 'TODAY',
-        type: 'eval',
-        placeholderLength: 16,
-        step: '*',
-        eval: {
-          formula: 'AFFICHER_DATE(TODAY())',
-          decimals: 0,
-        },
-      },
-    },
-    relations: {
-      options: {
-        '4': {
-          options: [7, 8],
-          variables: [2],
-          sections: {},
-          documents: [],
-          prefillers: [3],
-          validators: {
-            options: [],
-            variables: [],
-          },
-          parents: [2],
-          children: {
-            options: [],
-            variables: [],
-          },
-          dependants: [],
-          radioSiblings: [3],
-        },
-        '8': {
-          options: [],
-          variables: [],
-          sections: {},
-          documents: [],
-          prefillers: [],
-          validators: {
-            options: [],
-            variables: [],
-          },
-          parents: [6],
-          children: {
-            options: [],
-            variables: [],
-          },
-          dependants: [],
-        },
-        '10': {
-          options: [],
-          variables: [],
-          sections: {},
-          documents: [],
-          prefillers: [],
-          validators: {
-            options: [],
-            variables: [],
-          },
-          parents: [9],
-          children: {
-            options: [],
-            variables: [7],
-          },
-          dependants: [],
-          radioSiblings: [11],
-        },
-        '11': {
-          options: [],
-          variables: [],
-          sections: {},
-          documents: [],
-          prefillers: [],
-          validators: {
-            options: [],
-            variables: [],
-          },
-          parents: [9],
-          children: {
-            options: [],
-            variables: [],
-          },
-          dependants: [],
-          radioSiblings: [10],
-        },
-      },
-    },
-    evaluations: {
-      4: [6],
-      5: [6],
-      7: [6],
-    },
-  },
-};
-const originalState = JSON.stringify(mockState);
-
-// Mocking MPI
-const mpi = {
-  dispatch: jest.fn(),
-  getState: () => mockState,
-};
-
-// Mocking Next
-const next = jest.fn();
-
-// Mocking reference selecteor
-// ../selectors/references.ts
-jest.mock('../selectors/references', () => ({
-  __esModule: true,
-  selectVariableReference: (id: number) => mockState.references.variables[id],
-  selectOptionRelations: (id: number) =>
-    mockState.references.relations.options[id],
-}));
-
-// Mocking reference selecteor
-// ../../libs/EvalVariable.ts
-jest.mock('../../libs/EvalVariable', () => {
-  class EvalVariable {
-    result: string | number;
-
-    constructor(ref: any, index: any) {
-      if (ref.id === 8 && ref.eval?.formula === 'AFFICHER_DATE(TODAY())')
-        this.result = '01/01/1976';
-      else if (ref.id === 6 && mockState.inputs.options[10][index] === true)
-        this.result =
-          // @ts-ignore: Done on purpose
-          mockState.inputs.variables[4][index] +
-          mockState.inputs.variables[5][index] +
-          mockState.inputs.variables[7][index];
-      else if (ref.id === 6 && mockState.inputs.options[10][index] === false)
-        this.result =
-          // @ts-ignore: Done on purpose
-          mockState.inputs.variables[4][index] +
-          mockState.inputs.variables[5][index];
-      else this.result = 'UNDEFINED RESULT PLEASE CHECK MOCK';
-    }
-  }
-  return {
-    __esModule: true,
-    EvalVariable,
-  };
-});
-
-describe('Prefillers Watcher Middleware Test suit', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockState = JSON.parse(originalState);
-  });
-
-  it('Completes FETCH_MODEL_SUCCEEDED action correctly', () => {
-    // Running watcher
-    evaluationsWatcherMiddleware(mpi)(next)(fetchModelSucceededAction());
-
-    // Must recalculate all evals
-    expect(mpi.dispatch.mock.calls.length).toBe(2);
-    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 6,
-      index: 0,
-      value: 99,
-    });
-    expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 8,
-      index: 0,
-      value: '01/01/1976',
-    });
-  });
-
-  it('Completes UPDATE_VARIABLE_INPUT action correctly', () => {
-    // Running watcher
-    evaluationsWatcherMiddleware(mpi)(next)(updateVariableAction(4, 3, 0));
-
-    expect(mpi.dispatch.mock.calls.length).toBe(1);
-    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 6,
-      index: 0,
-      value: 99,
-    })
-  });
-
-  it('Completes UPDATE_OPTION_INPUT action correctly', () => {
-    mockState.inputs.options[10][0] = true;
-
-    // Running watcher
-    evaluationsWatcherMiddleware(mpi)(next)(updateOptionAction(10, true, 0));
-
-    expect(mpi.dispatch.mock.calls.length).toBe(1);
-    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 6,
-      index: 0,
-      value: 121,
-    });
-  });
-
-  it('Completes UPDATE_OPTION_CONDITION action correctly', () => {
-    // Real condition updating is tested in EvalVariable library
-    // Here we assume that the system works perfectly so we just
-    // put 10 to true
-
-    mockState.inputs.options[10][0] = true;
-
-    // Running watcher
-    evaluationsWatcherMiddleware(mpi)(next)(
-      updateOptionConditionsAction(10, 0, true)
-    );
-
-    expect(mpi.dispatch.mock.calls.length).toBe(1);
-    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 6,
-      index: 0,
-      value: 121,
-    });
-  });
-
-  it('Completes UPDATE_OPTION_CONDITION action correctly', () => {
-    // Real condition updating is tested in EvalVariable library
-    // Here we assume that the system works perfectly so we just
-    // put 10 to false
-
-    mockState.inputs.options[10][0] = false;
-
-    // Running watcher
-    evaluationsWatcherMiddleware(mpi)(next)(
-      updateOptionConditionsAction(10, 0, true)
-    );
-
-    expect(mpi.dispatch.mock.calls.length).toBe(1);
-    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 6,
-      index: 0,
-      value: 99,
-    });
-  });
-
-  it('Completes UPDATE_VARIABLE_CONDITION action correctly', () => {
-    // Real condition updating is tested in EvalVariable library
-    // Here we assume that the system works perfectly so we just
-    // put 10 to false
-
-    mockState.inputs.options[10][0] = true;
-
-    // Running watcher
-    evaluationsWatcherMiddleware(mpi)(next)(
-      updateVariableConditionsAction(7, 0, true)
-    );
-
-    expect(mpi.dispatch.mock.calls.length).toBe(1);
-    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
-      type: 'UPDATE_VARIABLE_INPUT',
-      id: 6,
-      index: 0,
-      value: 121,
-    });
-  });
-
-  it('Throws an error on UPDATE_VARIABLE_INPUT action if variable is undefined', () => {
-    // @ts-ignore: Done on puprose
-    mockState.references.variables[6] = undefined;
-
-    // Running watcher
-    expect(() =>
-      evaluationsWatcherMiddleware(mpi)(next)(updateVariableAction(4, 3, 0))
-    ).toThrowError('Variable 6 does not exist');
-  });
-
-  it('Throws an error on UPDATE_OPTION_INPUT action if variable is undefined', () => {
-    // @ts-ignore: Done on purpose
-    mockState.references.variables[6] = undefined;
-
-    // Running watcher
-    expect(() =>
-      evaluationsWatcherMiddleware(mpi)(next)(updateOptionAction(10, true, 0))
-    ).toThrowError('Variable 6 does not exist');
-  });
-});

package/src/redux/middlewares/evaluationsWatcherMiddleware.ts

@@ -1,250 +0,0 @@
-/* eslint-disable max-len */
-import { MiddlewareAPI, Dispatch } from "redux";
-import { ActionsType } from "../../types/Actions.type";
-import {
-  selectVariableReference,
-  selectOptionRelations,
-} from "../selectors/references";
-import { updateVariableAction } from "../actions/inputs";
-import {
-  UPDATE_VARIABLE_INPUT,
-  UPDATE_OPTION_INPUT,
-} from "../constants/inputs";
-import { StateType } from "../../types/State.type";
-import {
-  UPDATE_VARIABLE_CONDITION,
-  UPDATE_OPTION_CONDITION,
-  UPDATE_SECTION_CONDITION,
-} from "../constants/conditions";
-import { FETCH_MODEL_SUCCEEDED } from "../constants/app";
-import { EvalVariable } from "../../libs/EvalVariable";
-
-/**
- * Watching UPDATE_VARIABLE_INPUT action
- * @param mpi MiddlewareAPI
- * @param next Dispatch function
- * @param action Actions
- */
-export const watchUpdateVariable = (
-  mpi: MiddlewareAPI<Dispatch, StateType>,
-  next: Dispatch,
-  action:
-    | ActionsType.Inputs.updateVariableInput
-    | ActionsType.Conditions.updateVariableCondition
-) => {
-  const result = next(action);
-
-  // Checking if variable is hooked to an eval
-  const state: StateType = mpi.getState();
-  if (
-    Object.prototype.hasOwnProperty.call(
-      state.references.evaluations,
-      action.id
-    )
-  ) {
-    // Executing evaluations
-    const variables = state.references.evaluations[action.id];
-
-    variables.forEach((variableId) => {
-      // Evaluation operations
-      state.inputs.variables[variableId].forEach((oldValue, index) => {
-        const variableReference = selectVariableReference(variableId);
-        if (variableReference === undefined)
-          throw new Error(`Variable ${variableId} does not exist`);
-
-        const varEval = new EvalVariable(variableReference, index);
-        const newValue = varEval.result;
-        if (newValue === null) return;
-        if (newValue !== oldValue)
-          mpi.dispatch(updateVariableAction(variableId, newValue, index));
-      });
-    });
-  }
-
-  return result;
-};
-
-/**
- * Watching UPDATE_OPTION_INPUT action
- * @param mpi MiddlewareAPI
- * @param next Dispatch function
- * @param action Actions
- */
-const watchUpdateOption = (
-  mpi: MiddlewareAPI<Dispatch, StateType>,
-  next: Dispatch,
-  action:
-    | ActionsType.Inputs.updateOptionInput
-    | ActionsType.Conditions.updateOptionCondition
-) => {
-  const result = next(action);
-
-  // Checking if variable is hooked to an eval
-  const state: StateType = mpi.getState();
-
-  // Calculating union between option's variable children &
-  // eval variables
-  const evalVariablesIds = Object.keys(state.references.evaluations).map((i) =>
-    parseInt(i, 10)
-  );
-  const optionVariableChildren = selectOptionRelations(action.id).children
-    .variables;
-
-  // Union
-  const impactedVariables = optionVariableChildren.filter((i) =>
-    evalVariablesIds.includes(i)
-  );
-
-  impactedVariables.forEach((id) => {
-    // Executing evaluations
-    const variables = state.references.evaluations[id];
-
-    variables.forEach((variableId) => {
-      // Evaluation operations
-      state.inputs.variables[variableId].forEach((oldValue, index) => {
-        const variableReference = selectVariableReference(variableId);
-        if (variableReference === undefined)
-          throw new Error(`Variable ${variableId} does not exist`);
-
-        const varEval = new EvalVariable(variableReference, index);
-        const newValue = varEval.result;
-        if (newValue === null) return;
-        if (newValue !== oldValue)
-          mpi.dispatch(updateVariableAction(variableId, newValue, index));
-      });
-    });
-  });
-
-  return result;
-};
-
-/**
- * Watching UPDATE_SECTION action
- * @param mpi MiddlewareAPI
- * @param next Dispatch function
- * @param action Actions
- */
-const watchUpdateSection = (
-  mpi: MiddlewareAPI<Dispatch, StateType>,
-  next: Dispatch,
-  action: ActionsType.Conditions.updateSectionCondition
-) => {
-  const result = next(action);
-
-  // Checking if variable is hooked to an eval
-  const state: StateType = mpi.getState();
-
-  // Getting child options
-  if (state.references.sections.main[action.id])
-    state.references.sections.main[action.id].options.forEach((optionId) => {
-      // Calculating union between option's variable children &
-      // eval variables
-      const evalVariablesIds = Object.keys(state.references.evaluations).map(
-        (i) => parseInt(i, 10)
-      );
-      const optionVariableChildren =
-        selectOptionRelations(optionId).children.variables;
-
-      // Union
-      const impactedVariables = optionVariableChildren.filter((i) =>
-        evalVariablesIds.includes(i)
-      );
-
-      impactedVariables.forEach((id) => {
-        // Executing evaluations
-        const variables = state.references.evaluations[id];
-
-        variables.forEach((variableId) => {
-          // Evaluation operations
-          state.inputs.variables[variableId].forEach((oldValue, index) => {
-            const variableReference = selectVariableReference(variableId);
-            if (variableReference === undefined)
-              throw new Error(`Variable ${variableId} does not exist`);
-
-            const varEval = new EvalVariable(variableReference, index);
-            const newValue = varEval.result;
-            if (newValue === null) return;
-            if (newValue !== oldValue)
-              mpi.dispatch(updateVariableAction(variableId, newValue, index));
-          });
-        });
-      });
-
-      return result;
-    });
-};
-
-/**
- * Watching MODEL_FETCH_SUCCEEDED action
- * @param mpi MiddlewareAPI
- * @param next Dispatch function
- * @param action Actions
- */
-const watchFetchModelSuceeded = (
-  mpi: MiddlewareAPI<Dispatch, StateType>,
-  next: Dispatch,
-  action: ActionsType.App.fetchModelSucceeded
-) => {
-  const result = next(action);
-
-  // Checking if variable is hooked to an eval
-  const state: StateType = mpi.getState();
-
-  // Executing eval undependant eval variables on init
-  Object.keys(state.references.variables).forEach((variableId) => {
-    const variableReference = state.references.variables[variableId];
-    const variableInput = state.inputs.variables[variableId] || [""];
-    if (
-      variableReference.type === "eval" &&
-      typeof variableReference.eval?.formula === "string" &&
-      variableReference.eval?.formula.length > 0
-    ) {
-      variableInput.forEach((oldValue, index) => {
-        const varEval = new EvalVariable(variableReference, index);
-        const newValue = varEval.result;
-        if (newValue === null) return;
-        mpi.dispatch(
-          updateVariableAction(parseInt(variableId, 10), newValue, index)
-        );
-      });
-    }
-  });
-
-  return result;
-};
-
-export type WatcherActions =
-  | ActionsType.Conditions.updateVariableCondition
-  | ActionsType.Conditions.updateOptionCondition
-  | ActionsType.Inputs.updateOptionInput
-  | ActionsType.Inputs.updateVariableInput
-  | ActionsType.App.fetchModelSucceeded;
-
-// Enumerating watchers
-const watchersEnum: Record<
-  string,
-  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
-> = {
-  [UPDATE_VARIABLE_INPUT]: watchUpdateVariable,
-  [UPDATE_VARIABLE_CONDITION]: watchUpdateVariable,
-  [UPDATE_OPTION_INPUT]: watchUpdateOption,
-  [UPDATE_OPTION_CONDITION]: watchUpdateOption,
-  [UPDATE_SECTION_CONDITION]: watchUpdateSection,
-  [FETCH_MODEL_SUCCEEDED]: watchFetchModelSuceeded,
-};
-
-/**
- * Evaluations Watcher Middleware
- * @param mpi MiddlewareAPI
- * @param next Dispatch function
- * @param action Actions
- */
-const evaluationsWatcherMiddleware =
-  (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => {
-    if (Object.prototype.hasOwnProperty.call(watchersEnum, action.type)) {
-      return watchersEnum[action.type].apply(null, [mpi, next, action]);
-    }
-    return next(action);
-  };
-
-export default evaluationsWatcherMiddleware;