@truedat/bg 7.0.5 → 7.0.7

package/src/taxonomy/reducers/__tests__/domainsActions.spec.js

@@ -1,36 +0,0 @@
-import { fetchDomains } from "../../routines";
-import { domainsActions } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domainsActions", () => {
-  it("should provide the initial state", () => {
-    expect(domainsActions(undefined, {})).toEqual({});
-  });
-
-  it("should be an empty object after receiving the fetchDomains.TRIGGER action", () => {
-    expect(domainsActions(fooState, { type: fetchDomains.TRIGGER })).toEqual(
-      {}
-    );
-  });
-
-  it("should extract _actions from the fetchDomains.SUCCESS action", () => {
-    const _actions = { delete: { foo: "bar" } };
-    const payload = { data: { _actions: _actions } };
-    expect(
-      domainsActions(fooState, { type: fetchDomains.SUCCESS, payload })
-    ).toMatchObject(_actions);
-  });
-
-  it("should be an empty object after receiving the fetchDomains.SUCCESS action without _actions", () => {
-    const data = [{ id: 1 }];
-    const payload = { data };
-    expect(
-      domainsActions(fooState, { type: fetchDomains.SUCCESS, payload })
-    ).toEqual({});
-  });
-
-  it("should ignore unhandled actions", () => {
-    expect(domainsActions(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/taxonomy/reducers/__tests__/domainsConcept.spec.js

@@ -1,30 +0,0 @@
-import { fetchDomainsConcept } from "../../routines";
-import { domainsConcept } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domainsConcept", () => {
-  const initialState = [];
-
-  it("should provide the initial state", () => {
-    expect(domainsConcept(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the SUCCESS action", () => {
-    const data = [
-      { id: 1, name: "Domain 1", description: "Desc 1" },
-      { id: 2, name: "Domain 2", description: "Desc 2", parent_id: 1 },
-    ];
-
-    expect(
-      domainsConcept(fooState, {
-        type: fetchDomainsConcept.SUCCESS,
-        payload: { data: { data } },
-      })
-    ).toMatchObject(data);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(domainsConcept(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/taxonomy/reducers/__tests__/domainsFilter.spec.js

@@ -1,41 +0,0 @@
-import {
-  clearDomain,
-  fetchDomain,
-  fetchDomains,
-  filterDomains
-} from "../../routines";
-import { domainsFilter, initialState } from "../domainsFilter";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domainsFilter", () => {
-  it("should provide the initial state", () => {
-    expect(domainsFilter(undefined, {})).toBe(initialState);
-  });
-
-  it("should return the initial state after receiving the clearDomain.TRIGGER action", () => {
-    expect(domainsFilter(fooState, { type: clearDomain.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should return the initial state after receiving the fetchDomain.TRIGGER action", () => {
-    expect(domainsFilter(fooState, { type: fetchDomain.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should return the initial state after receiving the fetchDomains.TRIGGER action", () => {
-    expect(domainsFilter(fooState, { type: fetchDomains.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should contain the filter query after receiving the filterDomains.TRIGGER action", () => {
-    const query = "My Filter Text";
-    const payload = { query };
-    expect(
-      domainsFilter(fooState, { type: filterDomains.TRIGGER, payload })
-    ).toBe(query);
-  });
-});

package/src/taxonomy/reducers/__tests__/domainsLoading.spec.js

@@ -1,22 +0,0 @@
-import { fetchDomains } from "../../routines";
-import { domainsLoading } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domainsLoading", () => {
-  it("should provide the initial state", () => {
-    expect(domainsLoading(undefined, {})).toBe(false);
-  });
-
-  it("should be true after receiving the fetchDomains.TRIGGER action", () => {
-    expect(domainsLoading(false, { type: fetchDomains.TRIGGER })).toBe(true);
-  });
-
-  it("should be false after receiving the fetchDomains.FULFILL action", () => {
-    expect(domainsLoading(true, { type: fetchDomains.FULFILL })).toBe(false);
-  });
-
-  it("should ignore unhandled actions", () => {
-    expect(domainsLoading(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/taxonomy/reducers/domain.js

@@ -1,32 +0,0 @@
-import _ from "lodash/fp";
-import { clearDomain, fetchDomain, updateDomain } from "../routines";
-
-const initialState = {};
-
-const pickFields = _.pick([
-  "id",
-  "external_id",
-  "parent_id",
-  "name",
-  "description",
-  "type",
-  "parentable_ids",
-  "domain_group",
-]);
-
-const domain = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case clearDomain.TRIGGER:
-      return initialState;
-    case fetchDomain.TRIGGER:
-      return initialState;
-    case fetchDomain.SUCCESS:
-      return pickFields(payload.data);
-    case updateDomain.SUCCESS:
-      return pickFields(payload.data);
-    default:
-      return state;
-  }
-};
-
-export { domain };

package/src/taxonomy/reducers/domainActions.js

@@ -1,19 +0,0 @@
-import _ from "lodash/fp";
-import { fetchDomain, clearDomain } from "../routines";
-
-const initialState = {};
-
-export const domainActions = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case clearDomain.TRIGGER:
-      return initialState;
-    case fetchDomain.TRIGGER:
-      return initialState;
-    case fetchDomain.SUCCESS:
-      return _.propOr(initialState, "_actions")(payload);
-    default:
-      return state;
-  }
-};
-
-export default domainActions;

package/src/taxonomy/reducers/domainCreating.js

@@ -1,14 +0,0 @@
-import { createDomain } from "../routines";
-
-const domainCreating = (state = false, { type }) => {
-  switch (type) {
-    case createDomain.TRIGGER:
-      return true;
-    case createDomain.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};
-
-export { domainCreating };

package/src/taxonomy/reducers/domainLoading.js

@@ -1,14 +0,0 @@
-import { fetchDomain } from "../routines";
-
-const domainLoading = (state = false, { type }) => {
-  switch (type) {
-    case fetchDomain.TRIGGER:
-      return true;
-    case fetchDomain.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};
-
-export { domainLoading };

package/src/taxonomy/reducers/domainMembersActions.js

@@ -1,22 +0,0 @@
-import _ from "lodash/fp";
-import { fetchDomain, fetchDomainMembers, clearDomain } from "../routines";
-
-export const initialState = {};
-
-export const domainMembersActions = (
-  state = initialState,
-  { type, payload }
-) => {
-  switch (type) {
-    case clearDomain.TRIGGER:
-      return initialState;
-    case fetchDomain.TRIGGER:
-      return initialState;
-    case fetchDomainMembers.SUCCESS:
-      return _.pathOr(initialState, "_links.self")(payload);
-    default:
-      return state;
-  }
-};
-
-export default domainMembersActions;

package/src/taxonomy/reducers/domainMembersLoading.js

@@ -1,12 +0,0 @@
-import { fetchDomainMembers } from "../routines";
-
-export const domainMembersLoading = (state = false, { type }) => {
-  switch (type) {
-    case fetchDomainMembers.TRIGGER:
-      return true;
-    case fetchDomainMembers.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/domainRedirect.js

@@ -1,25 +0,0 @@
-import _ from "lodash/fp";
-import { clearRedirect } from "@truedat/core/routines";
-import { linkTo } from "@truedat/core/routes";
-import { createDomain, deleteDomain, updateDomain } from "../routines";
-
-const initialState = "";
-
-export const domainRedirect = (
-  state = initialState,
-  { type, payload, meta }
-) => {
-  switch (type) {
-    case clearRedirect.TRIGGER:
-      return initialState;
-    case createDomain.SUCCESS:
-      return linkTo.DOMAIN(_.prop("data", payload));
-    case updateDomain.SUCCESS:
-      return linkTo.DOMAIN(_.prop("data", payload));
-    case deleteDomain.SUCCESS:
-      const { redirectUrl } = meta;
-      return redirectUrl;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/domainUpdating.js

@@ -1,14 +0,0 @@
-import { updateDomain } from "../routines";
-
-const domainUpdating = (state = false, { type }) => {
-  switch (type) {
-    case updateDomain.TRIGGER:
-      return true;
-    case updateDomain.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};
-
-export { domainUpdating };

package/src/taxonomy/reducers/domains.js

@@ -1,19 +0,0 @@
-import _ from "lodash/fp";
-import { fetchDomains, clearDomains } from "../routines";
-
-const initialState = [];
-
-const caseInsensitiveName = ({ name }) => _.toLower(name);
-
-export const domains = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case fetchDomains.SUCCESS:
-      const { data } = payload;
-      const collection = _.prop("data")(data);
-      return _.sortBy(caseInsensitiveName)(collection);
-    case clearDomains.TRIGGER:
-      return initialState;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/domainsActions.js

@@ -1,20 +0,0 @@
-import _ from "lodash/fp";
-import { fetchDomains, clearDomains } from "../routines";
-
-const initialState = {};
-
-export const domainsActions = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case clearDomains.TRIGGER:
-      return initialState;
-    case fetchDomains.TRIGGER:
-      return initialState;
-    case fetchDomains.SUCCESS:
-      const { data } = payload;
-      return _.propOr(initialState, "_actions")(data);
-    default:
-      return state;
-  }
-};
-
-export default domainsActions;

package/src/taxonomy/reducers/domainsConcept.js

@@ -1,19 +0,0 @@
-import _ from "lodash/fp";
-import { fetchDomainsConcept, clearDomainsConcept } from "../routines";
-
-const initialState = [];
-
-const caseInsensitiveName = ({ name }) => _.toLower(name);
-
-export const domainsConcept = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case fetchDomainsConcept.SUCCESS:
-      const { data } = payload;
-      const collection = _.prop("data")(data);
-      return _.sortBy(caseInsensitiveName)(collection);
-    case clearDomainsConcept.TRIGGER:
-      return initialState;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/domainsConceptLoading.js

@@ -1,12 +0,0 @@
-import { fetchDomainsConcept } from "../routines";
-
-export const domainsConceptLoading = (state = false, { type }) => {
-  switch (type) {
-    case fetchDomainsConcept.TRIGGER:
-      return true;
-    case fetchDomainsConcept.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/domainsFilter.js

@@ -1,24 +0,0 @@
-import {
-  filterDomains,
-  clearDomain,
-  fetchDomain,
-  fetchDomains
-} from "../routines";
-
-export const initialState = "";
-
-export const domainsFilter = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case clearDomain.TRIGGER:
-      return initialState;
-    case fetchDomain.TRIGGER:
-      return initialState;
-    case fetchDomains.TRIGGER:
-      return initialState;
-    case filterDomains.TRIGGER:
-      const { query } = payload;
-      return query;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/domainsLoading.js

@@ -1,12 +0,0 @@
-import { fetchDomains } from "../routines";
-
-export const domainsLoading = (state = false, { type }) => {
-  switch (type) {
-    case fetchDomains.TRIGGER:
-      return true;
-    case fetchDomains.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};

package/src/taxonomy/reducers/index.js

@@ -1,31 +0,0 @@
-import { domain } from "./domain";
-import { domainActions } from "./domainActions";
-import { domainCreating } from "./domainCreating";
-import { domainLoading } from "./domainLoading";
-import { domainsConcept } from "./domainsConcept";
-import { domainsConceptLoading } from "./domainsConceptLoading";
-import { domainMembersActions } from "./domainMembersActions";
-import { domainMembersLoading } from "./domainMembersLoading";
-import { domainRedirect } from "./domainRedirect";
-import { domains } from "./domains";
-import { domainsActions } from "./domainsActions";
-import { domainsFilter } from "./domainsFilter";
-import { domainsLoading } from "./domainsLoading";
-import { domainUpdating } from "./domainUpdating";
-
-export {
-  domain,
-  domainActions,
-  domainCreating,
-  domainLoading,
-  domainMembersActions,
-  domainMembersLoading,
-  domainsConcept,
-  domainsConceptLoading,
-  domainRedirect,
-  domains,
-  domainsActions,
-  domainsFilter,
-  domainsLoading,
-  domainUpdating,
-};

package/src/taxonomy/sagas/__tests__/fetchDomain.spec.js

@@ -1,69 +0,0 @@
-import { compile } from "path-to-regexp";
-import { testSaga } from "redux-saga-test-plan";
-import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
-import { fetchDomainSaga, fetchDomainRequestSaga } from "../fetchDomain";
-import { fetchDomain } from "../../routines";
-import { API_DOMAIN } from "../../api";
-
-describe("sagas: fetchDomainRequestSaga", () => {
-  it("should invoke fetchDomainSaga on trigger", () => {
-    expect(() => {
-      testSaga(fetchDomainRequestSaga)
-        .next()
-        .takeLatest(fetchDomain.TRIGGER, fetchDomainSaga)
-        .finish()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should throw exception if an unhandled action is received", () => {
-    expect(() => {
-      testSaga(fetchDomainRequestSaga)
-        .next()
-        .takeLatest("FOO", fetchDomainSaga);
-    }).toThrow();
-  });
-});
-
-describe("sagas: fetchDomainSaga", () => {
-  const id = 1;
-  const url = compile(API_DOMAIN)({ id });
-  const payload = { id };
-
-  it("should put a success action when a response is returned", () => {
-    const data = { id, name: "Top domain", description: "Desc" };
-
-    expect(() => {
-      testSaga(fetchDomainSaga, { payload })
-        .next()
-        .put(fetchDomain.request())
-        .next()
-        .call(apiJson, url, JSON_OPTS)
-        .next({ data })
-        .put(fetchDomain.success(data))
-        .next()
-        .put(fetchDomain.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should put a failure action when the call returns an error", () => {
-    const message = "Request failed";
-    const error = { message };
-
-    expect(() => {
-      testSaga(fetchDomainSaga, { payload })
-        .next()
-        .put(fetchDomain.request())
-        .next()
-        .call(apiJson, url, JSON_OPTS)
-        .throw(error)
-        .put(fetchDomain.failure(message))
-        .next()
-        .put(fetchDomain.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-});

package/src/taxonomy/sagas/__tests__/fetchDomains.spec.js

@@ -1,90 +0,0 @@
-import { testSaga } from "redux-saga-test-plan";
-import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
-import { fetchDomainsRequestSaga, fetchDomainsSaga } from "../fetchDomains";
-import { fetchDomains } from "../../routines";
-import { API_DOMAINS } from "../../api";
-
-describe("sagas: fetchDomainsRequestSaga", () => {
-  it("should invoke fetchDomainsSaga on trigger", () => {
-    expect(() => {
-      testSaga(fetchDomainsRequestSaga)
-        .next()
-        .takeLatest(fetchDomains.TRIGGER, fetchDomainsSaga)
-        .finish()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should throw exception if an unhandled action is received", () => {
-    expect(() => {
-      testSaga(fetchDomainsRequestSaga)
-        .next()
-        .takeLatest("FOO", fetchDomainsSaga);
-    }).toThrow();
-  });
-});
-
-describe("sagas: fetchDomainsSaga", () => {
-  const data = {
-    collection: [
-      { id: 1, name: "Top domain", description: "Desc" },
-      { id: 2, name: "Child domain", description: "Desc2", parent_id: 2 },
-    ],
-  };
-
-  it("should put a success action when a response is returned", () => {
-    const actions = undefined;
-    expect(() => {
-      testSaga(fetchDomainsSaga, {})
-        .next()
-        .put(fetchDomains.request())
-        .next()
-        .call(apiJson, API_DOMAINS, JSON_OPTS)
-        .next({ data })
-        .put(fetchDomains.success({ data, actions }))
-        .next()
-        .put(fetchDomains.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should handle actions in the payload", () => {
-    const actions = "show";
-    const filter = "foo";
-    const payload = { actions, filter };
-    const json_opts = { params: { actions, filter }, ...JSON_OPTS };
-    expect(() => {
-      testSaga(fetchDomainsSaga, { payload })
-        .next()
-        .put(fetchDomains.request(payload))
-        .next()
-        .call(apiJson, API_DOMAINS, json_opts)
-        .next({ data })
-        .put(fetchDomains.success({ data, actions }))
-        .next()
-        .put(fetchDomains.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should put a failure action when the call throws an error", () => {
-    const message = "Request failed";
-    const error = { message };
-
-    expect(() => {
-      testSaga(fetchDomainsSaga, {})
-        .next()
-        .put(fetchDomains.request())
-        .next()
-        .call(apiJson, API_DOMAINS, JSON_OPTS)
-        .throw(error)
-        .put(fetchDomains.failure(message))
-        .next()
-        .put(fetchDomains.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-});

package/src/taxonomy/sagas/createDomain.js

@@ -1,27 +0,0 @@
-import { call, put, takeLatest } from "redux-saga/effects";
-import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
-import { createDomain } from "../routines";
-import { API_DOMAINS } from "../api";
-
-export function* createDomainSaga({ payload }) {
-  try {
-    const url = API_DOMAINS;
-    const body = { domain: payload };
-    yield put(createDomain.request(payload));
-    const { data } = yield call(apiJsonPost, url, body, JSON_OPTS);
-    yield put(createDomain.success(data));
-  } catch (error) {
-    if (error.response) {
-      const { status, data } = error.response;
-      yield put(createDomain.failure({ status, data }));
-    } else {
-      yield put(createDomain.failure(error.message));
-    }
-  } finally {
-    yield put(createDomain.fulfill());
-  }
-}
-
-export function* createDomainRequestSaga() {
-  yield takeLatest(createDomain.TRIGGER, createDomainSaga);
-}

package/src/taxonomy/sagas/deleteDomain.js

@@ -1,34 +0,0 @@
-import { compile } from "path-to-regexp";
-import { call, put, takeLatest } from "redux-saga/effects";
-import { DOMAINS, linkTo } from "@truedat/core/routes";
-import { apiJsonDelete, JSON_OPTS } from "@truedat/core/services/api";
-import { deleteDomain } from "../routines";
-import { API_DOMAIN } from "../api";
-
-const toApiPath = compile(API_DOMAIN);
-
-export function* deleteDomainSaga({ payload }) {
-  const domain = payload;
-  const url = toApiPath(domain);
-  const { parent_id } = domain;
-  const redirectUrl = parent_id ? linkTo.DOMAIN({ id: parent_id }) : DOMAINS;
-  const meta = { redirectUrl };
-  try {
-    yield put({ meta, ...deleteDomain.request() });
-    const { data } = yield call(apiJsonDelete, url, JSON_OPTS);
-    yield put({ meta, ...deleteDomain.success(data) });
-  } catch (error) {
-    if (error.response) {
-      const { status, data } = error.response;
-      yield put(deleteDomain.failure({ status, data, message: error.message }));
-    } else {
-      yield put(deleteDomain.failure(error.message));
-    }
-  } finally {
-    yield put(deleteDomain.fulfill());
-  }
-}
-
-export function* deleteDomainRequestSaga() {
-  yield takeLatest(deleteDomain.TRIGGER, deleteDomainSaga);
-}