@tsed/react-formio 1.14.1 → 2.0.1

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

@@ -1,214 +0,0 @@
-import { Formio } from "formiojs";
-
-import {
-  clearSubmissionError,
-  deleteSubmission,
-  failSubmission,
-  getSubmission,
-  receiveSubmission,
-  requestSubmission,
-  resetSubmission,
-  saveSubmission,
-  sendSubmission
-} from "./submission.actions";
-
-jest.mock("formiojs/Formio");
-
-describe("Submission actions", () => {
-  describe("getSubmission", () => {
-    beforeEach(() => {
-      (Formio as any).mockClear();
-    });
-    it("should return a result", async () => {
-      // GIVEN
-      (Formio as any).prototype.loadSubmission.mockReturnValue(Promise.resolve({}));
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const id = "123454";
-      const formId = "formId";
-
-      const getState = () => ({
-        [name]: {}
-      });
-
-      // WHEN
-      await new Promise((resolve) => getSubmission(name, formId, id, resolve)(dispatch, getState));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("/formId/submission/123454");
-      expect(Formio.prototype.loadSubmission).toHaveBeenCalledWith();
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: requestSubmission.toString(),
-        payload: {
-          formId: "formId",
-          id: "123454",
-          url: "/formId/submission/123454"
-        }
-      });
-      expect(dispatch).toHaveBeenCalledWith({
-        type: receiveSubmission.toString(),
-        name: "name",
-        payload: {
-          submission: {},
-          url: "/formId/submission/123454"
-        }
-      });
-    });
-    it("should do nothing when submission is already loaded", async () => {
-      // GIVEN
-      (Formio.prototype.loadSubmission as any).mockReturnValue(Promise.resolve({}));
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const id = "123454";
-      const formId = "formId";
-
-      const getState = () => ({
-        id
-      });
-
-      // WHEN
-      await getSubmission(name, formId, id)(dispatch, getState);
-
-      // THEN
-      expect(Formio).not.toHaveBeenCalled();
-    });
-    it("should throw error", async () => {
-      // GIVEN
-      (Formio.prototype.loadSubmission as any).mockReturnValue(Promise.reject(new Error("message")));
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const id = "123454";
-      const formId = "formId";
-
-      const getState = () => ({
-        [name]: {}
-      });
-
-      // WHEN
-      await new Promise((resolve) => getSubmission(name, formId, id, resolve)(dispatch, getState));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("/formId/submission/123454");
-      expect(Formio.prototype.loadSubmission).toHaveBeenCalledWith();
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: failSubmission.toString(),
-        payload: {
-          error: new Error("message")
-        }
-      });
-    });
-  });
-  describe("saveSubmission", () => {
-    it("should return a result", async () => {
-      // GIVEN
-      const dispatch = jest.fn();
-      const name = "name";
-      const data = { _id: "123454" };
-      const formId = "formId";
-
-      (Formio.prototype.saveSubmission as any).mockReturnValue(Promise.resolve(data));
-      // WHEN
-      await new Promise((resolve) => saveSubmission(name, formId, data, resolve)(dispatch));
-
-      // THEN
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: clearSubmissionError.toString()
-      });
-      expect(Formio).toHaveBeenCalledWith("/formId/submission/123454");
-      expect(Formio.prototype.saveSubmission).toHaveBeenCalledWith(data);
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: sendSubmission.toString(),
-        payload: {
-          formId,
-          submission: { _id: "123454" }
-        }
-      });
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        payload: {
-          url: "/formId/submission/123454",
-          submission: data
-        },
-        type: receiveSubmission.toString()
-      });
-    });
-    it("should throw error", async () => {
-      // GIVEN
-      (Formio.prototype.saveSubmission as any).mockImplementation(() => {
-        throw new Error("message");
-      });
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const data = { _id: "123454" };
-      const formId = "formId";
-
-      // WHEN
-      await new Promise((resolve) => saveSubmission(name, formId, data, resolve)(dispatch));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("/formId/submission/123454");
-      expect(Formio.prototype.saveSubmission).toHaveBeenCalledWith(data);
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: failSubmission.toString(),
-        payload: {
-          error: new Error("message")
-        }
-      });
-    });
-  });
-  describe("deleteSubmission", () => {
-    it("should return a result", async () => {
-      // GIVEN
-      (Formio.prototype.deleteSubmission as any).mockReturnValue(Promise.resolve({}));
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const id = "123454";
-      const formId = "formId";
-
-      // WHEN
-      await new Promise((resolve) => deleteSubmission(name, formId, id, resolve)(dispatch));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("/formId/submission/123454");
-      expect(Formio.prototype.deleteSubmission).toHaveBeenCalledWith();
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: resetSubmission.toString()
-      });
-    });
-    it("should throw error", async () => {
-      // GIVEN
-      (Formio.prototype.deleteSubmission as any).mockImplementation(() => {
-        throw new Error("message");
-      });
-      const dispatch = jest.fn();
-      const name = "name";
-      const id = "123454";
-      const formId = "formId";
-
-      // WHEN
-      await new Promise((resolve) => deleteSubmission(name, formId, id, resolve)(dispatch));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("/formId/submission/123454");
-      expect(Formio.prototype.deleteSubmission).toHaveBeenCalledWith();
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: failSubmission.toString(),
-        payload: {
-          error: new Error("message")
-        }
-      });
-    });
-  });
-});

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

