@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/reducers/references/updateOptionMeta.ts

@@ -0,0 +1,73 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+
+/**
+ * Option meta update reducer
+ * @param action UPDATE_OPTION_META Action
+ */
+export const updateOptionMetaReducer = (
+  state: StateType.References,
+  action: ActionsType.References.updateOptionMeta
+): StateType.References => {
+  const { id, meta } = action;
+
+  /**
+   * Updating boxes
+   */
+  let boxes = {
+    ...state.boxes,
+  };
+  if (state.options[id]?.meta.type === 'box') {
+    const raw = meta.box?.content || '';
+    let variables: number[] = [];
+    if (raw.trim().length > 0) {
+      /**
+       * Variables
+       */
+      // Extracting list of variables
+      const tagsMatch = raw.match(/\[var:([0-9]+)\]/gi);
+      if (tagsMatch !== null) {
+        // Tranforming tags into integer ids
+        const variablesTags: string[] = [...tagsMatch];
+        variables = variablesTags.map((current) => {
+          const boxVariableMatch = current.match(/([0-9]+)/);
+          if (boxVariableMatch === null) return 0;
+          return parseInt(boxVariableMatch[0], 10);
+        });
+      }
+      // Cleaning variables
+      variables = variables.filter((c, i) => variables.indexOf(c) === i);
+    }
+
+    boxes = {
+      ...boxes,
+      [id]: {
+        raw,
+        variables,
+      },
+    };
+  }
+
+  return {
+    ...state,
+    boxes,
+    options: {
+      ...state.options,
+      [id]: {
+        ...state.options[id],
+        meta: {
+          ...state.options[id].meta,
+          ...meta,
+          validator: {
+            ...state.options[id].meta.validator,
+            ...meta.validator,
+          },
+          multiple: {
+            ...state.options[id].meta.multiple,
+            ...meta.multiple,
+          },
+        },
+      },
+    },
+  };
+};

package/src/redux/reducers/references/updateVariableMeta.ts

@@ -0,0 +1,72 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+
+/**
+ * Variable meta update reducer
+ * @param action UPDATE_OPTION_META Action
+ */
+export const updateVariableMetaReducer = (
+  state: StateType.References,
+  action: ActionsType.References.updateVariableMeta
+): StateType.References => {
+  const { id, meta } = action;
+
+  /**
+   * Updating evaluations
+   */
+  const evaluations = {
+    ...state.evaluations,
+  };
+  if (state.variables[id]?.type === 'eval') {
+    const formula = meta.eval?.formula || '';
+    let variables: number[] = [];
+    if (formula.trim().length > 0) {
+      /**
+       * Variables
+       */
+      // Extracting list of variables
+      const tagsMatch = formula.match(/\[var:([0-9]+)\]/gi);
+      if (tagsMatch !== null) {
+        // Tranforming tags into integer ids
+        const variablesTags: string[] = [...tagsMatch];
+        variables = variablesTags.map((current) => {
+          const boxVariableMatch = current.match(/([0-9]+)/);
+          if (boxVariableMatch === null) return 0;
+          return parseInt(boxVariableMatch[0], 10);
+        });
+      }
+      // Cleaning variables
+      variables = variables.filter((c, i) => variables.indexOf(c) === i);
+    }
+
+    // Cleaning evaluation from previous triggers
+    Object.keys(evaluations).forEach((hookedVariableId) => {
+      if (evaluations[hookedVariableId].includes(id)) {
+        evaluations[hookedVariableId].splice(
+          evaluations[hookedVariableId].indexOf(id),
+          1
+        );
+      }
+    });
+
+    // Adding new hooks
+    variables.forEach((newHookVariableId) => {
+      if (!Array.isArray(evaluations[newHookVariableId]))
+        evaluations[newHookVariableId] = [];
+
+      evaluations[newHookVariableId].push(id);
+    });
+  }
+
+  return {
+    ...state,
+    evaluations,
+    variables: {
+      ...state.variables,
+      [id]: {
+        ...state.variables[id],
+        ...meta,
+      },
+    },
+  };
+};

package/src/redux/reducers/references.ts

