@truedat/bg 4.38.7 → 4.40.0

package/src/concepts/reducers/updatingDomain.js

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

package/src/messages/en.js

@@ -13,6 +13,8 @@ export default {
     "Repeated Concept name",
   "bulkUpdate.no.concepts.body": "No concepts selected",
   "bulkUpdate.no.concepts.header": "Empty Search",
+  business_concept_to_field_master: "Master Relation",
+  "conceptDomain.actions.update": "Update",
   "conceptRelations.relationType.business_concept_to_field_master":
     "Master Relation",
   "concept.error.existing.business.concept":
@@ -54,6 +56,8 @@ export default {
   "concept.sharedTo.dropdown.label": "Domain",
   "concept.sharedTo.dropdown.placeholder": "Select domain",
   "concept.sharedTo.header": "Share in",
+  "concept.changeDomain.header": "Edit Domain",
+  "concept.changeDomain.label": "Domain",
   "conceptRelation.actions.create": "New Link",
   "conceptRelation.actions.delete.confirmation.content":
     "The Concept will be unlinked from the field. Are you sure?",

package/src/messages/es.js

@@ -15,6 +15,8 @@ export default {
     "Nombre de concepto repetido",
   "bulkUpdate.no.concepts.body": "Ningún concepto seleccionado",
   "bulkUpdate.no.concepts.header": "Búsqueda vacía",
+  business_concept_to_field_master: "Relación master",
+  "conceptDomain.actions.update": "Actualizar",
   "conceptRelations.relationType.business_concept_to_field_master":
     "Relación master",
   "concept.error.existing.business.concept":
@@ -56,6 +58,8 @@ export default {
   "concept.sharedTo.dropdown.label": "Dominios",
   "concept.sharedTo.dropdown.placeholder": "Seleccionar dominio",
   "concept.sharedTo.header": "Compartir en",
+  "concept.changeDomain.label": "Dominios",
+  "concept.changeDomain.header": "Editar Dominio",
   "conceptRelation.actions.create": "Crear vínculo",
   "conceptRelation.actions.delete.confirmation.content":
     "Se eliminará esta vinculación. ¿Estás seguro?",

package/src/taxonomy/components/DomainsConceptLoader.js

@@ -0,0 +1,43 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { connect } from "react-redux";
+import { Loading } from "@truedat/core/components";
+import { clearDomainsConcept, fetchDomainsConcept } from "../routines";
+
+export class DomainsConceptLoader extends React.Component {
+  static propTypes = {
+    actions: PropTypes.string,
+    clearDomainsConcept: PropTypes.func,
+    fetchDomainsConcept: PropTypes.func,
+    filter: PropTypes.string,
+    domainsConceptLoading: PropTypes.bool,
+  };
+
+  componentDidMount() {
+    const { fetchDomainsConcept, actions, filter } = this.props;
+    fetchDomainsConcept({ actions, filter });
+  }
+
+  componentWillUnmount() {
+    const { clearDomainsConcept } = this.props;
+    clearDomainsConcept();
+  }
+
+  render() {
+    const { domainsConceptLoading } = this.props;
+    if (domainsConceptLoading) {
+      return <Loading />;
+    } else {
+      return null;
+    }
+  }
+}
+
+const mapStateToProps = ({ domainsConceptLoading }) => ({
+  domainsConceptLoading,
+});
+
+export default connect(mapStateToProps, {
+  clearDomainsConcept,
+  fetchDomainsConcept,
+})(DomainsConceptLoader);

package/src/taxonomy/components/__tests__/DomainsConceptLoader.spec.js

@@ -0,0 +1,38 @@
+import React from "react";
+import { mount } from "enzyme";
+import { DomainsConceptLoader } from "../DomainsConceptLoader";
+
+const getProps = () => ({
+  clearDomainsConcept: jest.fn(),
+  domainsConceptLoading: false,
+  fetchDomainsConcept: jest.fn(),
+  actions: "create_ingest",
+  filter: "all",
+});
+
+describe("<DomainsConceptLoader />", () => {
+  it("calls fetchDomainsConcept when component mounts but not when it unmounts", () => {
+    const props = getProps();
+    const wrapper = mount(<DomainsConceptLoader {...props} />);
+    expect(props.fetchDomainsConcept).toHaveBeenCalledTimes(1);
+    wrapper.unmount();
+    expect(props.fetchDomainsConcept).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls clearDomainsConcept and clearDomainDefaultFilters when component unmounts but not when it mounts", () => {
+    const props = getProps();
+    const wrapper = mount(<DomainsConceptLoader {...props} />);
+    expect(props.clearDomainsConcept).toHaveBeenCalledTimes(0);
+    wrapper.unmount();
+    expect(props.clearDomainsConcept).toHaveBeenCalledTimes(1);
+  });
+
+  it("renders Loading when domainLoading is true", () => {
+    const props = getProps();
+
+    const wrapper = mount(
+      <DomainsConceptLoader {...{ ...props, domainsConceptLoading: true }} />
+    );
+    expect(wrapper.find("Loading").length).toBe(1);
+  });
+});

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

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

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

@@ -0,0 +1,30 @@
+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/domainsConcept.js

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,12 @@
+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/index.js

@@ -5,6 +5,8 @@ import { domainLoading } from "./domainLoading";
 import { domainMemberDeleting } from "./domainMemberDeleting";
 import { domainMemberSaving } from "./domainMemberSaving";
 import { domainMembers } from "./domainMembers";
+import { domainsConcept } from "./domainsConcept";
+import { domainsConceptLoading } from "./domainsConceptLoading";
 import { domainConceptChildren } from "./domainConceptChildren";
 import { domainConceptChildrenLoading } from "./domainConceptChildrenLoading";
 import { domainMembersActions } from "./domainMembersActions";
@@ -26,6 +28,8 @@ export {
   domainMembersActions,
   domainMembers,
   domainMembersLoading,
+  domainsConcept,
+  domainsConceptLoading,
   domainConceptChildren,
   domainConceptChildrenLoading,
   domainRedirect,

package/src/taxonomy/routines.js

@@ -1,6 +1,8 @@
 import { createRoutine } from "redux-saga-routines";
 
 export const fetchDomains = createRoutine("FETCH_DOMAINS");
+export const fetchDomainsConcept = createRoutine("FETCH_CONCEPT_DOMAINS");
+export const clearDomainsConcept = createRoutine("CLEAR_DOMAINS");
 export const clearDomains = createRoutine("CLEAR_DOMAINS");
 export const filterDomains = createRoutine("FILTER_DOMAINS");
 export const clearDomainConceptChildren = createRoutine(

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

@@ -0,0 +1,93 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  fetchDomainsConceptRequestSaga,
+  fetchDomainsConceptSaga,
+} from "../fetchDomainsConcept";
+import { fetchDomainsConcept } from "../../routines";
+import { API_DOMAINS } from "../../api";
+
+describe("sagas: fetchDomainsConceptRequestSaga", () => {
+  it("should invoke fetchDomainsConceptSaga on trigger", () => {
+    expect(() => {
+      testSaga(fetchDomainsConceptRequestSaga)
+        .next()
+        .takeLatest(fetchDomainsConcept.TRIGGER, fetchDomainsConceptSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(fetchDomainsConceptRequestSaga)
+        .next()
+        .takeLatest("FOO", fetchDomainsConceptSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: fetchDomainsConceptSaga", () => {
+  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(fetchDomainsConceptSaga, {})
+        .next()
+        .put(fetchDomainsConcept.request())
+        .next()
+        .call(apiJson, API_DOMAINS, JSON_OPTS)
+        .next({ data })
+        .put(fetchDomainsConcept.success({ data, actions }))
+        .next()
+        .put(fetchDomainsConcept.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(fetchDomainsConceptSaga, { payload })
+        .next()
+        .put(fetchDomainsConcept.request(payload))
+        .next()
+        .call(apiJson, API_DOMAINS, json_opts)
+        .next({ data })
+        .put(fetchDomainsConcept.success({ data, actions }))
+        .next()
+        .put(fetchDomainsConcept.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(fetchDomainsConceptSaga, {})
+        .next()
+        .put(fetchDomainsConcept.request())
+        .next()
+        .call(apiJson, API_DOMAINS, JSON_OPTS)
+        .throw(error)
+        .put(fetchDomainsConcept.failure(message))
+        .next()
+        .put(fetchDomainsConcept.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

package/src/taxonomy/sagas/fetchDomainsConcept.js

@@ -0,0 +1,37 @@
+import _ from "lodash/fp";
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchDomainsConcept } from "../routines";
+import { API_DOMAINS } from "../api";
+
+export function* fetchDomainsConceptSaga({ payload }) {
+  try {
+    const { actions, filter } = payload || {};
+    const json_opts = actions
+      ? {
+          ...JSON_OPTS,
+          params: {
+            actions: _.flow(_.castArray, _.join(","))(actions),
+            filter,
+          },
+        }
+      : JSON_OPTS;
+    const url = API_DOMAINS;
+    yield put(fetchDomainsConcept.request(payload));
+    const { data } = yield call(apiJson, url, json_opts);
+    yield put(fetchDomainsConcept.success({ data, actions }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchDomainsConcept.failure({ status, data }));
+    } else {
+      yield put(fetchDomainsConcept.failure(error.message));
+    }
+  } finally {
+    yield put(fetchDomainsConcept.fulfill());
+  }
+}
+
+export function* fetchDomainsConceptRequestSaga() {
+  yield takeLatest(fetchDomainsConcept.TRIGGER, fetchDomainsConceptSaga);
+}

package/src/taxonomy/sagas/index.js

@@ -4,6 +4,7 @@ import { deleteDomainMemberRequestSaga } from "./deleteDomainMember";
 import { updateDomainMemberRequestSaga } from "./updateDomainMember";
 import { updateDomainRequestSaga } from "./updateDomain";
 import { deleteDomainRequestSaga } from "./deleteDomain";
+import { fetchDomainsConceptRequestSaga } from "./fetchDomainsConcept";
 import { fetchDomainConceptChildrenRequestSaga } from "./fetchDomainConceptChildren";
 import { fetchDomainMembersRequestSaga } from "./fetchDomainMembers";
 import { fetchDomainRequestSaga } from "./fetchDomain";
@@ -16,6 +17,7 @@ export {
   updateDomainMemberRequestSaga,
   updateDomainRequestSaga,
   deleteDomainRequestSaga,
+  fetchDomainsConceptRequestSaga,
   fetchDomainConceptChildrenRequestSaga,
   fetchDomainMembersRequestSaga,
   fetchDomainRequestSaga,
@@ -29,6 +31,7 @@ export default [
   updateDomainMemberRequestSaga(),
   updateDomainRequestSaga(),
   deleteDomainRequestSaga(),
+  fetchDomainsConceptRequestSaga(),
   fetchDomainConceptChildrenRequestSaga(),
   fetchDomainMembersRequestSaga(),
   fetchDomainRequestSaga(),

package/src/taxonomy/selectors/__tests__/getDomainSelectorOptions.spec.js

@@ -0,0 +1,66 @@
+import { getDomainSelectorOptions } from "..";
+
+describe("selectors: getDomainSelectorOptions", () => {
+  const domains = [
+    { id: 1, name: "domain1" },
+    { id: 2, name: "domain2", parent_id: 1 },
+    { id: 3, name: "domain3" },
+    { id: 4, name: "domain4", parent_id: 0 },
+    { id: 5, name: "domain2", parent_id: 2 },
+  ];
+
+  it("foo", () => {
+    const options = getDomainSelectorOptions({ domains });
+    expect(options).toEqual([
+      {
+        ancestors: [],
+        children: [{ id: 2, name: "domain2", parent_id: 1 }],
+        descendents: [
+          { id: 2, name: "domain2", parent_id: 1 },
+          { id: 5, name: "domain2", parent_id: 2 },
+        ],
+        id: 1,
+        level: 0,
+        name: "domain1",
+      },
+      {
+        ancestors: [{ id: 1, name: "domain1" }],
+        children: [{ id: 5, name: "domain2", parent_id: 2 }],
+        descendents: [{ id: 5, name: "domain2", parent_id: 2 }],
+        id: 2,
+        level: 1,
+        name: "domain2",
+        parent_id: 1,
+      },
+      {
+        ancestors: [
+          { id: 1, name: "domain1" },
+          { id: 2, name: "domain2", parent_id: 1 },
+        ],
+        children: [],
+        descendents: [],
+        id: 5,
+        level: 2,
+        name: "domain2",
+        parent_id: 2,
+      },
+      {
+        ancestors: [],
+        children: [],
+        descendents: [],
+        id: 3,
+        level: 0,
+        name: "domain3",
+      },
+      {
+        ancestors: [],
+        children: [],
+        descendents: [],
+        id: 4,
+        level: 0,
+        name: "domain4",
+        parent_id: 0,
+      },
+    ]);
+  });
+});

package/src/taxonomy/selectors/getDomainsConcept.js

@@ -0,0 +1,176 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
+import { getPrimaryActions, getSecondaryActions } from "./getDomainActions";
+import { getDomainGroups } from "./getDomainGroups";
+import { domainParentOptionsSelector } from "./domainParentOptionsSelector";
+
+const getDomain = ({ domain }) => domain;
+const getDomains = ({ domainsConcept }) => domainsConcept;
+const getDomainsFilter = ({ domainsFilter }) => domainsFilter;
+
+const isChildOf =
+  ({ id }) =>
+  ({ parent_id }) =>
+    parent_id === id;
+const isParentOf =
+  ({ parent_id }) =>
+  ({ id }) =>
+    parent_id === id;
+
+const hasNoParentIn = (domainsConcept) => (domain) =>
+  !_.some(isParentOf(domain))(domainsConcept);
+
+/**
+ * Creates a selector which returns the child domainsConcept of the currently selected domain.
+ * If no domain is currently selected, it returns the domainsConcept for which no parent is found.
+ */
+const getChildOrRootDomains = createSelector(
+  [getDomain, getDomains],
+  (domain, domainsConcept) => {
+    return _.isEmpty(domain)
+      ? _.filter(hasNoParentIn(domainsConcept))(domainsConcept)
+      : _.filter(isChildOf(domain))(domainsConcept);
+  }
+);
+
+const findParentsIn = (domainsConcept) => (child) =>
+  _.filter(isParentOf(child))(domainsConcept);
+const findChildrenIn = (domainsConcept) => (parent) =>
+  _.filter(isChildOf(parent))(domainsConcept);
+
+const findDescendents = (parents) => (domainsConcept) => {
+  const children = _.flatMap(findChildrenIn(domainsConcept))(parents);
+  return _.isEmpty(children)
+    ? children
+    : _.concat(children, findDescendents(children)(domainsConcept));
+};
+
+/**
+ * A selector to compute the descendents of the currently selected domain.
+ * If no domain is currently selected, all domainsConcept are returned.
+ */
+const getDescendents = createSelector(
+  [getDomain, getDomains],
+  (domain, domainsConcept) =>
+    _.isEmpty(domain)
+      ? domainsConcept
+      : findDescendents([domain])(domainsConcept)
+);
+
+const toSearchable = _.flow(_.deburr, _.toLower, _.trim);
+
+const isValidFilter = (filter) => !_.isEmpty(toSearchable(filter));
+
+const matchesFilter = (filter) =>
+  _.flow(
+    _.at(["name", "description"]),
+    _.map(toSearchable),
+    _.some(_.includes(toSearchable(filter)))
+  );
+
+/**
+ * A selector to compute the domainsConcept whose name or description matches a search string.
+ * If a domain is currently selected, the scope of the search will be limited to descendents
+ * of the currently selected domain. The search is case-insensitive and accent-insensitive.
+ */
+const getFilteredDomains = createSelector(
+  [getDescendents, getDomainsFilter],
+  (descendents, domainsFilter) =>
+    isValidFilter(domainsFilter)
+      ? _.filter(matchesFilter(domainsFilter))(descendents)
+      : []
+);
+
+const _getVisibleDomains = createSelector(
+  [getDomainsFilter, getFilteredDomains, getChildOrRootDomains],
+  (filter, filteredDomains, childOrRootDomains) =>
+    _.isEmpty(filter) ? childOrRootDomains : filteredDomains
+);
+
+/**
+ * A selector to compute the currently visible domainsConcept. If a filter is present, the selector
+ * returns descendent domainsConcept matching the filter within the scope of the currently selected
+ * domain (or within the scope of all domainsConcept if no domain is currently selected).
+ * If no filter is present, the selector returns domainsConcept without parents.
+ * Enriches domainsConcept with child count.
+ */
+const getVisibleDomains = createSelector(
+  [_getVisibleDomains, getDomains],
+  (visibleDomains, domainsConcept) =>
+    visibleDomains
+      .map((d) => ({
+        ...d,
+        children: _.filter(isChildOf(d))(domainsConcept),
+      }))
+      .map(({ children, ...d }) => ({ childCount: children.length, ...d }))
+);
+
+/**
+ * A selector to obtain unique domain types, sorted case-insensitively.
+ */
+const getDomainTypes = createSelector(
+  getDomains,
+  _.flow(_.map("type"), _.filter(_.isString), _.uniq, _.sortBy(_.toLower))
+);
+
+const findAncestorsIn = (domainsConcept) => (children) => {
+  const parents = _.flatMap(findParentsIn(domainsConcept))(children);
+  return _.isEmpty(parents)
+    ? parents
+    : _.concat(findAncestorsIn(domainsConcept)(parents), parents);
+};
+
+/**
+ * A selector to obtain the parents of the currently selected domain.
+ */
+const getAncestorDomains = createSelector(
+  [getDomains, getDomain],
+  (domainsConcept, domain) =>
+    _.isEmpty(domain) ? [] : findAncestorsIn(domainsConcept)([domain])
+);
+
+const reduceTaxonomy = (domainsConcept) => (domainsInLevel, level) => {
+  if (domainsConcept)
+    return _.reduce((acc, domain) => {
+      const children = findChildrenIn(domainsConcept)(domain);
+      return [
+        ...acc,
+        {
+          ...domain,
+          ancestors: findAncestorsIn(domainsConcept)([domain]),
+          descendents: findDescendents([domain])(domainsConcept),
+          children,
+          level,
+        },
+        ...reduceTaxonomy(domainsConcept)(children, level + 1),
+      ];
+    }, [])(domainsInLevel);
+  return [];
+};
+
+const getDomainConceptSelectorOptions = createSelector(
+  [getDomains],
+  (domainsConcept) => {
+    const roots = getChildOrRootDomains({
+      domainsConcept: _.sortBy(accentInsensitivePathOrder("name"))(
+        domainsConcept
+      ),
+    });
+    return reduceTaxonomy(domainsConcept)(roots, 0);
+  }
+);
+
+export {
+  domainParentOptionsSelector,
+  getChildOrRootDomains,
+  getDescendents,
+  getDomainConceptSelectorOptions,
+  getFilteredDomains,
+  getVisibleDomains,
+  getDomainGroups,
+  getDomainTypes,
+  getAncestorDomains,
+  getPrimaryActions,
+  getSecondaryActions,
+};

package/src/taxonomy/selectors/index.js

@@ -148,9 +148,10 @@ const reduceTaxonomy = (domains) => (domainsInLevel, level) => {
 };
 
 const getDomainSelectorOptions = createSelector([getDomains], (domains) => {
-  const roots = getChildOrRootDomains({
-    domains: _.sortBy(accentInsensitivePathOrder("name"))(domains),
-  });
+  const roots = _.flow(
+    _.filter(hasNoParentIn(domains)),
+    _.sortBy(accentInsensitivePathOrder("name"))
+  )(domains);
   return reduceTaxonomy(domains)(roots, 0);
 });