@truedat/dd 5.15.2 → 5.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dd",
-  "version": "5.15.2",
+  "version": "5.16.2",
   "description": "Truedat Web Data Dictionary",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -115,5 +115,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 2.0.3 < 2.2"
   },
-  "gitHead": "c1454a0ebd579263c17b3abea9715fc1ca3cf9ae"
+  "gitHead": "4f7b257765169d14b8415107ee59d8b76124f829"
 }

package/src/reducers/graphLoading.js

@@ -22,6 +22,8 @@ export const graphLoading = (state = false, { type, payload }) => {
       return payload || true;
     case createStructureGraph.REQUEST:
       return true;
+    case fetchGraph.SUCCESS:
+    case fetchGraph.FAILURE:
     case fetchGraph.FULFILL:
       return false;
     case fetchGraph.REQUEST:

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

@@ -5,10 +5,10 @@ import { apiJson, apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
 import {
   createGraphRequestSaga,
   createGraphSaga,
-  polling,
   POLLING_CANCELLED,
   selectLineageQuery,
 } from "../createGraph";
+import { polling } from "../graph/polling";
 import {
   cancelPoll,
   createGraph,
@@ -117,7 +117,7 @@ describe("sagas: createGraphSaga", () => {
         .next(graphAccepted)
         .put(fetchGraph.request(graphAccepted))
         .next()
-        .fork(polling, graphAccepted, isRedirected)
+        .fork(polling, createGraph, graphAccepted, isRedirected)
         .next()
         .take(cancelPoll.TRIGGER)
         .next()
@@ -171,7 +171,7 @@ describe("generator: polling", () => {
 
   it("polling should keep requesting by graph hash until graph is received", () => {
     expect(() => {
-      testSaga(polling, graphAccepted, isRedirected)
+      testSaga(polling, createGraph, graphAccepted, isRedirected)
         .next()
         .delay(1000)
         .next()
@@ -207,7 +207,7 @@ describe("generator: polling", () => {
 
   it("cancel should stop polling and return createGraph failure", () => {
     expect(() => {
-      testSaga(polling, graphAccepted, isRedirected)
+      testSaga(polling, createGraph, graphAccepted, isRedirected)
         .next()
         .delay(1000)
         .next()

package/src/sagas/createGraph.js

@@ -1,55 +1,43 @@
-/* eslint-disable fp/no-mutation */
-/* eslint-disable fp/no-let */
 import _ from "lodash/fp";
 import {
   all,
   call,
   cancel,
-  cancelled,
   fork,
   put,
   select,
   take,
   takeLatest,
-  delay,
 } from "redux-saga/effects";
-import { apiJson, apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
-import { compile } from "path-to-regexp";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
 import { excludeNode, cancelPoll, createGraph, fetchGraph } from "../routines";
-import { API_GRAPHS, API_GRAPH_HASH } from "../api";
+import { API_GRAPHS } from "../api";
+import { polling } from "./graph/polling";
 
 export const selectLineageQuery = _.prop("lineageQuery");
 
 export const POLLING_CANCELLED = "Polling cancelled!";
 
-function* exponentialBackoff(base, power) {
-  while (true) {
-    yield Math.pow(base, power);
-    // eslint-disable-next-line fp/no-mutation, no-param-reassign
-    power++;
-  }
-}
-
 export function* createGraphSaga() {
-  let graphAcceptedOrCreated;
   try {
     const body = yield select(selectLineageQuery);
     yield put(createGraph.request(body));
 
     /* graph is either new (accepted) or "created" (actually previously stored
       from an earlier accepted one) */
-    graphAcceptedOrCreated = yield call(
+    const graphAcceptedOrCreated = yield call(
       apiJsonPost,
       API_GRAPHS,
       body,
       JSON_OPTS
     );
 
-    if (graphAcceptedOrCreated.status == 202) {
+    if (graphAcceptedOrCreated.status === 202) {
       yield put(fetchGraph.request(graphAcceptedOrCreated));
       // starts the task in the background
       const pollingTask = yield fork(
         polling,
+        createGraph,
         graphAcceptedOrCreated,
         body.isRedirected
       );
@@ -59,7 +47,7 @@ export function* createGraphSaga() {
       // user clicked stop. cancel the background task
       // this will cause the forked bgSync task to jump into its finally block
       yield cancel(pollingTask);
-    } else if (graphAcceptedOrCreated.status == 201) {
+    } else if (graphAcceptedOrCreated.status === 201) {
       yield put(
         createGraph.success({
           ...graphAcceptedOrCreated,
@@ -82,58 +70,6 @@ export function* createGraphSaga() {
   }
 }
 
-export function* polling(graphAccepted, isRedirected) {
-  const backoff = exponentialBackoff(1.2, 0);
-  let backoffTime,
-    retry = 0,
-    graphResp,
-    isCancelled = false;
-
-  do {
-    backoffTime = backoff.next().value * 1000;
-    yield delay(backoffTime);
-
-    try {
-      graphResp = yield call(
-        apiJson,
-        compile(API_GRAPH_HASH)({
-          hash: graphAccepted.data.graph_hash,
-        }),
-        JSON_OPTS
-      );
-    } catch (error) {
-      if (error.response) {
-        const { status, data } = error.response;
-        yield put(createGraph.failure({ status, data }));
-      } else {
-        yield put(createGraph.failure(error.message));
-      }
-    }
-
-    graphResp?.status == 202 &&
-      (yield put(
-        fetchGraph.failure({
-          data: {
-            graph_hash: graphAccepted.data.graph_hash,
-            retry: ++retry,
-          },
-        })
-      ));
-
-    isCancelled = yield cancelled();
-    isCancelled && (yield put(createGraph.failure(POLLING_CANCELLED)));
-  } while (!isCancelled && graphResp?.status == 202);
-
-  graphResp?.status == 200 && !isCancelled
-    ? yield put(
-        createGraph.success({
-          ...graphResp,
-          data: { ...graphResp.data, isRedirected },
-        })
-      )
-    : yield put(createGraph.failure({}));
-}
-
 export function* createGraphRequestSaga() {
   yield all([
     takeLatest(createGraph.TRIGGER, createGraphSaga),

package/src/sagas/fetchGraph.js

@@ -1,18 +1,40 @@
+import _ from "lodash/fp";
 import { compile } from "path-to-regexp";
-import { call, put, takeLatest } from "redux-saga/effects";
+import { call, cancel, fork, put, take, takeLatest } from "redux-saga/effects";
 import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
-import { fetchGraph } from "../routines";
 import { API_GRAPH } from "../api";
+import { cancelPoll, fetchGraph } from "../routines";
+import { polling } from "./graph/polling";
 
 const toApiPath = compile(API_GRAPH);
 
+export const selectLineageQuery = _.prop("lineageQuery");
+
 export function* fetchGraphSaga({ payload }) {
   try {
     const url = toApiPath(payload);
     yield put(fetchGraph.request(payload));
-    const { data } = yield call(apiJson, url, JSON_OPTS);
 
-    yield put(fetchGraph.success(data));
+    /* graph is either new (202 accepted) or 200 OK*/
+    const graphAcceptedOrFetched = yield call(apiJson, url, JSON_OPTS);
+
+    if (graphAcceptedOrFetched.status === 202) {
+      yield put(fetchGraph.request(graphAcceptedOrFetched));
+      // starts the task in the background
+      const pollingTask = yield fork(
+        polling,
+        fetchGraph,
+        graphAcceptedOrFetched
+      );
+
+      // wait for the user stop action
+      yield take(cancelPoll.TRIGGER);
+      // user clicked stop. cancel the background task
+      // this will cause the forked bgSync task to jump into its finally block
+      yield cancel(pollingTask);
+    } else if (graphAcceptedOrFetched.status === 200) {
+      yield put(yield put(fetchGraph.success(graphAcceptedOrFetched.data)));
+    }
   } catch (error) {
     if (error.response) {
       const { status, data } = error.response;

package/src/sagas/graph/polling.js

@@ -0,0 +1,70 @@
+/* eslint-disable fp/no-mutation */
+/* eslint-disable fp/no-let */
+
+import { call, cancelled, delay, put } from "redux-saga/effects";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import { fetchGraph } from "../../routines";
+import { API_GRAPH_HASH } from "../../api";
+
+export const POLLING_CANCELLED = "Polling cancelled!";
+
+function* exponentialBackoff(base, power) {
+  while (true) {
+    yield Math.pow(base, power);
+    // eslint-disable-next-line fp/no-mutation, no-param-reassign
+    power++;
+  }
+}
+
+export function* polling(routine, graphAccepted, isRedirected) {
+  const backoff = exponentialBackoff(1.2, 0);
+  let backoffTime,
+    retry = 0,
+    graphResp,
+    isCancelled = false;
+
+  do {
+    backoffTime = backoff.next().value * 1000;
+    yield delay(backoffTime);
+
+    try {
+      graphResp = yield call(
+        apiJson,
+        compile(API_GRAPH_HASH)({
+          hash: graphAccepted.data.graph_hash,
+        }),
+        JSON_OPTS
+      );
+    } catch (error) {
+      if (error.response) {
+        const { status, data } = error.response;
+        yield put(routine.failure({ status, data }));
+      } else {
+        yield put(routine.failure(error.message));
+      }
+    }
+
+    graphResp?.status == 202 &&
+      (yield put(
+        fetchGraph.failure({
+          data: {
+            graph_hash: graphAccepted.data.graph_hash,
+            retry: ++retry,
+          },
+        })
+      ));
+
+    isCancelled = yield cancelled();
+    isCancelled && (yield put(routine.failure(POLLING_CANCELLED)));
+  } while (!isCancelled && graphResp?.status == 202);
+
+  graphResp?.status == 200 && !isCancelled
+    ? yield put(
+        routine.success({
+          ...graphResp,
+          data: { ...graphResp.data, isRedirected: isRedirected || false },
+        })
+      )
+    : yield put(routine.failure({}));
+}