@truedat/core 7.5.9 → 7.5.11

package/src/selectors/makeTagOptionsSelector.js

@@ -1,21 +1,17 @@
 import _ from "lodash/fp";
-import {
-  createSelector,
-  createSelectorCreator,
-  defaultMemoize
-} from "reselect";
+import { createSelector, createSelectorCreator, lruMemoize } from "reselect";
 
 const tagsToOptions = _.map(({ id: value, value: { label, type } }) => ({
   value,
-  text: _.defaultTo(type)(label)
+  text: _.defaultTo(type)(label),
 }));
 
-export const makeTagOptionsSelector = targetType => {
+export const makeTagOptionsSelector = (targetType) => {
   const getTagOptions = createSelector(
     _.prop("relationTags"),
     _.flow(_.filter(_.pathEq("value.target_type", targetType)), tagsToOptions)
   );
-  return createSelectorCreator(defaultMemoize, _.isEqual)(
+  return createSelectorCreator(lruMemoize, _.isEqual)(
     getTagOptions,
     _.identity
   );

package/src/selectors/subscopedTemplates.js

@@ -0,0 +1,16 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+
+export const getSubscopes = (allTemplates, mainScope) => {
+  return _.flow(
+    _.filter({ scope: mainScope }),
+    _.map("subscope"),
+    _.uniq,
+    _.filter((el) => el !== null)
+  )(allTemplates);
+};
+
+export const makeGetSubscopes = (mainScope) =>
+  createSelector(_.prop("allTemplates"), (allTemplates) =>
+    getSubscopes(allTemplates, mainScope)
+  );

package/src/selectors/taxonomy.js

@@ -0,0 +1,170 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+import { FormattedMessage } from "react-intl";
+import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
+
+const getDomain = ({ domain }) => domain;
+const getDomains = ({ domains }) => domains;
+const getDomainsFilter = ({ domainsFilter }) => domainsFilter;
+
+const isChildOf =
+  ({ id }) =>
+  ({ parent_id }) =>
+    parent_id === id;
+const isParentOf =
+  ({ parent_id }) =>
+  ({ id }) =>
+    parent_id === id;
+
+const hasNoParentIn = (domains) => (domain) =>
+  !_.some(isParentOf(domain))(domains);
+
+/**
+ * Creates a selector which returns the child domains of the currently selected domain.
+ * If no domain is currently selected, it returns the domains for which no parent is found.
+ */
+const getChildOrRootDomains = createSelector(
+  [getDomain, getDomains],
+  (domain, domains) => {
+    return _.isEmpty(domain)
+      ? _.filter(hasNoParentIn(domains))(domains)
+      : _.filter(isChildOf(domain))(domains);
+  }
+);
+
+const findParentsIn = (domains) => (child) =>
+  _.filter(isParentOf(child))(domains);
+const findChildrenIn = (domains) => (parent) =>
+  _.filter(isChildOf(parent))(domains);
+
+const findDescendents = (parents) => (domains) => {
+  const children = _.flatMap(findChildrenIn(domains))(parents);
+  return _.isEmpty(children)
+    ? children
+    : _.concat(children, findDescendents(children)(domains));
+};
+
+/**
+ * A selector to compute the descendents of the currently selected domain.
+ * If no domain is currently selected, all domains are returned.
+ */
+const getDescendents = createSelector(
+  [getDomain, getDomains],
+  (domain, domains) =>
+    _.isEmpty(domain) ? domains : findDescendents([domain])(domains)
+);
+
+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 domains 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 domains. If a filter is present, the selector
+ * returns descendent domains matching the filter within the scope of the currently selected
+ * domain (or within the scope of all domains if no domain is currently selected).
+ * If no filter is present, the selector returns domains without parents.
+ * Enriches domains with child count.
+ */
+const getVisibleDomains = createSelector(
+  [_getVisibleDomains, getDomains],
+  (visibleDomains, domains) =>
+    visibleDomains
+      .map((d) => ({
+        ...d,
+        children: _.filter(isChildOf(d))(domains),
+      }))
+      .map(({ children, ...d }) => ({ childCount: children.length, ...d }))
+);
+
+const findAncestorsIn = (domains) => (children) => {
+  const parents = _.flatMap(findParentsIn(domains))(children);
+  return _.isEmpty(parents)
+    ? parents
+    : _.concat(findAncestorsIn(domains)(parents), parents);
+};
+
+/**
+ * A selector to obtain the parents of the currently selected domain.
+ */
+const getAncestorDomains = createSelector(
+  [getDomains, getDomain],
+  (domains, domain) =>
+    _.isEmpty(domain) ? [] : findAncestorsIn(domains)([domain])
+);
+
+const reduceTaxonomy = (domains) => (domainsInLevel, level) => {
+  if (domains)
+    return _.reduce((acc, domain) => {
+      const children = _.sortBy(["name"])(findChildrenIn(domains)(domain));
+      return [
+        ...acc,
+        {
+          ...domain,
+          ancestors: findAncestorsIn(domains)([domain]),
+          descendents: _.sortBy(["name"])(findDescendents([domain])(domains)),
+          children,
+          level,
+        },
+        ...reduceTaxonomy(domains)(children, level + 1),
+      ];
+    }, [])(domainsInLevel);
+  return [];
+};
+
+const getDomainSelectorOptions = createSelector([getDomains], (domains) => {
+  const roots = _.flow(
+    _.filter(hasNoParentIn(domains)),
+    _.sortBy(accentInsensitivePathOrder("name"))
+  )(domains);
+  const emptyDomain = _.contains("")(domains)
+    ? [
+        {
+          external_id: null,
+          id: 0,
+          name: <FormattedMessage id={`filter.empty`} />,
+          parent_id: null,
+          ancestors: [],
+          descendents: [],
+          children: [],
+          level: 0,
+        },
+      ]
+    : [];
+
+  return _.concat(emptyDomain, reduceTaxonomy(domains)(roots, 0));
+});
+
+export {
+  getChildOrRootDomains,
+  getDescendents,
+  getDomainSelectorOptions,
+  getFilteredDomains,
+  getVisibleDomains,
+  getAncestorDomains,
+};

package/src/services/__tests__/columnDecorator.spec.js

@@ -29,7 +29,7 @@ describe("services: columnDecorator", () => {
   it("should apply a decorator to a selected field", () => {
     const column = {
       fieldDecorator: _.upperCase,
-      fieldSelector: _.path("foo.bar")
+      fieldSelector: _.path("foo.bar"),
     };
     const obj = { foo: { bar: "baz" } };
     expect(columnDecorator(column)(obj)).toEqual("BAZ");

package/src/services/__tests__/dateFilterFormatter.spec.js

@@ -41,7 +41,7 @@ describe("dateFilterFormatter", () => {
       const filter = dff(foo);
 
       expect(
-        filter == { updated_at: { gte: "2024-04-17", lt: "2024-05-05||+1d" } }
+        filter == { updated_at: { gte: "2024-04-17", lt: "2024-05-05||+1d" } },
       );
     });
 
@@ -61,7 +61,7 @@ describe("dateFilterFormatter", () => {
               start_date: { gte: "2024-04-17" },
               end_date: { lt: "2024-05-05" },
             },
-          }
+          },
       );
     });
 

package/src/services/__tests__/fieldType.spec.js

@@ -6,8 +6,8 @@ describe("services: getFieldType", () => {
       "should return data_type_class if it has value %s",
       (data_type_class) =>
         expect(getFieldType({ metadata: { data_type_class } })).toBe(
-          data_type_class
-        )
+          data_type_class,
+        ),
     );
 
     test.each([

package/src/services/__tests__/filters.spec.js

@@ -61,7 +61,7 @@ describe("services: filters", () => {
           defaultFilters,
           linkable,
           pageSize: size,
-        })
+        }),
       ).toEqual({
         must: { ...must, ...defaultFilters },
         only_linkable: true,

package/src/services/__tests__/message.spec.js

@@ -9,13 +9,13 @@ describe("services: message", () => {
   describe("toErrorList", () => {
     it("should transform an object with array values to a list of strings prepended by the keys", () => {
       expect(
-        toErrorList("foo")({ name: ["unique", "missing"], bar: ["baz"] })
+        toErrorList("foo")({ name: ["unique", "missing"], bar: ["baz"] }),
       ).toEqual(
         expect.arrayContaining([
           { name: "foo.name.unique" },
           { name: "foo.name.missing" },
           { name: "foo.bar.baz" },
-        ])
+        ]),
       );
     });
   });

package/src/services/__tests__/operators.spec.js

@@ -10,7 +10,7 @@ describe("services: operators toItem should transform to existing operator/modif
         name: "name",
         returnType: "boolean",
         args: [{ type: "xyz" }],
-      })
+      }),
     ).toEqual({ id, category: "xyz", name: "name", returnType: "boolean" });
   });
 
