@truedat/dd 7.11.1 → 7.11.3

package/src/sagas/__tests__/legacyFetchStructure.spec.js

@@ -0,0 +1,148 @@
+import { testSaga } from "redux-saga-test-plan";
+import {
+  legacyFetchStructureRequestSaga,
+  legacyFetchStructureSaga,
+} from "../legacyFetchStructure";
+
+import { legacyFetchStructure } from "../../routines";
+import { LEGACY_DATA_STRUCTURE_VERSION_QUERY } from "../../api/queries";
+import { getStructureFieldColumns } from "../../selectors";
+
+describe("sagas: fetchStructureRequestSaga", () => {
+  it("should invoke fetchStructureSaga on trigger", () => {
+    expect(() => {
+      testSaga(legacyFetchStructureRequestSaga)
+        .next()
+        .takeLatest(legacyFetchStructure.TRIGGER, legacyFetchStructureSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(legacyFetchStructureRequestSaga)
+        .next()
+        .takeLatest("FOO", legacyFetchStructureSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: legacyFetchStructureSaga", () => {
+  const client = { query: jest.fn() };
+  const id = 1;
+  const version = "latest";
+  const payload = { id };
+  const variables = {
+    dataStructureId: id,
+    version,
+    note_fields: ["note_field"],
+  };
+
+  const structureFieldColumns = [{ name: "id" }, { name: "note.note_field" }];
+
+  const _actions = { test: true };
+  const user_permissions = { permission1: true };
+
+  const dataStructureVersion = {
+    id,
+    name: "Structure 1",
+    description: "desc1",
+    _actions,
+    user_permissions,
+  };
+
+  const data = {
+    data: dataStructureVersion,
+    _actions,
+    user_permissions,
+  };
+
+  it("should put a success action when a response is returned", () => {
+    const meta = { version };
+
+    expect(() => {
+      testSaga(legacyFetchStructureSaga, { payload })
+        .next()
+        .select(getStructureFieldColumns)
+        .next(structureFieldColumns)
+        .getContext("client")
+        .next(client)
+        .put(legacyFetchStructure.request())
+        .next()
+
+        .call(client.query, {
+          fetchPolicy: "network-only",
+          query: LEGACY_DATA_STRUCTURE_VERSION_QUERY,
+          variables,
+        })
+        .next({ data: { dataStructureVersion } })
+        .put({ meta, ...legacyFetchStructure.success(data) })
+        .next()
+        .put(legacyFetchStructure.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should put a success action when a response is returned - with version", () => {
+    const version = 23;
+    const payload = { id, version };
+    const meta = { version };
+
+    const variables = {
+      dataStructureId: id,
+      version,
+      note_fields: ["note_field"],
+    };
+
+    expect(() => {
+      testSaga(legacyFetchStructureSaga, { payload })
+        .next()
+        .select(getStructureFieldColumns)
+        .next(structureFieldColumns)
+        .getContext("client")
+        .next(client)
+        .put(legacyFetchStructure.request())
+        .next()
+        .call(client.query, {
+          fetchPolicy: "network-only",
+          query: LEGACY_DATA_STRUCTURE_VERSION_QUERY,
+          variables,
+        })
+        .next({ data: { dataStructureVersion } })
+        .put({ meta, ...legacyFetchStructure.success(data) })
+        .next()
+        .put(legacyFetchStructure.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(legacyFetchStructureSaga, { payload })
+        .next()
+        .select(getStructureFieldColumns)
+        .next(structureFieldColumns)
+        .getContext("client")
+        .next(client)
+        .put(legacyFetchStructure.request())
+        .next()
+        .call(client.query, {
+          fetchPolicy: "network-only",
+          query: LEGACY_DATA_STRUCTURE_VERSION_QUERY,
+          variables,
+        })
+        .throw(error)
+        .put(legacyFetchStructure.failure(message))
+        .next()
+        .put(legacyFetchStructure.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

package/src/sagas/__tests__/requestGrantRemoval.spec.js

@@ -0,0 +1,132 @@
+import { testSaga } from "redux-saga-test-plan";
+import { compile } from "path-to-regexp";
+import {
+  requestGrantRemovalSaga,
+  requestGrantRemovalRequestSaga,
+} from "../requestGrantRemoval";
+import {
+  requestGrantRemoval,
+  legacyFetchStructure,
+  fetchStructures,
+} from "../../routines";
+import { API_GRANT } from "../../api";
+import { apiJsonPatch, JSON_OPTS } from "@truedat/core/services/api";
+
+describe("sagas: requestGrantRemovalRequestSaga", () => {
+  it("should invoke requestGrantRemovalSaga on requestGrantRemoval.TRIGGER", () => {
+    expect(() => {
+      testSaga(requestGrantRemovalRequestSaga)
+        .next()
+        .takeLatest(requestGrantRemoval.TRIGGER, requestGrantRemovalSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(requestGrantRemovalRequestSaga)
+        .next()
+        .takeLatest("FOO", requestGrantRemovalSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: requestGrantRemovalSaga", () => {
+  const id = "1";
+  const action = "REMOVE";
+  const data_structure_id = 2;
+  const version = "v3";
+  const previousStructureQuery = { foo: "bar" };
+  const payloadWithPrevQuery = {
+    id,
+    action,
+    data_structure_id,
+    version,
+    previousStructureQuery,
+  };
+  const payloadWithoutPrevQuery = {
+    id,
+    action,
+    data_structure_id,
+    version,
+    previousStructureQuery: undefined,
+  };
+  const requestData = { action };
+  const url = compile(API_GRANT)({ id: `${id}` });
+
+  it("should put a success action and fetchStructures.trigger when previousStructureQuery is provided", () => {
+    expect(() => {
+      testSaga(requestGrantRemovalSaga, { payload: payloadWithPrevQuery })
+        .next()
+        .put(requestGrantRemoval.request())
+        .next()
+        .call(apiJsonPatch, url, requestData, JSON_OPTS)
+        .next({ data: "result" })
+        .put(requestGrantRemoval.success("result"))
+        .next()
+        .put(fetchStructures.trigger(previousStructureQuery))
+        .next()
+        .put(requestGrantRemoval.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should put a success action and legacyFetchStructure.trigger when previousStructureQuery is not provided", () => {
+    expect(() => {
+      testSaga(requestGrantRemovalSaga, { payload: payloadWithoutPrevQuery })
+        .next()
+        .put(requestGrantRemoval.request())
+        .next()
+        .call(apiJsonPatch, url, requestData, JSON_OPTS)
+        .next({ data: "result" })
+        .put(requestGrantRemoval.success("result"))
+        .next()
+        .put(
+          legacyFetchStructure.trigger({
+            id: data_structure_id,
+            version,
+          })
+        )
+        .next()
+        .put(requestGrantRemoval.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should put a failure action with response when error.response exists", () => {
+    const error = { response: { status: 403, data: { err: "bad" } } };
+    expect(() => {
+      testSaga(requestGrantRemovalSaga, { payload: payloadWithPrevQuery })
+        .next()
+        .put(requestGrantRemoval.request())
+        .next()
+        .call(apiJsonPatch, url, requestData, JSON_OPTS)
+        .throw(error)
+        .put(requestGrantRemoval.failure({ status: 403, data: { err: "bad" } }))
+        .next()
+        .put(requestGrantRemoval.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should put a failure action with error.message when error.response does not exist", () => {
+    const error = { message: "Some other error" };
+    expect(() => {
+      testSaga(requestGrantRemovalSaga, { payload: payloadWithoutPrevQuery })
+        .next()
+        .put(requestGrantRemoval.request())
+        .next()
+        .call(apiJsonPatch, url, requestData, JSON_OPTS)
+        .throw(error)
+        .put(requestGrantRemoval.failure("Some other error"))
+        .next()
+        .put(requestGrantRemoval.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

package/src/sagas/createGrantRequestStatus.js

@@ -17,6 +17,7 @@ export function* createGrantRequestStatusSaga({ payload }) {
       structureId,
       previousStructureQuery,
     } = payload;
+
     const url = compile(API_GRANT_REQUEST_STATUS)({
       id: `${grantRequest.id}`,
     });

package/src/sagas/fetchStructureChildrens.js

@@ -0,0 +1,48 @@
+import _ from "lodash/fp";
+import { call, put, takeLatest, select, getContext } from "redux-saga/effects";
+import { fetchStructureChildrens } from "../routines";
+import { DATA_STRUCTURE_CHILDREN_QUERY } from "../api/queries";
+import { getStructureFieldColumns } from "../selectors";
+
+export function* fetchStructureChildrenSaga({ payload }) {
+  try {
+    const client = yield getContext("client");
+
+    yield put(fetchStructureChildrens.request());
+
+    const { id, version = "latest" } = payload;
+    const {
+      data: { dataStructureVersion },
+    } = yield call(client.query, {
+      fetchPolicy: "network-only",
+      query: DATA_STRUCTURE_CHILDREN_QUERY,
+      variables: {
+        dataStructureId: id,
+        version,
+      },
+    });
+
+    const data = {
+      data: dataStructureVersion,
+      _actions: dataStructureVersion._actions,
+      user_permissions: dataStructureVersion.user_permissions,
+    };
+
+    const meta = { version };
+
+    yield put({ meta, ...fetchStructureChildrens.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchStructureChildrens.failure({ status, data }));
+    } else {
+      yield put(fetchStructureChildrens.failure(error.message));
+    }
+  } finally {
+    yield put(fetchStructureChildrens.fulfill());
+  }
+}
+
+export function* fetchStructureChildrensRequestSaga() {
+  yield takeLatest(fetchStructureChildrens.TRIGGER, fetchStructureChildrensSaga);
+}

package/src/sagas/fetchStructureParents.js

@@ -0,0 +1,48 @@
+import _ from "lodash/fp";
+import { call, put, takeLatest, select, getContext } from "redux-saga/effects";
+import { fetchStructureParents } from "../routines";
+import { DATA_STRUCTURE_PARENTS_QUERY } from "../api/queries";
+import { getStructureFieldColumns } from "../selectors";
+
+export function* fetchStructureParentsSaga({ payload }) {
+  try {
+    const client = yield getContext("client");
+
+    yield put(fetchStructureParents.request());
+
+    const { id, version = "latest" } = payload;
+    const {
+      data: { dataStructureVersion },
+    } = yield call(client.query, {
+      fetchPolicy: "network-only",
+      query: DATA_STRUCTURE_PARENTS_QUERY,
+      variables: {
+        dataStructureId: id,
+        version, 
+      },
+    });
+
+    const data = {
+      data: dataStructureVersion,
+      _actions: dataStructureVersion._actions,
+      user_permissions: dataStructureVersion.user_permissions,
+    };
+
+    const meta = { version };
+
+    yield put({ meta, ...fetchStructureParents.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchStructureParents.failure({ status, data }));
+    } else {
+      yield put(fetchStructureParents.failure(error.message));
+    }
+  } finally {
+    yield put(fetchStructureParents.fulfill());
+  }
+}
+
+export function* fetchStructureParentsRequestSaga() {
+  yield takeLatest(fetchStructureParents.TRIGGER, fetchStructureParentsSaga);
+}

package/src/sagas/fetchStructureVersions.js

@@ -0,0 +1,46 @@
+import { call, put, takeLatest, getContext } from "redux-saga/effects";
+import { fetchStructureVersions } from "../routines";
+import { DATA_STRUCTURE_VERSION_VERSIONS_QUERY } from "../api/queries";
+
+export function* fetchStructureVersionsSaga({ payload }) {
+  try {
+    const client = yield getContext("client");
+
+    yield put(fetchStructureVersions.request());
+
+    const { id, version = "latest" } = payload;
+    const {
+      data: { dataStructureVersion },
+    } = yield call(client.query, {
+      fetchPolicy: "network-only",
+      query: DATA_STRUCTURE_VERSION_VERSIONS_QUERY,
+      variables: {
+        dataStructureId: id,
+        version,
+      },
+    });
+
+    const data = {
+      data: dataStructureVersion,
+      _actions: dataStructureVersion._actions,
+      user_permissions: dataStructureVersion.user_permissions,
+    };
+
+    const meta = { version };
+
+    yield put({ meta, ...fetchStructureVersions.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchStructureVersions.failure({ status, data }));
+    } else {
+      yield put(fetchStructureVersions.failure(error.message));
+    }
+  } finally {
+    yield put(fetchStructureVersions.fulfill());
+  }
+}
+
+export function* fetchStructureVersionsRequestSaga() {
+  yield takeLatest(fetchStructureVersions.TRIGGER, fetchStructureVersionsSaga);
+}

package/src/sagas/index.js

@@ -32,6 +32,7 @@ import { fetchProfileGroupRequestSaga } from "./fetchProfileGroup";
 import { fetchStructureGraphRequestSaga } from "./fetchStructureGraph";
 import { fetchStructureNotesRequestSaga } from "./fetchStructureNotes";
 import { fetchStructureRequestSaga } from "./fetchStructure";
+import { legacyFetchStructureRequestSaga } from "./legacyFetchStructure";
 import { fetchStructureTypeRequestSaga } from "./fetchStructureType";
 import { fetchStructureTypesRequestSaga } from "./fetchStructureTypes";
 import { fetchStructuresRequestSaga } from "./fetchStructures";
@@ -96,6 +97,7 @@ export {
   fetchSystemStructuresRequestSaga,
   fetchUserSearchFiltersRequestSaga,
   linkStructureToStructureRequestSaga,
+  legacyFetchStructureRequestSaga,
   tagStructureRequestSaga,
   operateGrantRequestToCartRequestSaga,
   requestGrantRemovalRequestSaga,
@@ -153,6 +155,7 @@ export default [
   fetchSystemStructuresRequestSaga(),
   fetchUserSearchFiltersRequestSaga(),
   linkStructureToStructureRequestSaga(),
+  legacyFetchStructureRequestSaga(),
   tagStructureRequestSaga(),
   operateGrantRequestToCartRequestSaga(),
   requestGrantRemovalRequestSaga(),

package/src/sagas/legacyFetchStructure.js

@@ -0,0 +1,55 @@
+import _ from "lodash/fp";
+import { call, put, takeLatest, select, getContext } from "redux-saga/effects";
+import { legacyFetchStructure } from "../routines";
+import { LEGACY_DATA_STRUCTURE_VERSION_QUERY } from "../api/queries";
+import { getStructureFieldColumns } from "../selectors";
+
+export function* legacyFetchStructureSaga({ payload }) {
+  try {
+    const structureFieldColumns = yield select(getStructureFieldColumns);
+    const note_fields = _.flow(
+      _.filter(({ name }) => name.startsWith("note.")),
+      _.map(({ name }) => name.split(".")[1])
+    )(structureFieldColumns);
+
+    const client = yield getContext("client");
+
+    yield put(legacyFetchStructure.request());
+
+    const { id, version = "latest" } = payload;
+    const {
+      data: { dataStructureVersion },
+    } = yield call(client.query, {
+      fetchPolicy: "network-only",
+      query: LEGACY_DATA_STRUCTURE_VERSION_QUERY,
+      variables: {
+        dataStructureId: id,
+        version,
+        note_fields,
+      },
+    });
+
+    const data = {
+      data: dataStructureVersion,
+      _actions: dataStructureVersion._actions,
+      user_permissions: dataStructureVersion.user_permissions,
+    };
+
+    const meta = { version };
+
+    yield put({ meta, ...legacyFetchStructure.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(legacyFetchStructure.failure({ status, data }));
+    } else {
+      yield put(legacyFetchStructure.failure(error.message));
+    }
+  } finally {
+    yield put(legacyFetchStructure.fulfill());
+  }
+}
+
+export function* legacyFetchStructureRequestSaga() {
+  yield takeLatest(legacyFetchStructure.TRIGGER, legacyFetchStructureSaga);
+}

package/src/sagas/requestGrantRemoval.js

@@ -3,7 +3,7 @@ import { call, put, takeLatest } from "redux-saga/effects";
 import { apiJsonPatch, JSON_OPTS } from "@truedat/core/services/api";
 import {
   requestGrantRemoval,
-  fetchStructure,
+  legacyFetchStructure,
   fetchStructures,
 } from "../routines";
 import { API_GRANT } from "../api";
@@ -21,7 +21,7 @@ export function* requestGrantRemovalSaga({ payload }) {
     yield put(
       previousStructureQuery
         ? fetchStructures.trigger(previousStructureQuery)
-        : fetchStructure.trigger({ id: data_structure_id, version })
+        : legacyFetchStructure.trigger({ id: data_structure_id, version })
     );
   } catch (error) {
     if (error.response) {

package/src/selectors/__tests__/getTabVisibility.spec.js

@@ -2,10 +2,10 @@ import { getTabVisibility } from "../getTabVisibility";
 
 describe("selectors: getTabVisibility", () => {
   it("should include fields iff structureFields is not empty", () => {
-    expect(getTabVisibility({ structureFields: [1] })).toMatchObject({
+    expect(getTabVisibility({ structure: { data_fields_count: 1 } })).toMatchObject({
       fields: true,
     });
-    expect(getTabVisibility({ structureFields: [] })).toMatchObject({
+    expect(getTabVisibility({ structure: { data_fields_count: 0 } })).toMatchObject({
       fields: false,
     });
   });
@@ -122,10 +122,10 @@ describe("selectors: getTabVisibility", () => {
 
   it("should include versions iff structureVersions is not empty", () => {
     expect(getTabVisibility({})).toMatchObject({ versions: false });
-    expect(getTabVisibility({ structureVersions: [] })).toMatchObject({
+    expect(getTabVisibility({ structure: { version_count: 0 } })).toMatchObject({
       versions: false,
     });
-    expect(getTabVisibility({ structureVersions: [{}] })).toMatchObject({
+    expect(getTabVisibility({ structure: { version_count: 1 } })).toMatchObject({
       versions: true,
     });
   });
@@ -224,10 +224,10 @@ describe("selectors: getTabVisibility", () => {
     expect(getTabVisibility({ structure: {} })).toMatchObject({
       grants: false,
     });
-    expect(getTabVisibility({ structure: { grants: [] } })).toMatchObject({
+    expect(getTabVisibility({ structure: { grants_count: 0 } })).toMatchObject({
       grants: false,
     });
-    expect(getTabVisibility({ structure: { grants: [{}] } })).toMatchObject({
+    expect(getTabVisibility({ structure: { grants_count: 1 } })).toMatchObject({
       grants: true,
     });
   });

package/src/selectors/getStructuresFields.js

@@ -43,6 +43,7 @@ const getFieldsFromStructures = (structuresFields, parentStructures) =>
 
 export const getStructuresFields = createSelector(
   [_.propOr([], "structuresFields"), _.propOr([], "parentStructures")],
-  (structuresFields, parentStructures) =>
-    getFieldsFromStructures(structuresFields, parentStructures)
+  (structuresFields, parentStructures) => {
+    return getFieldsFromStructures(structuresFields, parentStructures);
+  }
 );

package/src/selectors/getTabVisibility.js

@@ -6,7 +6,7 @@ const notEmpty = _.negate(_.isEmpty);
 const notEmptyPath = (path) => _.flow(_.path(path), notEmpty);
 const hasProfile = notEmptyPath("profile");
 
-const fieldsTabVisible = _.conformsTo({ structureFields: notEmpty });
+const fieldsTabVisible = (state) => state?.structure?.data_fields_count > 0;
 
 const profileTabVisible = ({
   userPermissions,
@@ -36,7 +36,8 @@ const notesTabVisible = ({ templatesLoading, templates, structure }) =>
     _.negate(_.isNil)
   )(templates);
 
-const versionsTabVisible = notEmptyPath("structureVersions");
+// const versionsTabVisible = notEmptyPath("structureVersions");
+const versionsTabVisible = (state) => state?.structure?.version_count > 0;
 
 const structureLinksTabVisible = (state) =>
   _.has("create_struct_to_struct_link", state?.structureActions) ||
@@ -56,10 +57,12 @@ const eventsTabVisible = _.flow(
   _.prop("structureVersion"),
   _.isEqual("latest")
 );
-const grantsTabVisible = _.flow(_.path("structure.grants"), notEmpty);
-const metatadaVisible = (state) => !_.isEmpty(_.path(["structure", "structure_type", "metadata_views"])(state))
+const grantsTabVisible = (state) => state?.structure?.grants_count > 0;
 
-export const getTabVisibility = createSelector([state => state], (state) => ({
+const metatadaVisible = (state) =>
+  !_.isEmpty(_.path(["structure", "structure_type", "metadata_views"])(state));
+
+export const getTabVisibility = createSelector([(state) => state], (state) => ({
   fields: fieldsTabVisible(state),
   profile: profileTabVisible(state),
   links: linksTabVisible(state),