@truedat/dd 5.15.2 → 5.16.3

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

@@ -0,0 +1,91 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  fetchGrantRequestsFiltersRequestSaga,
+  fetchGrantRequestsFiltersSaga,
+} from "../fetchGrantRequestsFilters";
+import { fetchGrantRequestsFilters } from "../../routines";
+import { API_GRANT_REQUESTS_FILTERS_SEARCH } from "../../api";
+
+const filters = {
+  filters: {
+    current_status: ["pending"],
+  },
+};
+const payload = {
+  filters: filters,
+};
+
+describe("sagas: fetchGrantRequestsFiltersRequestSaga", () => {
+  it("should invoke fetchGrantRequestsFiltersSaga on fetchGrantRequestsFilters.TRIGGER", () => {
+    expect(() => {
+      testSaga(fetchGrantRequestsFiltersRequestSaga)
+        .next()
+        .takeLatest(
+          fetchGrantRequestsFilters.TRIGGER,
+          fetchGrantRequestsFiltersSaga
+        )
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(fetchGrantRequestsFiltersRequestSaga)
+        .next()
+        .takeLatest("FOO", fetchGrantRequestsFiltersRequestSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: fetchGrantRequestsFiltersSaga", () => {
+  const data = {
+    data: { foo: {}, var: {} },
+  };
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(fetchGrantRequestsFiltersSaga, { payload })
+        .next()
+        .put(fetchGrantRequestsFilters.request())
+        .next()
+        .call(
+          apiJsonPost,
+          API_GRANT_REQUESTS_FILTERS_SEARCH,
+          payload,
+          JSON_OPTS
+        )
+        .next({ data })
+        .put(fetchGrantRequestsFilters.success({ data }))
+        .next()
+        .put(fetchGrantRequestsFilters.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(fetchGrantRequestsFiltersSaga, { payload })
+        .next()
+        .put(fetchGrantRequestsFilters.request())
+        .next()
+        .call(
+          apiJsonPost,
+          API_GRANT_REQUESTS_FILTERS_SEARCH,
+          payload,
+          JSON_OPTS
+        )
+        .throw(error)
+        .put(fetchGrantRequestsFilters.failure(message))
+        .next()
+        .put(fetchGrantRequestsFilters.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,92 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  fetchGrantRequestsSearchRequestSaga,
+  fetchGrantRequestsSearchSaga,
+} from "../fetchGrantRequestsSearch";
+import { fetchGrantRequestsSearch } from "../../routines";
+import { API_GRANT_REQUESTS_SEARCH } from "../../api";
+
+const body = {
+  must: {
+    current_status: ["pending"],
+  },
+};
+const payload = body;
+
+describe("sagas: fetchGrantRequestsSearchRequestSaga", () => {
+  it("should invoke fetchGrantRequestsSearchSaga on fetchGrantRequestsSearch.TRIGGER", () => {
+    expect(() => {
+      testSaga(fetchGrantRequestsSearchRequestSaga)
+        .next()
+        .debounce(
+          200,
+          fetchGrantRequestsSearch.TRIGGER,
+          fetchGrantRequestsSearchSaga
+        )
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(fetchGrantRequestsSearchRequestSaga)
+        .next()
+        .takeLatest("FOO", fetchGrantRequestsSearchRequestSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: fetchGrantRequestsSearchSaga", () => {
+  const data = {
+    _permissions: ["Role1", "Role2"],
+    data: [
+      {
+        id: 385,
+      },
+      {
+        id: 385,
+      },
+    ],
+  };
+
+  const headers = {
+    "x-total-count": "2",
+  };
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(fetchGrantRequestsSearchSaga, { payload })
+        .next()
+        .put(fetchGrantRequestsSearch.request(body))
+        .next()
+        .call(apiJsonPost, API_GRANT_REQUESTS_SEARCH, body, JSON_OPTS)
+        .next({ data, headers })
+        .put(fetchGrantRequestsSearch.success({ data, headers }))
+        .next()
+        .put(fetchGrantRequestsSearch.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(fetchGrantRequestsSearchSaga, { payload })
+        .next()
+        .put(fetchGrantRequestsSearch.request(body))
+        .next()
+        .call(apiJsonPost, API_GRANT_REQUESTS_SEARCH, body, JSON_OPTS)
+        .throw(error)
+        .put(fetchGrantRequestsSearch.failure(message))
+        .next()
+        .put(fetchGrantRequestsSearch.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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/fetchGrantRequestsFilters.js

@@ -0,0 +1,32 @@
+import _ from "lodash/fp";
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchGrantRequestsFilters } from "../routines";
+import { API_GRANT_REQUESTS_FILTERS_SEARCH } from "../api";
+
+export function* fetchGrantRequestsFiltersSaga(payload) {
+  try {
+    yield put(fetchGrantRequestsFilters.request());
+    const url = API_GRANT_REQUESTS_FILTERS_SEARCH;
+    const filters = _.propOr({}, "payload.filters")(payload);
+    const body = { filters };
+    const { data } = yield call(apiJsonPost, url, body, JSON_OPTS);
+    yield put(fetchGrantRequestsFilters.success({ data }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchGrantRequestsFilters.failure({ status, data }));
+    } else {
+      yield put(fetchGrantRequestsFilters.failure(error.message));
+    }
+  } finally {
+    yield put(fetchGrantRequestsFilters.fulfill());
+  }
+}
+
+export function* fetchGrantRequestsFiltersRequestSaga() {
+  yield takeLatest(
+    fetchGrantRequestsFilters.TRIGGER,
+    fetchGrantRequestsFiltersSaga
+  );
+}

package/src/sagas/fetchGrantRequestsSearch.js

@@ -0,0 +1,30 @@
+import { call, put, debounce } from "redux-saga/effects";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchGrantRequestsSearch } from "../routines";
+import { API_GRANT_REQUESTS_SEARCH } from "../api";
+
+export function* fetchGrantRequestsSearchSaga({ payload: body }) {
+  try {
+    const url = API_GRANT_REQUESTS_SEARCH;
+    yield put(fetchGrantRequestsSearch.request(body));
+    const { data, headers } = yield call(apiJsonPost, url, body, JSON_OPTS);
+    yield put(fetchGrantRequestsSearch.success({ data, headers }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchGrantRequestsSearch.failure({ status, data }));
+    } else {
+      yield put(fetchGrantRequestsSearch.failure(error.message));
+    }
+  } finally {
+    yield put(fetchGrantRequestsSearch.fulfill());
+  }
+}
+
+export function* fetchGrantRequestsSearchRequestSaga() {
+  yield debounce(
+    200,
+    fetchGrantRequestsSearch.TRIGGER,
+    fetchGrantRequestsSearchSaga
+  );
+}

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({}));
+}

package/src/sagas/index.js

@@ -23,6 +23,8 @@ import { downloadGrantsRequestSaga } from "./downloadGrants";
 import { downloadReferenceDatasetRequestSaga } from "./downloadReferenceDataset";
 import { downloadStructuresRequestSaga } from "./downloadStructures";
 import { fetchGrantFiltersRequestSaga } from "./fetchGrantFilters";
+import { fetchGrantRequestsFiltersRequestSaga } from "./fetchGrantRequestsFilters";
+import { fetchGrantRequestsSearchRequestSaga } from "./fetchGrantRequestsSearch";
 import { fetchGrantRequestRequestSaga } from "./fetchGrantRequest";
 import { fetchGrantRequestsRequestSaga } from "./fetchGrantRequests";
 import { fetchGrantsRequestSaga } from "./fetchGrants";
@@ -85,6 +87,8 @@ export {
   downloadStructuresRequestSaga,
   fetchGrantFiltersRequestSaga,
   fetchGrantRequestRequestSaga,
+  fetchGrantRequestsFiltersRequestSaga,
+  fetchGrantRequestsSearchRequestSaga,
   fetchGrantRequestsRequestSaga,
   fetchGrantsRequestSaga,
   fetchGraphRequestSaga,
@@ -148,6 +152,8 @@ export default [
   fetchGrantFiltersRequestSaga(),
   fetchGrantRequestRequestSaga(),
   fetchGrantRequestsRequestSaga(),
+  fetchGrantRequestsFiltersRequestSaga(),
+  fetchGrantRequestsSearchRequestSaga(),
   fetchGrantsRequestSaga(),
   fetchGraphRequestSaga(),
   fetchLineageEventsRequestSaga(),

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

@@ -0,0 +1,15 @@
+import { getGrantRequestsAvailableFilters } from "..";
+
+const foo = { values: ["foo1", "foo2"] };
+const bar = { values: ["bar1", "bar2"] };
+const baz = { values: ["baz1", "baz2"] };
+
+describe("selectors: getGrantRequestsAvailableFilters", () => {
+  const grantRequestsFilters = { foo, bar, baz };
+  const grantRequestsActiveFilters = { baz: [] };
+  const state = { grantRequestsFilters, grantRequestsActiveFilters };
+
+  it("should return the keys of the grant request filters which are not currently active", () => {
+    expect(getGrantRequestsAvailableFilters(state)).toEqual(["foo", "bar"]);
+  });
+});

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

@@ -0,0 +1,19 @@
+import { getGrantRequestsFilterTypes } from "..";
+
+const foo = { type: "fooType", values: ["foo1", "foo2"] };
+const bar = { type: "barType", values: ["bar1", "bar2"] };
+const bay = { values: ["bay1"] };
+
+describe("selectors: getGrantRequestsFilterTypes", () => {
+  const state = { grantRequestsFilters: { foo, bar, bay } };
+
+  const expected = {
+    foo: "fooType",
+    bar: "barType",
+    bay: undefined,
+  };
+
+  it("should return a map with filter types", () => {
+    expect(getGrantRequestsFilterTypes(state)).toEqual(expected);
+  });
+});

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

@@ -0,0 +1,30 @@
+import _ from "lodash/fp";
+import {
+  defaultGrantRequestsSearchTableColumns,
+  getGrantRequestsSearchColumns,
+} from "..";
+
+describe("selectors: getGrantRequestsSearchColumns", () => {
+  const state = {};
+
+  it("get default grant requests columns", () => {
+    const columns = getGrantRequestsSearchColumns(state);
+    expect(_.map("name")(columns)).toEqual(
+      _.flow(_.map("name"))(defaultGrantRequestsSearchTableColumns)
+    );
+  });
+
+  it("get specified columns in reducer", () => {
+    const grantRequestsSearchColumns = [
+      {
+        name: "foo",
+        fieldDecorator: _.identity,
+      },
+    ];
+    const columns = getGrantRequestsSearchColumns({
+      ...state,
+      grantRequestsSearchColumns,
+    });
+    expect(columns).toStrictEqual(grantRequestsSearchColumns);
+  });
+});

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

@@ -0,0 +1,24 @@
+import { getGrantRequestsSearchQuery } from "..";
+
+const grantRequestSearchQuery = { query: "foo" };
+const grantRequestsActiveFilters = { foo: "bar", bar: "baz" };
+const grantRequestsDefaultFilters = { status: "some status" };
+
+describe("selectors: getGrantRequestsSearchQuery", () => {
+  const state = {
+    grantRequestsDefaultFilters,
+    grantRequestsActiveFilters,
+    grantRequestSearchQuery,
+  };
+  it("get query merged with defaults", () => {
+    const res = getGrantRequestsSearchQuery({
+      grantRequestSearchQuery,
+      grantRequestsDefaultFilters,
+      grantRequestsActiveFilters,
+    });
+    expect(res).toEqual({
+      query: "foo",
+      filters: { foo: "bar", bar: "baz", status: "some status" },
+    });
+  });
+});

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

@@ -0,0 +1,15 @@
+import { getGrantRequestsSelectedFilterActiveValues } from "..";
+
+const foo = ["foo1", "foo2"];
+const bar = ["bar1", "bar2"];
+const baz = ["baz1", "baz2"];
+
+describe("selectors: getGrantRequestsSelectedFilterActiveValues", () => {
+  const grantRequestsActiveFilters = { foo: ["foo1"] };
+  const grantRequestsSelectedFilter = "foo";
+  const state = { grantRequestsActiveFilters, grantRequestsSelectedFilter };
+
+  it("should return the active values of the currently selected grant filters", () => {
+    expect(getGrantRequestsSelectedFilterActiveValues(state)).toEqual(["foo1"]);
+  });
+});

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

@@ -0,0 +1,15 @@
+import { getGrantRequestsSelectedFilterValues } from "../../../../dd/src/selectors";
+
+const foo = { values: ["foo1", "foo2"] };
+const bar = { values: ["bar1", "bar2"] };
+const baz = { values: ["baz1", "baz2"] };
+
+describe("selectors: getGrantRequestsSelectedFilterValues", () => {
+  const grantRequestsSelectedFilter = "foo";
+  const grantRequestsFilters = { foo, bar, baz };
+  const state = { grantRequestsSelectedFilter, grantRequestsFilters };
+
+  it("should return the values of the currently selected Grant Request filters", () => {
+    expect(getGrantRequestsSelectedFilterValues(state)).toEqual(foo.values);
+  });
+});

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

@@ -0,0 +1,13 @@
+import { getGrantRequestsSelectedFilters } from "..";
+
+describe("selectors: getGrantRequestsSelectedFilters", () => {
+  const grantRequestsActiveFilters = {
+    baz: ["baz1", "baz2"],
+    must_not_approved_by: ["approver 1"],
+  };
+  const state = { grantRequestsActiveFilters };
+
+  it("should return the keys of the structure filters which are currently active", () => {
+    expect(getGrantRequestsSelectedFilters(state)).toEqual(["baz"]);
+  });
+});

package/src/selectors/getGrantRequestsAvailableFilters.js

@@ -0,0 +1,17 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+import { getGrantRequestsSelectedFilters } from "./getGrantRequestsSelectedFilters";
+
+const getGrantRequestsFilters = _.propOr({}, "grantRequestsFilters");
+
+export const getGrantRequestsAvailableFilters = createSelector(
+  getGrantRequestsFilters,
+  getGrantRequestsSelectedFilters,
+  (grantRequestsFilters, grantRequestsSelectedFilters) => {
+    return _.flow(
+      _.omitBy(({ values }) => _.size(values) < 2),
+      _.keys,
+      _.without(grantRequestsSelectedFilters)
+    )(grantRequestsFilters);
+  }
+);

package/src/selectors/getGrantRequestsFilterTypes.js

@@ -0,0 +1,7 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+
+export const getGrantRequestsFilterTypes = createSelector(
+  _.prop("grantRequestsFilters"),
+  _.mapValues("type")
+);