@truedat/dd 8.13.6 → 8.13.8

package/src/routines.js

@@ -6,6 +6,7 @@ export const addStructureSelectedFilter = createRoutine(
   "ADD_STRUCTURE_SELECTED_FILTER",
 );
 export const applyUserSearchFilter = createRoutine("APPLY_USER_SEARCH_FILTER");
+export const backgroundGraph = createRoutine("BACKGROUND_GRAPH");
 export const bulkUpdateStructures = createRoutine("BULK_UPDATE_STRUCTURES");
 export const cancelPoll = createRoutine("CANCEL_POLL");
 export const checkoutGrantRequest = createRoutine("CHECKOUT_GRANT_REQUEST");
@@ -66,6 +67,7 @@ export const deleteTag = createRoutine("DELETE_TAG");
 export const deleteUserSearchFilter = createRoutine(
   "DELETE_USER_SEARCH_FILTER",
 );
+export const dismissGraphGeneration = createRoutine("DISMISS_GRAPH_GENERATION");
 export const doStructureNoteAction = createRoutine("DO_STRUCTURE_NOTE_ACTION");
 export const downloadCsvGraph = createRoutine("DOWNLOAD_CSV_GRAPH");
 export const downloadReferenceDataset = createRoutine(
@@ -104,6 +106,7 @@ export const fetchUserSearchFilters = createRoutine(
   "FETCH_USER_SEARCH_FILTERS",
 );
 export const filterStructures = createRoutine("FILTER_STRUCTURES");
+export const graphGeneration = createRoutine("GRAPH_GENERATION");
 export const hoverNode = createRoutine("HOVER_NODE");
 export const initSvg = createRoutine("INIT_SVG");
 export const linkStructureToStructure = createRoutine(

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

@@ -1,20 +1,15 @@
 import { compile } from "path-to-regexp";
-import { takeLatest } from "redux-saga/effects";
+import { takeEvery } from "redux-saga/effects";
 import { testSaga } from "redux-saga-test-plan";
 import { apiJson, apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
 import {
   createGraphRequestSaga,
   createGraphSaga,
-  POLLING_CANCELLED,
   selectLineageQuery,
 } from "../createGraph";
+import { generateGraph } from "../graph/generation";
 import { polling } from "../graph/polling";
-import {
-  cancelPoll,
-  createGraph,
-  fetchGraph,
-  excludeNode,
-} from "../../routines";
+import { createGraph, excludeNode } from "../../routines";
 import { API_GRAPHS, API_GRAPH_HASH } from "../../api";
 
 const graphAcceptedData = {
@@ -50,8 +45,8 @@ describe("sagas: createGraphRequestSaga", () => {
       testSaga(createGraphRequestSaga)
         .next()
         .all([
-          takeLatest(createGraph.TRIGGER, createGraphSaga),
-          takeLatest(excludeNode.TRIGGER, createGraphSaga),
+          takeEvery(createGraph.TRIGGER, createGraphSaga),
+          takeEvery(excludeNode.TRIGGER, createGraphSaga),
         ])
         .finish()
         .isDone();
@@ -68,7 +63,7 @@ describe("sagas: createGraphRequestSaga", () => {
 });
 
 describe("sagas: createGraphSaga", () => {
-  const isRedirected = false;
+  const isRedirected = true;
 
   const query = {
     ids: ["BASILEAII_HIST_PROA_MOROSIDAD [ 2 ] [ 1 ].SOBREGIROCAPITAL"],
@@ -77,74 +72,19 @@ describe("sagas: createGraphSaga", () => {
     isRedirected,
   };
 
-  const graphAccepted = {
-    data: graphAcceptedData,
-    status: 202,
-  };
-
-  const graphCreated = {
-    data: { ...graphData, isRedirected },
-    status: 201,
-  };
-
-  it("should put a success action when uuids are requested and a 201 (created) graph data response is returned", () => {
-    expect(() => {
-      testSaga(createGraphSaga)
-        .next()
-        .select(selectLineageQuery)
-        .next(query)
-        .put(createGraph.request(query))
-        .next()
-        .call(apiJsonPost, API_GRAPHS, query, JSON_OPTS)
-        .next(graphCreated)
-        .put(createGraph.success(graphCreated))
-        .next()
-        .put(createGraph.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should fork a polling task when uuids are requested and a 202 (accepted) graph hash response is returned. Then, wait for task cancellation.", () => {
-    expect(() => {
-      testSaga(createGraphSaga)
-        .next()
-        .select(selectLineageQuery)
-        .next(query)
-        .put(createGraph.request(query))
-        .next()
-        .call(apiJsonPost, API_GRAPHS, query, JSON_OPTS)
-        .next(graphAccepted)
-        .put(fetchGraph.request(graphAccepted))
-        .next()
-        .fork(polling, createGraph, graphAccepted, isRedirected)
-        .next()
-        .take(cancelPoll.TRIGGER)
-        .next()
-        .cancel()
-        .next()
-        .put(createGraph.fulfill())
-        .next()
-        .isDone();
-    }).not.toThrow();
-  });
-
-  it("should put a failure action when the call returns an error", () => {
-    const message = "Request failed";
-    const error = { message };
-
+  it("should pass the query and redirect intent to the shared graph generation", () => {
     expect(() => {
       testSaga(createGraphSaga)
         .next()
         .select(selectLineageQuery)
         .next(query)
-        .put(createGraph.request(query))
-        .next()
-        .call(apiJsonPost, API_GRAPHS, query, JSON_OPTS)
-        .throw(error)
-        .put(createGraph.failure(message))
-        .next()
-        .put(createGraph.fulfill())
+        .call(
+          generateGraph,
+          createGraph,
+          apiJsonPost,
+          [API_GRAPHS, query, JSON_OPTS],
+          isRedirected,
+        )
         .next()
         .isDone();
     }).not.toThrow();
@@ -152,8 +92,6 @@ describe("sagas: createGraphSaga", () => {
 });
 
 describe("generator: polling", () => {
-  const isRedirected = false;
-
   const graphAccepted = {
     data: graphAcceptedData,
     status: 202,
@@ -165,67 +103,64 @@ describe("generator: polling", () => {
   };
 
   const graphCompleted = {
-    data: { ...graphData, isRedirected },
+    data: graphData,
     status: 200,
   };
 
+  const url = compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash });
+  const progressFor = (retry) => ({
+    ...graphPending,
+    data: {
+      ...graphPending.data,
+      graph_hash: graphAccepted.data.graph_hash,
+      retry,
+    },
+  });
+
   it("polling should keep requesting by graph hash until graph is received", () => {
+    const onProgress = jest.fn();
+
     expect(() => {
-      testSaga(polling, createGraph, graphAccepted, isRedirected)
+      testSaga(polling, graphAccepted, onProgress)
         .next()
         .delay(1000)
         .next()
-        .call(
-          apiJson,
-          compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash }),
-          JSON_OPTS,
-        )
+        .call(apiJson, url, JSON_OPTS)
         .next(graphPending)
-        .put(
-          fetchGraph.failure({
-            data: { graph_hash: graphAccepted.data.graph_hash, retry: 1 },
-          }),
-        )
+        .call(onProgress, progressFor(1))
         .next()
-        .cancelled()
-        .next(false)
         .delay(1200)
         .next()
-        .call(
-          apiJson,
-          compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash }),
-          JSON_OPTS,
-        )
-        .next(graphCompleted)
-        .cancelled()
-        .next(false)
-        .put(createGraph.success(graphCompleted))
+        .call(apiJson, url, JSON_OPTS)
+        .next(graphPending)
+        .call(onProgress, progressFor(2))
         .next()
-        .isDone();
+        .delay(1440)
+        .next()
+        .call(apiJson, url, JSON_OPTS)
+        .next(graphCompleted)
+        .returns(graphCompleted);
     }).not.toThrow();
   });
 
-  it("cancel should stop polling and return createGraph failure", () => {
-    expect(() => {
-      testSaga(polling, createGraph, graphAccepted, isRedirected)
-        .next()
-        .delay(1000)
-        .next()
-        .call(
-          apiJson,
-          compile(API_GRAPH_HASH)({ hash: graphAccepted.data.graph_hash }),
-          JSON_OPTS,
-        )
-        .next(graphPending)
-        .put(
-          fetchGraph.failure({
-            data: { graph_hash: graphAccepted.data.graph_hash, retry: 1 },
-          }),
-        )
-        .next()
-        .cancelled()
-        .next(true)
-        .put(createGraph.failure(POLLING_CANCELLED));
-    }).not.toThrow();
+  it("retries a network error without reporting the previous response as new progress", () => {
+    const onProgress = jest.fn();
+    testSaga(polling, graphAccepted, onProgress)
+      .next()
+      .delay(1000)
+      .next()
+      .call(apiJson, url, JSON_OPTS)
+      .next(graphPending)
+      .call(onProgress, progressFor(1))
+      .next()
+      .delay(1200)
+      .next()
+      .call(apiJson, url, JSON_OPTS)
+      .throw(new Error("offline"))
+      .delay(1440)
+      .next()
+      .call(apiJson, url, JSON_OPTS)
+      .next(graphCompleted)
+      .returns(graphCompleted);
   });
 });

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

@@ -0,0 +1,19 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import { fetchGraph } from "../../routines";
+import { API_GRAPH } from "../../api";
+import { fetchGraphSaga } from "../fetchGraph";
+import { generateGraph } from "../graph/generation";
+
+test("loading a saved graph uses the shared generation lifecycle", () => {
+  const payload = { id: "42" };
+  testSaga(fetchGraphSaga, { payload })
+    .next()
+    .call(generateGraph, fetchGraph, apiJson, [
+      compile(API_GRAPH)(payload),
+      JSON_OPTS,
+    ])
+    .next()
+    .isDone();
+});

package/src/sagas/createGraph.js

@@ -1,78 +1,26 @@
 import _ from "lodash/fp";
-import {
-  all,
-  call,
-  cancel,
-  fork,
-  put,
-  select,
-  take,
-  takeLatest,
-} from "redux-saga/effects";
+import { all, call, select, takeEvery } from "redux-saga/effects";
 import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
-import { excludeNode, cancelPoll, createGraph, fetchGraph } from "../routines";
+import { excludeNode, createGraph } from "../routines";
 import { API_GRAPHS } from "../api";
-import { polling } from "./graph/polling";
+import { generateGraph } from "./graph/generation";
 
 export const selectLineageQuery = _.prop("lineageQuery");
 
-export const POLLING_CANCELLED = "Polling cancelled!";
-
 export function* createGraphSaga() {
-  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) */
-    const graphAcceptedOrCreated = yield call(
-      apiJsonPost,
-      API_GRAPHS,
-      body,
-      JSON_OPTS,
-    );
-
-    if (graphAcceptedOrCreated.status === 202) {
-      yield put(fetchGraph.request(graphAcceptedOrCreated));
-      // starts the task in the background
-      const pollingTask = yield fork(
-        polling,
-        createGraph,
-        graphAcceptedOrCreated,
-        body.isRedirected,
-      );
-
-      // 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 (graphAcceptedOrCreated.status === 201) {
-      yield put(
-        createGraph.success({
-          ...graphAcceptedOrCreated,
-          data: {
-            ...graphAcceptedOrCreated.data,
-            isRedirected: body.isRedirected,
-          },
-        }),
-      );
-    }
-  } catch (error) {
-    if (error.response) {
-      const { status, data } = error.response;
-      yield put(createGraph.failure({ status, data }));
-    } else {
-      yield put(createGraph.failure(error.message));
-    }
-  } finally {
-    yield put(createGraph.fulfill());
-  }
+  const body = yield select(selectLineageQuery);
+  yield call(
+    generateGraph,
+    createGraph,
+    apiJsonPost,
+    [API_GRAPHS, body, JSON_OPTS],
+    body.isRedirected,
+  );
 }
 
 export function* createGraphRequestSaga() {
   yield all([
-    takeLatest(createGraph.TRIGGER, createGraphSaga),
-    takeLatest(excludeNode.TRIGGER, createGraphSaga),
+    takeEvery(createGraph.TRIGGER, createGraphSaga),
+    takeEvery(excludeNode.TRIGGER, createGraphSaga),
   ]);
 }

package/src/sagas/fetchGraph.js

@@ -1,52 +1,20 @@
 import _ from "lodash/fp";
 import { compile } from "path-to-regexp";
-import { call, cancel, fork, put, take, takeLatest } from "redux-saga/effects";
+import { call, takeEvery } from "redux-saga/effects";
 import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
 import { API_GRAPH } from "../api";
-import { cancelPoll, fetchGraph } from "../routines";
-import { polling } from "./graph/polling";
+import { fetchGraph } from "../routines";
+import { generateGraph } from "./graph/generation";
 
 const toApiPath = compile(API_GRAPH);
 
 export const selectLineageQuery = _.prop("lineageQuery");
 
 export function* fetchGraphSaga({ payload }) {
-  try {
-    const url = toApiPath(payload);
-    yield put(fetchGraph.request(payload));
-
-    /* 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;
-      yield put(fetchGraph.failure({ status, data }));
-    } else {
-      yield put(fetchGraph.failure(error.message));
-    }
-  } finally {
-    yield put(fetchGraph.fulfill());
-  }
+  const url = toApiPath(payload);
+  yield call(generateGraph, fetchGraph, apiJson, [url, JSON_OPTS]);
 }
 
 export function* fetchGraphRequestSaga() {
-  yield takeLatest(fetchGraph.TRIGGER, fetchGraphSaga);
+  yield takeEvery(fetchGraph.TRIGGER, fetchGraphSaga);
 }

package/src/sagas/graph/__tests__/backgroundGraphs.spec.js

@@ -0,0 +1,22 @@
+import { testSaga } from "redux-saga-test-plan";
+import { watchBackgroundGraphs, selectGeneration } from "../generation";
+import {
+  backgroundGraph,
+  clearGraph,
+  graphGeneration,
+} from "../../../routines";
+
+test("does not keep a timer running when no background graph is pending", () => {
+  const actions = [
+    backgroundGraph.TRIGGER,
+    clearGraph.TRIGGER,
+    graphGeneration.REQUEST,
+  ];
+  testSaga(watchBackgroundGraphs)
+    .next()
+    .take(actions)
+    .next()
+    .select(selectGeneration)
+    .next({ jobs: {} })
+    .take(actions);
+});