@@ -23,7 +23,7 @@ describe("services: operators toItem should transform to existing operator/modif
         scope: "scope",
         returnType: "boolean",
         args: [{ type: "any" }],
-      })
+      }),
     ).toEqual({
       id,
       category: "any",
@@ -45,7 +45,7 @@ describe("services: operators toItem should transform to existing operator/modif
           { name: "start", type: "number" },
           { name: "end", type: "number" },
         ],
-      })
+      }),
     ).toEqual({
       id,
       category: "cat",
@@ -77,7 +77,7 @@ describe("services: operators toItem should transform to existing operator/modif
             values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
           },
         ],
-      })
+      }),
     ).toEqual({
       id,
       category: "date",
@@ -99,7 +99,7 @@ describe("services: operators toItem should transform to existing operator/modif
         group: "references",
         returnType: "boolean",
         args: [{ type: "any" }, { type: "ref" }],
-      })
+      }),
     ).toEqual({
       id,
       category: "any",

package/src/services/__tests__/sort.spec.js

@@ -3,7 +3,7 @@ import {
   i18nOrder,
   lowerDeburr,
   lowerDeburrPath,
-  sortColumn
+  sortColumn,
 } from "../sort";
 
 describe("services: sort", () => {
@@ -12,7 +12,7 @@ describe("services: sort", () => {
       const formatMessage = ({ id }) => id;
       const prefix = "PREFIX";
       expect(i18nOrder(formatMessage, prefix)("ÇÖPùLÂÉ")).toEqual(
-        "prefix.copulae"
+        "prefix.copulae",
       );
     });
   });
@@ -26,7 +26,7 @@ describe("services: sort", () => {
   describe("lowerDeburrPath", () => {
     it("should extract a path, remove accents and convert to lower case", () => {
       expect(lowerDeburrPath("foo.bar")({ foo: { bar: "ÇÖPùLÂÉ" } })).toEqual(
-        "copulae"
+        "copulae",
       );
     });
   });
@@ -34,10 +34,10 @@ describe("services: sort", () => {
   describe("getSortInfo", () => {
     it("should return a column and semantic ui direction map with the first element of an array of sorted columns", () => {
       expect(
-        getSortInfo([{ "name.raw": "desc" }, { "description.raw": "asc" }])
+        getSortInfo([{ "name.raw": "desc" }, { "description.raw": "asc" }]),
       ).toMatchObject({
         column: "name.raw",
-        direction: "descending"
+        direction: "descending",
       });
     });
   });
@@ -60,7 +60,7 @@ describe("services: sort", () => {
         setDirection,
         setColumn,
         currentDirection,
-        currentSortedColumn
+        currentSortedColumn,
       );
       expect(sort.mock.calls.length).toBe(1);
       expect(sort.mock.calls[0][0]).toMatchObject([{ "name.raw": "desc" }]);
@@ -85,11 +85,11 @@ describe("services: sort", () => {
         setDirection,
         setColumn,
         currentDirection,
-        currentSortedColumn
+        currentSortedColumn,
       );
       expect(sort.mock.calls.length).toBe(1);
       expect(sort.mock.calls[0][0]).toMatchObject([
-        { "description.raw": "asc" }
+        { "description.raw": "asc" },
       ]);
       expect(setDirection.mock.calls.length).toBe(1);
       expect(setDirection.mock.calls[0][0]).toEqual("ascending");

package/src/services/__tests__/storage.spec.js

@@ -1,5 +1,22 @@
 import { clearToken, readToken, saveToken } from "../storage";
 
+// Mock localStorage
+beforeEach(() => {
+  // Setup localStorage mock
+  const localStorageMock = {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+    clear: jest.fn(),
+  };
+
+  // Replace the global localStorage with our mock
+  Object.defineProperty(window, "localStorage", {
+    value: localStorageMock,
+    writable: true,
+  });
+});
+
 describe("readToken", () => {
   it("should read the token from local storage", () => {
     readToken();

package/src/services/arrays.js

@@ -1,25 +1,27 @@
-export const dropAt = (i, n = 1) => array =>
-  i >= 0 && i < array.length
-    ? [...array.slice(0, i), ...array.slice(i + n)]
-    : array;
+export const dropAt =
+  (i, n = 1) =>
+  (array) =>
+    i >= 0 && i < array.length
+      ? [...array.slice(0, i), ...array.slice(i + n)]
+      : array;
 
-export const replaceAt = (i, value) => array =>
+export const replaceAt = (i, value) => (array) =>
   i >= 0 && i < array.length
     ? [...array.slice(0, i), value, ...array.slice(i + 1)]
     : array;
 
-export const swap = (i1, i2) => array => {
+export const swap = (i1, i2) => (array) => {
   const j1 = i1 < i2 ? i1 : i2;
   const j2 = i1 > i2 ? i1 : i2;
   return j1 == j2
     ? array
     : j1 >= 0 && j2 < array.length
-    ? [
-        ...array.slice(0, j1),
-        array[j2],
-        ...array.slice(j1 + 1, j2),
-        array[j1],
-        ...array.slice(j2 + 1)
-      ]
-    : array;
+      ? [
+          ...array.slice(0, j1),
+          array[j2],
+          ...array.slice(j1 + 1, j2),
+          array[j1],
+          ...array.slice(j2 + 1),
+        ]
+      : array;
 };

package/src/services/columnDecoratorComponent.js

@@ -1,5 +1,5 @@
 import _ from "lodash/fp";
-import React from "react";
+import { createElement } from "react";
 
 export const columnDecoratorComponent = (column) => (obj) => {
   const { fieldSelector, fieldDecorator, name } = column || {};
@@ -14,7 +14,7 @@ export const columnDecoratorComponent = (column) => (obj) => {
    * https://stackoverflow.com/a/57456179
    */
   return _.isFunction(fieldDecorator)
-    ? React.createElement(fieldDecorator, field)
+    ? createElement(fieldDecorator, field)
     : field;
 };
 

package/src/services/columnDecorators.js

@@ -1,5 +1,4 @@
 import _ from "lodash/fp";
-import React from "react";
 import PropTypes from "prop-types";
 import { FormattedMessage } from "react-intl";
 import Moment from "react-moment";

package/src/services/fieldType.js

@@ -15,11 +15,11 @@ export const getFieldType = ({ metadata, type }) =>
   type === "reference_dataset_field"
     ? "string"
     : _.includes(metadata?.data_type_class)([
-        "boolean",
-        "date",
-        "number",
-        "string",
-        "timestamp",
-      ])
-    ? metadata?.data_type_class
-    : guessType(type);
+          "boolean",
+          "date",
+          "number",
+          "string",
+          "timestamp",
+        ])
+      ? metadata?.data_type_class
+      : guessType(type);

package/src/services/filters.js

@@ -1,5 +1,5 @@
 import _ from "lodash/fp";
-import { getDomainSelectorOptions } from "@truedat/bg/taxonomy/selectors";
+import { getDomainSelectorOptions } from "@truedat/core/selectors/taxonomy";
 
 const intersectionOrDefault = (defaults, overrides) => {
   const v = _.intersection(defaults, overrides);
@@ -12,8 +12,8 @@ const filterCustomizer = (defaults, overrides, key) =>
   key === "taxonomy" && isNonEmptyArray(overrides)
     ? overrides
     : isNonEmptyArray(defaults) && isNonEmptyArray(overrides)
-    ? intersectionOrDefault(defaults, overrides)
-    : undefined;
+      ? intersectionOrDefault(defaults, overrides)
+      : undefined;
 
 export const mergeFilters = _.mergeAllWith(filterCustomizer);
 
@@ -34,8 +34,8 @@ export const formatFilterValues = ({ values, type }) =>
   type === "domain"
     ? getDomainSelectorOptions({ domains: values })
     : _.any(isEmbedded)(values)
-    ? _.map(({ id, name }) => ({ value: id, text: name }))(values)
-    : values;
+      ? _.map(({ id, name }) => ({ value: id, text: name }))(values)
+      : values;
 
 export const toFilterValues = (filterValues) =>
   _.map((v) => (_.isObject(v) ? v.id || v.value : v))(filterValues);

package/src/services/message.js

@@ -32,10 +32,7 @@ export const defaultMessage = (state, type, payload) => {
 
 const changesetErrorTranslation = (error) =>
   // eslint-disable-next-line prettier/prettier
-  _.flow(
-    _.toPairs,
-    _.head,
-    ([field, errorList]) =>
+  _.flow(_.toPairs, _.head, ([field, errorList]) =>
     errorList.length === 1
       ? `${field}.${errorList[0]}`
       : /* This is horrible, showing the raw errorList makes it untranslatable,

package/src/services/operators.js

@@ -4,7 +4,7 @@ const transformType = (type) =>
   ({
     ref: "field",
     reference_dataset_field: "reference_dataset_field",
-  }[type]);
+  })[type];
 
 export const toItem = ({
   name,