@@ -1,81 +0,0 @@
-import { createAction } from "@tsed/redux-utils";
-import { Formio } from "formiojs";
-import noop from "lodash/noop";
-
-import { Submission } from "../../interfaces";
-import { getSubmissionUrl } from "../../utils/url";
-
-export const clearSubmissionError = createAction();
-export const requestSubmission = createAction();
-export const sendSubmission = createAction();
-export const receiveSubmission = createAction();
-export const failSubmission = createAction();
-export const resetSubmission = createAction();
-
-export const getSubmission =
-  (name: string, formId: string, id: string, done = noop) =>
-  async (dispatch: any, getState: any) => {
-    // Check to see if the submission is already loaded.
-    if (getState().id === id) {
-      return;
-    }
-
-    const url = getSubmissionUrl(formId, id);
-    const formio = new Formio(url);
-
-    dispatch(clearSubmissionError(name));
-    dispatch(requestSubmission(name, { id, formId, url }));
-
-    try {
-      const result = await formio.loadSubmission();
-
-      dispatch(receiveSubmission(name, { submission: result, url }));
-      done(null, result);
-    } catch (error) {
-      dispatch(failSubmission(name, { error }));
-      done(error);
-    }
-  };
-
-export const saveSubmission =
-  (name: string, formId: string, data: Submission, done = noop) =>
-  async (dispatch: any) => {
-    dispatch(clearSubmissionError(name));
-    dispatch(sendSubmission(name, { submission: data, formId }));
-
-    const id = data._id;
-    const url = getSubmissionUrl(formId, id);
-    const formio = new Formio(url);
-
-    try {
-      const result = await formio.saveSubmission(data);
-      dispatch(
-        receiveSubmission(name, {
-          submission: result,
-          url: getSubmissionUrl(formId, result._id)
-        })
-      );
-      done(null, result);
-    } catch (error) {
-      dispatch(failSubmission(name, { error }));
-      done(error);
-    }
-  };
-
-export const deleteSubmission =
-  (name: string, formId: string, id: string, done = noop) =>
-  async (dispatch: any) => {
-    dispatch(clearSubmissionError(name));
-
-    const url = getSubmissionUrl(formId, id);
-    const formio = new Formio(url);
-
-    try {
-      await formio.deleteSubmission();
-      dispatch(resetSubmission(name));
-      done(null);
-    } catch (error) {
-      dispatch(failSubmission(name, { error }));
-      done(error);
-    }
-  };

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

