@tsed/react-formio 1.14.1 → 2.0.0

package/src/stores/actions/actions.actions.ts

@@ -1,34 +0,0 @@
-import { createAction } from "@tsed/redux-utils";
-import { Formio } from "formiojs";
-import noop from "lodash/noop";
-
-import { getFormUrl } from "../../utils/url";
-import { ACTIONS } from "./actions.constant";
-
-export const resetActions = createAction();
-export const requestActions = createAction();
-export const receiveActions = createAction<{
-  actions: any[];
-  availableActions: any[];
-}>();
-export const failActions = createAction<{ error: Error }>();
-
-export const getActions =
-  (id: string, done = noop) =>
-  async (dispatch: any) => {
-    dispatch(resetActions(ACTIONS));
-    dispatch(requestActions(ACTIONS));
-
-    const url = getFormUrl(id);
-    const formio = new Formio(url);
-
-    try {
-      const [actions, availableActions] = await Promise.all([formio.loadActions({ params: {} }), formio.availableActions()]);
-
-      dispatch(receiveActions(ACTIONS, { actions, availableActions }));
-      done(null, actions, availableActions);
-    } catch (error) {
-      dispatch(failActions(ACTIONS, { error }));
-      done(error);
-    }
-  };

package/src/stores/actions/actions.constant.ts

@@ -1 +0,0 @@
-export const ACTIONS = "actions";

package/src/stores/actions/actions.reducers.spec.ts

@@ -1,62 +0,0 @@
-import { failActions, receiveActions, requestActions, resetActions } from "./actions.actions";
-import { ACTIONS } from "./actions.constant";
-import { actionsReducer } from "./actions.reducers";
-
-describe("Actions reducers", () => {
-  it("should return state (resetActions)", () => {
-    const reducer = actionsReducer;
-    const state: any = {};
-    const payload = {};
-
-    expect(reducer.$emit(resetActions, state, payload)).toEqual({
-      name: ACTIONS,
-      data: [],
-      availableActions: [],
-      error: null,
-      isActive: false
-    });
-  });
-  it("should return state (requestActions)", () => {
-    const reducer = actionsReducer;
-    const state: any = {};
-    const payload = {};
-
-    expect(reducer.$emit(requestActions, state, payload)).toEqual({
-      name: ACTIONS,
-      data: [],
-      availableActions: [],
-      error: null,
-      isActive: true
-    });
-  });
-
-  it("should return state (receiveActions)", () => {
-    const reducer = actionsReducer;
-    const state: any = {};
-    const payload = {
-      actions: [{ _id: "id" }]
-    };
-
-    expect(reducer.$emit(receiveActions, state, payload)).toEqual({
-      name: ACTIONS,
-      error: null,
-      data: [{ _id: "id" }],
-      isActive: false
-    });
-  });
-
-  it("should return state (failActions)", () => {
-    const reducer = actionsReducer;
-    const state: any = {};
-    const payload = {
-      error: new Error("message")
-    };
-
-    expect(reducer.$emit(failActions, state, payload)).toEqual({
-      name: ACTIONS,
-      data: [],
-      error: payload.error,
-      isActive: false
-    });
-  });
-});

package/src/stores/actions/actions.reducers.ts

@@ -1,48 +0,0 @@
-import { createReducer, InitialStateCreator } from "@tsed/redux-utils";
-
-import { ActionInfoSchema, ActionSchema } from "../../interfaces";
-import { failActions, receiveActions, requestActions, resetActions } from "./actions.actions";
-import { ACTIONS } from "./actions.constant";
-
-export interface ActionsState {
-  error: null | Error;
-  data: ActionSchema[];
-  availableActions: ActionInfoSchema[];
-  isActive: boolean;
-}
-
-const createInitialState: InitialStateCreator<ActionsState> = () => ({
-  error: null,
-  data: [],
-  availableActions: [],
-  isActive: false
-});
-
-export const actionsReducer = createReducer<ActionsState>(
-  {
-    [resetActions.toString()]: (_, _2, reset) => {
-      return reset();
-    },
-    [requestActions.toString()]: (state) => ({
-      ...state,
-      error: null,
-      data: [],
-      availableActions: [],
-      isActive: true
-    }),
-    [receiveActions.toString()]: (state, { actions, availableActions }) => ({
-      ...state,
-      error: null,
-      data: actions,
-      availableActions,
-      isActive: false
-    }),
-    [failActions.toString()]: (state, { error }) => ({
-      ...state,
-      error,
-      data: [],
-      isActive: false
-    })
-  },
-  createInitialState
-)(ACTIONS);

package/src/stores/actions/actions.selectors.spec.ts

