@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/selectors/references.ts

@@ -0,0 +1,410 @@
+import { StateType } from '../../types/State.type';
+import { createSelector } from './selectors';
+
+/**
+ * Warning:
+ * All hashKeys for selectors here return static id (they never change)
+ * this is because references never change, so it is useless to purge
+ * memoization for them
+ */
+
+/**
+ * Returns output's reference
+ * @param id Option's id
+ */
+// eslint-disable-next-line max-len
+export const selectOutputReference = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.outputs[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/**
+ * Returns output's reference
+ * @param id Option's id
+ */
+// eslint-disable-next-line max-len
+export const selectBoxReference = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.boxes[id] === undefined)
+      throw new Error(`Box ${id} does not exist`);
+    return state.references.boxes[id];
+  },
+  () => Math.random()
+);
+
+/*
+ * |---------------------------------|
+ * |       Options Selectors         |
+ * |---------------------------------|
+ */
+
+/**
+ * Returns whether the option is multiple or not
+ * @param id Option's id
+ */
+export const isOptionMultiple = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.options[id].meta.multiple?.enabled === true;
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/**
+ * Returns option's reference
+ * @param id Option's id
+ */
+// eslint-disable-next-line max-len
+export const selectOptionReference = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.options[id] === undefined)
+      throw new Error(`Option ${id} does not exist`);
+
+    return state.references.options[id];
+  },
+  () => Math.random()
+);
+
+/**
+ * Returns Option's relations
+ * @param id Option's id
+ */
+// eslint-disable-next-line max-len
+export const selectOptionRelations = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.relations.options[id] === undefined)
+      throw new Error(`Option ${id} relations do not exist`);
+    return state.references.relations.options[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/**
+ * Returns Section's relations
+ * @param id Section's id
+ */
+// eslint-disable-next-line max-len
+export const selectSectionRelations = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.relations.sections[id] === undefined)
+      throw new Error(`Section ${id} relations do not exist`);
+    return state.references.relations.sections[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/**
+ * Returns Option's parents
+ * @param id Option's id
+ */
+export const selectOptionParents = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.relations.options[id].parents === undefined)
+      throw new Error(`Option ${id} parent relations are undefined`);
+
+    return state.references.relations.options[id].parents;
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/**
+ * Returns Option's siblings for radio options
+ * @param id Option's id
+ */
+export const selectRadioSiblings = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.relations.options[id] === undefined)
+      throw new Error(`Option ${id} relations do not exist`);
+    const { radioSiblings } = state.references.relations.options[id];
+    return radioSiblings;
+  },
+  (state, id) => (!state.references ? Math.random() : id)
+);
+
+/*
+ * |---------------------------------|
+ * |     Variables Selectors         |
+ * |---------------------------------|
+ */
+// eslint-disable-next-line max-len
+export const selectVariableReference = createSelector(
+  (state: StateType, id: number, noThrow = false) => {
+    if (state.references.variables[id] === undefined && noThrow === false)
+      throw new Error(`Variable ${id} does not exist`);
+    return state.references.variables[id];
+  },
+  () => Math.random()
+);
+
+export const selectVariableRelations = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.relations.variables[id] === undefined)
+      throw new Error(`Variable ${id} relations do not exist`);
+    return state.references.relations.variables[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+export const selectVariableParents = createSelector(
+  (state: StateType, id: number) => {
+    if (state.references.relations.variables[id] === undefined)
+      throw new Error(`Variable ${id} parents relations is undefined`);
+    return state.references.relations.variables[id].parents;
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/*
+ * |---------------------------------|
+ * |      Documents Selectors        |
+ * |---------------------------------|
+ */
+export const selectAllDocumentsReferences = createSelector(
+  (state: StateType) => {
+    if (state.references.documents === undefined)
+      throw new Error(`Documents references do not exist`);
+    return state.references.documents;
+  },
+  (state: StateType) => (!state.references ? Math.random() : 1)
+);
+
+export const selectDocumentReference = createSelector(
+  (state: StateType, document: string) => {
+    if (state.references.documents === undefined)
+      throw new Error(`Documents references do not exist`);
+    return state.references.documents[document];
+  },
+  (state: StateType) => (!state.references ? Math.random() : 1)
+);
+
+/*
+ * |---------------------------------|
+ * |      Sections Selectors         |
+ * |---------------------------------|
+ */
+export const selectAllSectionsReferences = createSelector(
+  (state: StateType, document = 'main') => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.sections[document];
+  },
+  (state: StateType, document = 'main') =>
+    !state.references ? Math.random() : document
+);
+
+/**
+ * Return section's reference
+ * @param id Section's id
+ */
+// eslint-disable-next-line max-len
+export const selectSectionReference = createSelector(
+  (state: StateType, id: number, document = 'main') => {
+    if (state.references.sections[document] === undefined)
+      throw new Error(`Document ${document} does not exist`);
+    if (state.references.sections[document][id] === undefined) {
+      throw new Error(`Section ${id} does not exist in document ${document}`);
+    }
+    return state.references.sections[document][id];
+  },
+  (state: StateType, id: number, document = 'main') =>
+    !state.references ? Math.random() : `${id}-${document}`
+);
+
+/**
+ * Sections defaults Selectors
+ */
+export const selectSectionDefaults = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.defaults[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/*
+ * |---------------------------------|
+ * |     Conditions Selectors        |
+ * |---------------------------------|
+ */
+export const selectOptionConditionsObject = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.conditions.options[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+export const selectVariableConditionsObject = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.conditions.variables[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+export const selectDocumentConditionsObject = createSelector(
+  (state: StateType, name: string) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.conditions.documents[name];
+  },
+  (state: StateType, name: string) => (!state.references ? Math.random() : name)
+);
+
+export const selectSectionConditionsObject = createSelector(
+  (state: StateType, id: number, document = 'main') => {
+    return state.references.conditions.sections[document][id];
+  },
+  (state: StateType, id: number, document = 'main') =>
+    !state.references ? Math.random() : `${id}-${document}`
+);
+
+export const selectPrefillerConditionsObject = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.conditions.prefillers[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+export const selectOptionValidatorConditionsObject = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.conditions.validators.options[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+export const selectVariableValidatorConditionsObject = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.references === 'undefined') return undefined;
+    return state.references.conditions.validators.variables[id];
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/*
+ * |---------------------------------|
+ * |       Helpers Selectors         |
+ * |---------------------------------|
+ */
+export const areVariablesSiblings = createSelector(
+  (state: StateType, ...args: number[]) => {
+    if (typeof state.references === 'undefined') return undefined;
+
+    // Getting variables first parent
+    const rootParents = args
+      .map((variableId) => {
+        const parents = selectVariableParents(variableId);
+        if (parents === undefined) return null;
+        return parents[parents.length - 1];
+      })
+      .filter((a) => a !== null);
+
+    const comparator = rootParents.length > 0 ? rootParents[0] : -1;
+
+    return rootParents.every((c) => c === comparator);
+  },
+  (state: StateType, ...args: number[]) =>
+    args.reduce((p, c) => p + c.toString(), '')
+);
+
+/**
+ * Tags selector
+ */
+export const selectVariablesByTag = createSelector(
+  (state: StateType, tag: string) => {
+    const ids: number[] = [];
+    Object.keys(state.references.variables).forEach((id) => {
+      const variable = state.references.variables[id];
+      if (Array.isArray(variable.tags) && variable.tags.includes(tag))
+        ids.push(parseInt(id, 10));
+    });
+    return ids;
+  }
+);
+
+export const selectOptionsByTag = createSelector(
+  (state: StateType, tag: string) => {
+    const ids: number[] = [];
+    Object.keys(state.references.options).forEach((id) => {
+      const option = state.references.options[id];
+      if (Array.isArray(option.meta.tags) && option.meta.tags.includes(tag))
+        ids.push(parseInt(id, 10));
+    });
+    return ids;
+  }
+);
+
+/**
+ * Returns Option's parent section
+ * @param id Option's id
+ */
+export const selectOptionParentSection = createSelector(
+  (state: StateType, id: number) => {
+    const { parents } = state.references.relations.options[id];
+    if (parents === undefined)
+      throw new Error(`Option ${id} parent relations are undefined`);
+
+    // Getting root option id
+    const rootId = parents.length > 0 ? parents[parents.length - 1] : id;
+
+    // Looking for section
+    const sections = Object.values(state.references.sections.main);
+
+    for (let i = 0; i < sections.length; i += 1) {
+      if (sections[i].options.includes(rootId)) return sections[i].id;
+    }
+
+    throw new Error(
+      `Cannot find parent section for option ${id} (Root option id: ${rootId})`
+    );
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+/**
+ * Returns Variable's parent section
+ * @param id Variable's id
+ */
+export const selectVariableParentSection = createSelector(
+  (state: StateType, id: number) => {
+    const { parents } = state.references.relations.variables[id];
+    if (parents === undefined)
+      throw new Error(`Variable ${id} parent relations are undefined`);
+
+    // Getting root option id
+    const rootId = parents[parents.length - 1];
+
+    // Looking for section
+    const sections = Object.values(state.references.sections.main);
+
+    for (let i = 0; i < sections.length; i += 1) {
+      if (sections[i].options.includes(rootId)) return sections[i].id;
+    }
+
+    throw new Error(
+      `Cannot find parent section for variable ${id} (Root option id: ${rootId})`
+    );
+  },
+  (state: StateType, id: number) => (!state.references ? Math.random() : id)
+);
+
+export const selectUserEmailSectionVariableIds = createSelector(
+  (state: StateType, sectionId: number) => {
+    const { variables } = state.references;
+
+    // Extract all user_email variables
+    const userEmailVariables = Object.keys(variables).filter(
+      (variableId) => variables[variableId].type === 'user_email'
+    );
+
+    return userEmailVariables.filter(
+      (variableId) =>
+        selectVariableParentSection(parseInt(variableId, 10)) === sectionId
+    );
+  },
+  (state: StateType, sectionId: number) =>
+    !state.references ? Math.random() : sectionId
+);

package/src/redux/selectors/selectors.test.ts

@@ -0,0 +1,21 @@
+import configureMockStore from 'redux-mock-store';
+import { createSelector, selectorsMiddleware } from './selectors';
+
+describe('Selectors Test', () => {
+  it('Middleware', () => {
+    const mockStore = configureMockStore([selectorsMiddleware]);
+    const store = mockStore({});
+
+    const myFakeFunction = jest.fn();
+
+    const selector = createSelector(myFakeFunction);
+
+    store.dispatch({ type: 'FAKE_ACTION' });
+    selector();
+    selector();
+    selector();
+    selector();
+
+    expect(myFakeFunction).toHaveBeenCalledTimes(1);
+  });
+});

package/src/redux/selectors/selectors.ts

@@ -0,0 +1,87 @@
+import { Action, MiddlewareAPI, Dispatch } from 'redux';
+import { StateType } from '../../types/State.type';
+
+let SelectorsStateTrack = -1;
+let globalMPI: MiddlewareAPI;
+
+/**
+ * Create a Memoized version of the selector function based on
+ * the state version and the arguments passed to it
+ *
+ * @category Selectors
+ *
+ * @param selector {function} A selector function
+ * @param [equalityFn] {function} returns the cache key
+ *
+ * @return A memoized selector function
+ */
+export type SelectorFunction = (state: StateType, ...args: any[]) => any;
+export type SelectorArguments<F extends SelectorFunction> = F extends (
+  state: StateType,
+  ...a: infer A
+) => any
+  ? A
+  : never;
+export type SelectorReturn<F extends SelectorFunction> = F extends (
+  state: StateType,
+  ...a: any[]
+) => infer R
+  ? R
+  : never;
+export type SelectorEqualityFn<T extends SelectorFunction> = (
+  state: StateType,
+  ...a: SelectorArguments<T>
+) => string | number;
+
+export function createSelector<
+  T extends SelectorFunction,
+  R = SelectorReturn<T>
+>(
+  selector: T,
+  equalityFn?: SelectorEqualityFn<T>
+): (...args: SelectorArguments<T>) => Readonly<R> {
+  const cache: Record<string, any> = {};
+  return (...args) => {
+    let state;
+
+    if (SelectorsStateTrack === -1)
+      throw new Error(`State hasn't beed initiated yet`);
+
+    // Getting state from MPI, wrapping it inside a try/catch since it throws
+    // an error if selectors are used inside reducers
+    try {
+      state = globalMPI.getState();
+    } catch (e) {
+      throw new Error(
+        'You may not use selectors while the reducer is executing. (Try sagas or middlewares)'
+      );
+    }
+
+    // Calculating current cache key
+    const currentKey: string | number =
+      typeof equalityFn === 'function'
+        ? equalityFn(state, ...args)
+        : [SelectorsStateTrack, ...args].reduce((v, c) => v + c);
+
+    if (!Object.prototype.hasOwnProperty.call(cache, currentKey)) {
+      cache[currentKey] = selector(state, ...args);
+    }
+
+    return cache[currentKey];
+  };
+}
+
+/**
+ * Selector Redux Middleware
+ * @param mpi Redux's Middleware API
+ */
+export const selectorsMiddleware =
+  (mpi: MiddlewareAPI) => (next: Dispatch) => (action: Action) => {
+    const result = next(action);
+
+    // Adding Middleware API
+    globalMPI = mpi;
+    SelectorsStateTrack += 1;
+
+    return result;
+  };

package/src/redux/selectors/smartscript.ts

@@ -0,0 +1,30 @@
+import { createSelector } from './selectors';
+import { StateType } from '../../types/State.type';
+
+/**
+ * Returns if option's index is hidden by Smartscript or not
+ */
+export const selectIsSmartscriptOptionIndexHidden = createSelector(
+  (state: StateType, id: number, index: number) =>
+    Array.isArray(state.smartscript.hidden.options[id]) &&
+    state.smartscript.hidden.options[id].includes(index),
+  (state, id, index) =>
+    Array.isArray(state.smartscript.hidden.options[id]) &&
+    state.smartscript.hidden.options[id].includes(index)
+      ? '1'
+      : '0'
+);
+
+/**
+ * Returns if variable's index is hidden by Smartscript or not
+ */
+export const selectIsSmartscriptVariableIndexHidden = createSelector(
+  (state: StateType, id: number, index: number) =>
+    Array.isArray(state.smartscript.hidden.variables[id]) &&
+    state.smartscript.hidden.variables[id].includes(index),
+  (state, id, index) =>
+    Array.isArray(state.smartscript.hidden.variables[id]) &&
+    state.smartscript.hidden.variables[id].includes(index)
+      ? '1'
+      : '0'
+);

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

@@ -0,0 +1,39 @@
+import { createAppStore, getStore } from '../store';
+import { selectCurrentUserLevel, isLevelAccessibleForUser } from './user';
+import { initUserAction } from '../actions/user';
+
+// Initiating state
+createAppStore('memory');
+const store = getStore();
+
+describe('User selectors test suit', () => {
+  it('selectCurrentUserLevel', () => {
+    store.dispatch(
+      initUserAction({
+        displayName: 'John Doe',
+        level: 'MANAGER',
+        email: 'john@doe.com',
+      })
+    );
+
+    const selector = selectCurrentUserLevel();
+
+    expect(selector).toEqual('MANAGER');
+  });
+
+  it('selectCurrentUserLevel', () => {
+    store.dispatch(
+      initUserAction({
+        displayName: 'John Doe',
+        level: 'MANAGER',
+        email: 'john@doe.com',
+      })
+    );
+
+    expect(isLevelAccessibleForUser('GUEST')).toBeTruthy();
+    expect(isLevelAccessibleForUser('USER')).toBeTruthy();
+    expect(isLevelAccessibleForUser('MANAGER')).toBeTruthy();
+    expect(isLevelAccessibleForUser('ADMIN')).toBeFalsy();
+    expect(isLevelAccessibleForUser('SUPER')).toBeFalsy();
+  });
+});

package/src/redux/selectors/user.ts

@@ -0,0 +1,45 @@
+import { StateType } from '../../types/State.type';
+import { createSelector } from './selectors';
+
+/**
+ * Returns current user level
+ */
+export const selectCurrentUserLevel = createSelector(
+  (state: StateType) => (state.user ? state.user.level : undefined),
+  (state: StateType) => (state.user ? state.user.level : Math.random())
+);
+
+export const selectUserStatus = createSelector(
+  (state: StateType) => (state.user ? state.user.status : 'unauthenticated'),
+  (state: StateType) => (state.user ? state.user.status : Math.random())
+);
+
+export const selectUserValidToken = createSelector(
+  (state: StateType) => state.user?.validToken || false,
+  (state: StateType) =>
+    state.user ? (state.user.validToken || false).toString() : Math.random()
+);
+
+export const selectUserEmail = createSelector(
+  (state: StateType) =>
+    state.user && state.user.email && state.user.email.length > 0
+      ? state.user.email
+      : '',
+  (state: StateType) =>
+    state.user && state.user.email && state.user.email.length > 0
+      ? state.user.email
+      : Math.random()
+);
+
+export const isLevelAccessibleForUser = createSelector(
+  (
+    state: StateType,
+    level: 'ADMIN' | 'MANAGER' | 'USER' | 'GUEST' | 'SUPER'
+  ) => {
+    const currentUserLevel = state.user ? state.user.level : 'GUEST';
+    const levelEnum = ['GUEST', 'USER', 'MANAGER', 'ADMIN', 'SUPER'];
+    return levelEnum.indexOf(level) <= levelEnum.indexOf(currentUserLevel);
+  },
+  (state: StateType, level: 'ADMIN' | 'MANAGER' | 'USER' | 'GUEST' | 'SUPER') =>
+    state.user ? `${state.user.level}-${level}` : Math.random()
+);

package/src/redux/store.test.ts

@@ -0,0 +1,22 @@
+import { createAppStore, getStore } from './store';
+
+/**
+ * Testing store creation
+ */
+describe('Store Creation', () => {
+  it('Throws error when trying to get store before creation', () => {
+    expect(() => getStore()).toThrowError('Store not yet created');
+  });
+
+  it('It creates store', () => {
+    createAppStore();
+    const store = getStore();
+    return expect(store).toHaveProperty('getState');
+  });
+
+  it('It properly connects redux', () => {
+    createAppStore();
+    const state = getStore().getState();
+    return expect(state).toHaveProperty('router');
+  });
+});