@@ -1,96 +0,0 @@
-import { failSubmission, receiveSubmission, requestSubmission, resetSubmission, sendSubmission } from "./submission.actions";
-import { submissionReducer } from "./submission.reducers";
-
-describe("Submission reducers", () => {
-  it("should return state (resetSubmission)", () => {
-    const reducer = submissionReducer("name");
-    const state: any = {};
-    const payload = {};
-
-    expect(reducer.$emit(resetSubmission.toString(), state, payload)).toEqual({
-      name: "name",
-      error: null,
-      formId: "",
-      id: "",
-      isActive: false,
-      lastUpdated: 0,
-      data: {},
-      url: ""
-    });
-  });
-  it("should return state (requestSubmission)", () => {
-    const reducer = submissionReducer("name");
-    const state: any = {};
-    const payload = {
-      formId: "formId",
-      id: "id",
-      url: "url"
-    };
-
-    expect(reducer.$emit(requestSubmission.toString(), state, payload)).toEqual({
-      name: "name",
-      formId: "formId",
-      id: "id",
-      isActive: true,
-      data: {},
-      url: "url"
-    });
-  });
-
-  it("should return state (sendSubmission)", () => {
-    const reducer = submissionReducer("name");
-    const state: any = {};
-    const payload = {
-      formId: "formId",
-      submission: {},
-      id: "id",
-      url: "url"
-    };
-
-    expect(reducer.$emit(sendSubmission.toString(), state, payload)).toEqual({
-      name: "name",
-      formId: "formId",
-      id: "id",
-      isActive: true,
-      data: {},
-      url: "url"
-    });
-  });
-
-  it("should return state (receiveSubmission)", () => {
-    const reducer = submissionReducer("name");
-    const state: any = {};
-    const payload = {
-      formId: "formId",
-      id: "id",
-      url: "url",
-      submission: {
-        _id: "id"
-      }
-    };
-
-    expect(reducer.$emit(receiveSubmission.toString(), state, payload)).toEqual({
-      name: "name",
-      url: "url",
-      error: null,
-      isActive: false,
-      data: {
-        _id: "id"
-      }
-    });
-  });
-
-  it("should return state (failSubmission)", () => {
-    const reducer = submissionReducer("name");
-    const state: any = {};
-    const payload = {
-      error: new Error("message")
-    };
-
-    expect(reducer.$emit(failSubmission.toString(), state, payload)).toEqual({
-      name: "name",
-      error: payload.error,
-      isActive: false
-    });
-  });
-});

package/src/stores/submission/submission.reducers.ts

@@ -1,70 +0,0 @@
-import { createReducer, InitialStateCreator } from "@tsed/redux-utils";
-
-import { Submission } from "../../interfaces";
-import {
-  clearSubmissionError,
-  failSubmission,
-  receiveSubmission,
-  requestSubmission,
-  resetSubmission,
-  sendSubmission
-} from "./submission.actions";
-
-export interface SubmissionState {
-  formId: string;
-  id: string;
-  isActive: boolean;
-  lastUpdated: number;
-  data: Partial<Submission>;
-  url: string;
-  error: null | Error;
-}
-
-const createInitialState: InitialStateCreator = () => ({
-  formId: "",
-  id: "",
-  isActive: false,
-  lastUpdated: 0,
-  data: {},
-  url: "",
-  error: null
-});
-
-export const submissionReducer = createReducer<SubmissionState>(
-  {
-    [resetSubmission.toString()]: (_: any, _2: any, reset: any) => reset(),
-    [clearSubmissionError.toString()]: (state: any) => ({
-      ...state,
-      error: null
-    }),
-    [requestSubmission.toString()]: (state: any, { formId, id, url }: any) => ({
-      ...state,
-      formId,
-      id,
-      url,
-      data: {},
-      isActive: true
-    }),
-    [sendSubmission.toString()]: (state: any, { formId, submission, id, url }: any) => ({
-      ...state,
-      formId,
-      id,
-      url: url || state.url,
-      data: submission,
-      isActive: true
-    }),
-    [receiveSubmission.toString()]: (state: any, { submission, url }: any) => ({
-      ...state,
-      data: submission,
-      url: url || state.url,
-      isActive: false,
-      error: null
-    }),
-    [failSubmission.toString()]: (state: any, { error }: any) => ({
-      ...state,
-      isActive: false,
-      error
-    })
-  },
-  createInitialState
-);

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

@@ -1,19 +0,0 @@
-import { selectSubmission } from "./submission.selectors";
-
-describe("submission Selectors", () => {
-  describe("selectSubmission()", () => {
-    it("should return submission", () => {
-      expect(
-        selectSubmission("submission", {
-          submission: {
-            data: {
-              _id: "id"
-            }
-          }
-        })
-      ).toEqual({
-        _id: "id"
-      });
-    });
-  });
-});

package/src/stores/submission/submission.selectors.ts

@@ -1,5 +0,0 @@
-import { Submission } from "../../interfaces";
-import { selectRoot } from "../root";
-import { SubmissionState } from "./submission.reducers";
-
-export const selectSubmission = (name: string, state: any): Partial<Submission> => selectRoot<SubmissionState>(name, state).data;