@@ -0,0 +1,59 @@
+import { StateType } from '../../types/State.type';
+import { initReferencesReducer } from './references/initReferences';
+import { updateOptionMetaReducer } from './references/updateOptionMeta';
+import { updateVariableMetaReducer } from './references/updateVariableMeta';
+import {
+  INIT_REFERENCES,
+  UPDATE_OPTION_META,
+  UPDATE_VARIABLE_META,
+} from '../constants/references';
+import { ReferencesActions } from '../../types/Actions.type';
+
+const initialState: StateType.References = {
+  options: {},
+  variables: {},
+  outputs: {},
+  boxes: {},
+  relations: {
+    options: {},
+    variables: {},
+    sections: {},
+  },
+  conditions: {
+    options: {},
+    variables: {},
+    prefillers: {},
+    validators: {
+      options: {},
+      variables: {},
+    },
+    sections: {},
+    documents: {},
+  },
+  documents: {},
+  sections: {},
+  defaults: {},
+  evaluations: {},
+};
+
+const reducersEnum: Record<
+  string,
+  (state: StateType.References, action: any) => StateType.References
+> = {
+  [INIT_REFERENCES]: initReferencesReducer,
+  [UPDATE_OPTION_META]: updateOptionMetaReducer,
+  [UPDATE_VARIABLE_META]: updateVariableMetaReducer,
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const referencesReducer = (
+  state: StateType.References = initialState,
+  action: ReferencesActions
+): StateType.References => {
+  const reducer = reducersEnum[action.type];
+
+  if (typeof reducer === 'function')
+    return reducer.apply(null, [state, action]);
+
+  return state;
+};

package/src/redux/reducers/smartscript/enableSmartScript.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../types/State.type';
+
+export const enableSmartScriptReducer = (
+  state: StateType.SmartScript
+): StateType.SmartScript => {
+  // Making sure smartscript isn't already enabled
+  if (state.enabled === true) return state;
+
+  return {
+    ...state,
+    enabled: true,
+  };
+};

package/src/redux/reducers/smartscript/initSmartScriptTriggers.ts

@@ -0,0 +1,14 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const initSmartscriptTriggersReducer = (
+  state: StateType.SmartScript,
+  action: ActionsType.SmartScript.initSmartscriptTriggers
+): StateType.SmartScript => {
+  const { triggers } = action;
+
+  return {
+    ...state,
+    triggers,
+  };
+};

package/src/redux/reducers/smartscript/updateSmartscriptOptionHidden.ts

@@ -0,0 +1,30 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updateSmartscriptOptionHiddenReducer = (
+  state: StateType.SmartScript,
+  action: ActionsType.SmartScript.updateSmartscriptOptionHidden
+): StateType.SmartScript => {
+  const { id, index, hide } = action;
+
+  const hiddenIndexes = Array.isArray(state.hidden.options[id])
+    ? [...state.hidden.options[id]]
+    : [];
+
+  if (hide === false && hiddenIndexes.includes(index)) {
+    hiddenIndexes.splice(hiddenIndexes.indexOf(index), 1);
+  } else if (hide === true && !hiddenIndexes.includes(index)) {
+    hiddenIndexes.push(index);
+  }
+
+  return {
+    ...state,
+    hidden: {
+      ...state.hidden,
+      options: {
+        ...state.hidden.options,
+        [id]: hiddenIndexes,
+      },
+    },
+  };
+};

package/src/redux/reducers/smartscript/updateSmartscriptVariableHidden.ts

@@ -0,0 +1,30 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updateSmartscriptVariableHiddenReducer = (
+  state: StateType.SmartScript,
+  action: ActionsType.SmartScript.updateSmartscriptVariableHidden
+): StateType.SmartScript => {
+  const { id, index, hide } = action;
+
+  const hiddenIndexes = Array.isArray(state.hidden.variables[id])
+    ? [...state.hidden.variables[id]]
+    : [];
+
+  if (hide === false && hiddenIndexes.includes(index)) {
+    hiddenIndexes.splice(hiddenIndexes.indexOf(index), 1);
+  } else if (hide === true && !hiddenIndexes.includes(index)) {
+    hiddenIndexes.push(index);
+  }
+
+  return {
+    ...state,
+    hidden: {
+      ...state.hidden,
+      variables: {
+        ...state.hidden.variables,
+        [id]: hiddenIndexes,
+      },
+    },
+  };
+};

package/src/redux/reducers/smartscript.ts

@@ -0,0 +1,47 @@
+import { StateType } from '../../types/State.type';
+import { SmartScriptActions } from '../../types/Actions.type';
+import {
+  ENABLE_SMARTSCRIPT,
+  INIT_SMARTSCRIPT_TRIGGERS,
+  UPDATE_SMARTSCRIPT_OPTION_HIDDEN,
+  UPDATE_SMARTSCRIPT_VARIABLE_HIDDEN,
+} from '../constants/smartscript';
+import { enableSmartScriptReducer } from './smartscript/enableSmartScript';
+import { initSmartscriptTriggersReducer } from './smartscript/initSmartScriptTriggers';
+import { updateSmartscriptOptionHiddenReducer } from './smartscript/updateSmartscriptOptionHidden';
+import { updateSmartscriptVariableHiddenReducer } from './smartscript/updateSmartscriptVariableHidden';
+
+const initialState: StateType.SmartScript = {
+  enabled: false,
+  triggers: {
+    options: [],
+    variables: [],
+  },
+  hidden: {
+    options: {},
+    variables: {},
+  },
+};
+
+const reducersEnum: Record<
+  string,
+  (state: StateType.SmartScript, action: any) => StateType.SmartScript
+> = {
+  [ENABLE_SMARTSCRIPT]: enableSmartScriptReducer,
+  [INIT_SMARTSCRIPT_TRIGGERS]: initSmartscriptTriggersReducer,
+  [UPDATE_SMARTSCRIPT_OPTION_HIDDEN]: updateSmartscriptOptionHiddenReducer,
+  [UPDATE_SMARTSCRIPT_VARIABLE_HIDDEN]: updateSmartscriptVariableHiddenReducer,
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const smartscriptReducer = (
+  state: StateType.SmartScript = initialState,
+  action: SmartScriptActions
+): StateType.SmartScript => {
+  const reducer = reducersEnum[action.type];
+
+  if (typeof reducer === 'function')
+    return reducer.apply(null, [state, action]);
+
+  return state;
+};

package/src/redux/reducers/user/initUser.ts

@@ -0,0 +1,15 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+
+export const initUserReducer = (
+  state: StateType.User,
+  action: ActionsType.User.initUser
+): StateType.User => {
+  const { email, displayName, level } = action;
+  return {
+    ...state,
+    email,
+    displayName,
+    level,
+  };
+};

package/src/redux/reducers/user/setUserStatus.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+
+export const setUserStatusReducer = (
+  state: StateType.User,
+  action: ActionsType.User.setUserStatus
+): StateType.User => {
+  const { status } = action;
+  return {
+    ...state,
+    status,
+  };
+};

package/src/redux/reducers/user/setUserValidToken.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+
+export const setUserValidTokenReducer = (
+  state: StateType.User,
+  action: ActionsType.User.setUserValidToken
+): StateType.User => {
+  const { validToken } = action;
+  return {
+    ...state,
+    validToken,
+  };
+};

package/src/redux/reducers/user.test.ts

@@ -0,0 +1,51 @@
+import { initUserReducer } from './user/initUser';
+import { userReducer } from './user';
+
+describe('User Reducer test suits', () => {
+  // initUserReducer reducer
+  it('initUserReducer Reducer', () => {
+    const reducer = initUserReducer(
+      {
+        status: 'unauthenticated',
+        level: 'GUEST',
+        displayName: '',
+        email: '',
+        validToken: false,
+      },
+      {
+        type: 'INIT_USER',
+        level: 'ADMIN',
+        displayName: 'John Doe',
+        email: 'doe@legalplace.fr',
+        validToken: false,
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      status: 'unauthenticated',
+      level: 'ADMIN',
+      displayName: 'John Doe',
+      email: 'doe@legalplace.fr',
+      validToken: false,
+    });
+  });
+
+  // user reducer
+  it('user Reducer INIT_USER Action', () => {
+    const reducer = userReducer(undefined, {
+      type: 'INIT_USER',
+      level: 'ADMIN',
+      displayName: 'John Doe',
+      email: 'doe@legalplace.fr',
+      validToken: false,
+    });
+
+    return expect(reducer).toStrictEqual({
+      status: 'unauthenticated',
+      level: 'ADMIN',
+      displayName: 'John Doe',
+      email: 'doe@legalplace.fr',
+      validToken: false,
+    });
+  });
+});

package/src/redux/reducers/user.ts

@@ -0,0 +1,40 @@
+import { setUserValidTokenReducer } from './user/setUserValidToken';
+import {
+  SET_USER_VALID_TOKEN,
+  INIT_USER,
+  SET_USER_STATUS,
+} from '../constants/user';
+import { UserActions } from '../../types/Actions.type';
+import { StateType } from '../../types/State.type';
+import { initUserReducer } from './user/initUser';
+import { setUserStatusReducer } from './user/setUserStatus';
+
+const initialState: StateType.User = {
+  status: 'unauthenticated',
+  email: '',
+  displayName: '',
+  level: 'GUEST',
+  validToken: false,
+};
+
+const reducersEnum: Record<
+  string,
+  (state: StateType.User, actions: any) => StateType.User
+> = {
+  [INIT_USER]: initUserReducer,
+  [SET_USER_STATUS]: setUserStatusReducer,
+  [SET_USER_VALID_TOKEN]: setUserValidTokenReducer,
+};
+
+export const userReducer = (
+  state = initialState,
+  action: UserActions
+): StateType.User => {
+  const reducer = reducersEnum[action.type];
+
+  if (typeof reducer === 'function') {
+    return reducer.apply(null, [state, action]);
+  }
+
+  return state;
+};

package/src/redux/routerHistore.test.ts

@@ -0,0 +1,19 @@
+import { createHistory, getHistory } from './routerHistory';
+
+describe('Router History', () => {
+  it('Thows an error when history is not initiated', () => {
+    expect(getHistory).toThrowError('History not yet created');
+  });
+
+  it('Creates and returns history', () => {
+    const history = createHistory('memory');
+
+    expect(history).toHaveProperty('location');
+  });
+
+  it('Returns history', () => {
+    createHistory('memory');
+    const history = getHistory();
+    expect(history).toHaveProperty('location');
+  });
+});

package/src/redux/routerHistory.ts

@@ -0,0 +1,21 @@
+import {
+  createMemoryHistory,
+  createBrowserHistory,
+  MemoryHistory,
+  History,
+} from 'history';
+
+let history: History<unknown> | MemoryHistory;
+
+export const createHistory = (historyType: 'memory' | 'browser') => {
+  // Creating history according to type
+  history =
+    historyType === 'memory' ? createMemoryHistory() : createBrowserHistory();
+  return history;
+};
+
+export const getHistory = () => {
+  if (typeof history === 'undefined')
+    throw new Error('History not yet created');
+  return history;
+};

package/src/redux/sagas/fetchModel.test.ts

@@ -0,0 +1,79 @@
+import * as fs from 'fs';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initInstanceAction } from '../actions/app';
+import { fetchModelPrerequisitesAction } from '../actions/sagas/model';
+
+const permalink = 'test-model';
+const uniqid = 'myMockUniqid';
+const mockApiEndpoint = 'https://api.mock/api/v1/';
+const model = JSON.parse(
+  fs.readFileSync('./src/misc/test_models/testmodel.json', 'utf8')
+);
+const meta = {
+  id: 123,
+  title: 'Test model',
+  permalink,
+};
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require('jest-fetch-mock').enableMocks();
+
+// Mocking config
+jest.mock('../../config', () => ({
+  getConfig: () => ({
+    apiEndpoint: mockApiEndpoint,
+    router: {
+      wizardPath: '/:permalink/questionnaire/:page([0-9]+|sommaire)',
+      wizardInstancePath:
+        '/:permalink/questionnaire/:uniqid([0-9a-zA-Z]+)/:page([0-9]+|sommaire)',
+    },
+    appStates: ['wizard'],
+  }),
+}));
+
+describe('Fetch model saga', () => {
+  let store: any;
+  beforeEach(() => {
+    createAppStore('memory');
+    store = getStore();
+    store.dispatch({
+      type: 'SET_DEFAULTS',
+    });
+
+    // Initiating Meta
+    store.dispatch(
+      initMetaAction({
+        id: 123,
+        title: 'Test model',
+        prefix: '',
+        permalink,
+        modelVersion: 1,
+        productType: 'demarche',
+      })
+    );
+
+    // Initiating Meta
+    store.dispatch(
+      initInstanceAction({
+        uniqid,
+        isPaid: false,
+        isOrderHandled: undefined,
+        dataStatus: 'saved',
+        steps: '*',
+      })
+    );
+
+    // Resetting fetch mocks
+    fetchMock.resetMocks();
+  });
+
+  it('Sends fetch client config request to API', () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ model, meta }));
+
+    store.dispatch(fetchModelPrerequisitesAction(permalink));
+    expect(fetchMock.mock.calls.length).toEqual(2);
+    expect(fetchMock.mock.calls[0][0]).toEqual(
+      `${mockApiEndpoint}client-config?permalink=${permalink}&disableOnBoarding=true`
+    );
+  });
+});