@@ -1,34 +0,0 @@
-import { selectActions, selectAvailableActions } from "./actions.selectors";
-
-describe("actions Selectors", () => {
-  describe("selectActions()", () => {
-    it("should return actions", () => {
-      expect(
-        selectActions({
-          actions: {
-            data: {
-              id: "id"
-            },
-            availableActions: {}
-          }
-        })
-      ).toEqual({
-        id: "id"
-      });
-    });
-  });
-  describe("selectAvailableActions()", () => {
-    it("should return available actions", () => {
-      expect(
-        selectAvailableActions({
-          actions: {
-            data: {
-              id: "id"
-            },
-            availableActions: []
-          }
-        })
-      ).toEqual([]);
-    });
-  });
-});

package/src/stores/actions/actions.selectors.ts

@@ -1,7 +0,0 @@
-import { selectRoot } from "../root";
-import { ACTIONS } from "./actions.constant";
-import { ActionsState } from "./actions.reducers";
-
-export const selectActions = (state: Record<string, any>) => selectRoot<ActionsState>(ACTIONS, state).data;
-
-export const selectAvailableActions = (state: Record<string, any>) => selectRoot<ActionsState>(ACTIONS, state).availableActions;

package/src/stores/actions/index.ts

@@ -1,4 +0,0 @@
-export * from "./actions.actions";
-export * from "./actions.constant";
-export * from "./actions.reducers";
-export * from "./actions.selectors";

package/src/stores/auth/auth.actions.ts

@@ -1,13 +0,0 @@
-import { createAction } from "@tsed/redux-utils";
-
-import { FormSchema, RoleSchema, Submission } from "../../interfaces";
-
-export const requestUser = createAction();
-export const receiveUser = createAction<{ user: Submission }>();
-export const failUser = createAction<{ error: Error }>();
-export const logoutUser = createAction();
-export const submissionAccessUser = createAction<{ submissionAccess: any }>();
-export const formAccessUser = createAction<{ formAccess: any }>();
-export const projectAccessUser = createAction<{ projectAccess: any }>();
-export const userRoles = createAction<{ roles: Record<string, RoleSchema> }>();
-export const userForms = createAction<{ forms: Record<string, FormSchema> }>();

package/src/stores/auth/auth.constant.ts

@@ -1 +0,0 @@
-export const AUTH = "auth";

package/src/stores/auth/auth.reducers.spec.ts

@@ -1,376 +0,0 @@
-import {
-  failUser,
-  formAccessUser,
-  logoutUser,
-  projectAccessUser,
-  receiveUser,
-  requestUser,
-  submissionAccessUser,
-  userForms,
-  userRoles
-} from "./auth.actions";
-import { AUTH } from "./auth.constant";
-import { authReducer } from "./auth.reducers";
-
-describe("Auth reducer", () => {
-  it("should return state (requestUser)", () => {
-    const payload = {};
-
-    expect(
-      authReducer(undefined, {
-        type: requestUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: false,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: true,
-      is: {},
-      isActive: true,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: false,
-      user: null
-    });
-  });
-  it("should return state (receiveUser)", () => {
-    const payload = {
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(undefined, {
-        type: receiveUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    });
-  });
-  it("should return state (failUser)", () => {
-    const payload = {
-      error: {}
-    };
-
-    expect(
-      authReducer(undefined, {
-        type: failUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: false,
-      error: {},
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: null
-    });
-  });
-  it("should return state (logoutUser)", () => {
-    const payload = {};
-    const state: any = {
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(state, {
-        type: logoutUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: false,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: null
-    });
-  });
-  it("should return state (submissionAccessUser)", () => {
-    const payload = {
-      submissionAccess: {
-        sub: {}
-      }
-    };
-    const state: any = {
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(state, {
-        type: submissionAccessUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {
-        sub: {}
-      },
-      user: {
-        _id: "id"
-      }
-    });
-  });
-  it("should return state (formAccessUser)", () => {
-    const payload = {
-      formAccess: {
-        sub: {}
-      }
-    };
-    const state: any = {
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(state, {
-        type: formAccessUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: true,
-      error: null,
-      formAccess: {
-        sub: {}
-      },
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    });
-  });
-  it("should return state (userForms)", () => {
-    const payload = {
-      forms: {
-        sub: {}
-      }
-    };
-    const state: any = {
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(state, {
-        type: userForms.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {
-        sub: {}
-      },
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    });
-  });
-  it("should return state (projectAccessUser)", () => {
-    const payload = {
-      projectAccess: {
-        sub: {}
-      }
-    };
-    const state: any = {
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(state, {
-        type: projectAccessUser.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {
-        sub: {}
-      },
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    });
-  });
-  it("should return state (userRoles)", () => {
-    const payload = {
-      roles: {
-        sub: {}
-      }
-    };
-    const state: any = {
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {},
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    };
-
-    expect(
-      authReducer(state, {
-        type: userRoles.toString(),
-        payload,
-        name: AUTH
-      })
-    ).toEqual({
-      authenticated: true,
-      error: null,
-      formAccess: {},
-      forms: {},
-      init: false,
-      is: {},
-      isActive: false,
-      name: "auth",
-      projectAccess: {},
-      roles: {
-        sub: {}
-      },
-      submissionAccess: {},
-      user: {
-        _id: "id"
-      }
-    });
-  });
-});