package/src/stores/submissions/index.ts

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

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

@@ -1,99 +0,0 @@
-import { Formio } from "formiojs";
-
-import { mapRequestParams } from "../../utils/mapRequestParams";
-import { failSubmissions, getSubmissions, receiveSubmissions, requestSubmissions } from "./submissions.actions";
-
-jest.mock("formiojs");
-jest.mock("../../utils/mapRequestParams");
-
-describe("Submissions actions", () => {
-  beforeEach(() => {
-    (mapRequestParams as any).mockImplementation((o: any) => o);
-  });
-  describe("getSubmissions", () => {
-    it("should return a result", async () => {
-      // GIVEN
-      (Formio.prototype.loadSubmissions as any).mockReturnValue(Promise.resolve([{}]));
-      (Formio.getProjectUrl as any).mockReturnValue("https://formio");
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const formId = "formId";
-      const parameters = {
-        pageSize: 10,
-        pageIndex: 0
-      };
-
-      const getState = () => ({
-        [name]: {
-          parameters
-        }
-      });
-
-      // WHEN
-      await new Promise((resolve) => getSubmissions(name, formId, parameters, resolve)(dispatch, getState));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("https://formio/formId/submission");
-      expect(Formio.prototype.loadSubmissions).toHaveBeenCalledWith({
-        params: parameters
-      });
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: requestSubmissions.toString(),
-        payload: {
-          formId,
-          parameters
-        }
-      });
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        payload: {
-          submissions: [{}]
-        },
-        type: receiveSubmissions.toString()
-      });
-    });
-    it("should return a error", async () => {
-      // GIVEN
-      (Formio.prototype.loadSubmissions as any).mockReturnValue(Promise.reject(new Error("message")));
-      (Formio.getProjectUrl as any).mockReturnValue("https://formio");
-
-      const dispatch = jest.fn();
-      const name = "name";
-      const formId = "formId";
-      const parameters = {
-        pageSize: 10,
-        pageIndex: 0
-      };
-
-      const getState = () => ({
-        [name]: {
-          parameters
-        }
-      });
-
-      // WHEN
-      await new Promise((resolve) => getSubmissions(name, formId, parameters, resolve)(dispatch, getState));
-
-      // THEN
-      expect(Formio).toHaveBeenCalledWith("https://formio/formId/submission");
-      expect(Formio.prototype.loadSubmissions).toHaveBeenCalledWith({
-        params: parameters
-      });
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        type: requestSubmissions.toString(),
-        payload: {
-          formId,
-          parameters
-        }
-      });
-      expect(dispatch).toHaveBeenCalledWith({
-        name: "name",
-        payload: { error: new Error("message") },
-        type: failSubmissions.toString()
-      });
-    });
-  });
-});

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

@@ -1,38 +0,0 @@
-import { createAction } from "@tsed/redux-utils";
-import { Formio } from "formiojs";
-import noop from "lodash/noop";
-
-import { mapRequestParams } from "../../utils/mapRequestParams";
-import { getSubmissionUrl } from "../../utils/url";
-import { selectSubmissionsParameters } from "./submissions.selectors";
-
-export const resetSubmissions = createAction();
-export const requestSubmissions = createAction();
-export const receiveSubmissions = createAction();
-export const failSubmissions = createAction();
-
-export const getSubmissions =
-  (name: string, formId: string, parameters: any = {}, done = noop) =>
-  async (dispatch: any, getState: any) => {
-    dispatch(requestSubmissions(name, { formId, parameters }));
-
-    const url = getSubmissionUrl(formId);
-    const formio = new Formio(url);
-    const requestParams = mapRequestParams(selectSubmissionsParameters(name, getState()));
-
-    try {
-      const submissions = await formio.loadSubmissions({ params: requestParams });
-      dispatch(receiveSubmissions(name, { submissions }));
-      done(null, submissions);
-    } catch (error) {
-      dispatch(failSubmissions(name, { error }));
-      done(error);
-    }
-  };
-
-export const refreshSubmissions = (name: string, formId: string, done = noop) => {
-  return async (dispatch: any, getState: any) => {
-    const parameters = selectSubmissionsParameters(name, getState());
-    return getSubmissions(name, formId, parameters, done)(dispatch, getState);
-  };
-};