@truedat/dq 4.53.0 → 4.53.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [4.53.2] 2022-10-07
+
+### Changed
+
+- [TD-5226] Use `useOperators` hook to load operators
+
+## [4.53.1] 2022-10-05
+
+### Changed
+
+- [TD-5098] Improve modifiers behaviour
+  - Fix field type selector for StructureFieldsDrowdown
+  - Fix fields applied modifiers for StructureFieldsDrowdown
+  - Allow multiple modifiers in ruleImplementationOperators reducer
+
 ## [4.53.0] 2022-10-04
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.53.0",
+  "version": "4.53.2",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -34,7 +34,7 @@
     "@testing-library/jest-dom": "^5.16.4",
     "@testing-library/react": "^12.0.0",
     "@testing-library/user-event": "^13.2.1",
-    "@truedat/test": "4.53.0",
+    "@truedat/test": "4.53.2",
     "babel-jest": "^28.1.0",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -93,8 +93,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.6.4",
-    "@truedat/core": "4.53.0",
-    "@truedat/df": "4.53.0",
+    "@truedat/core": "4.53.2",
+    "@truedat/df": "4.53.2",
     "graphql": "^15.5.3",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.8.1",
@@ -114,5 +114,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "c13d72dea3b93ba4f21b455dc2aaf9f289261dd3"
+  "gitHead": "e29af66624aad6ecce065ced88c8cc2e320d67e2"
 }

package/src/components/ConditionSummary.js

@@ -4,6 +4,7 @@ import PropTypes from "prop-types";
 import { Header, Icon, Segment, Table } from "semantic-ui-react";
 import { Link } from "react-router-dom";
 import { FormattedMessage } from "react-intl";
+import { useIntl } from "react-intl";
 import { linkTo } from "@truedat/core/routes";
 
 const concatValues = (values, link) => _.join(link)(values);
@@ -131,6 +132,7 @@ const ConditionCell = ({ row, alias }) => {
 
   const values = getValues(row);
   const operator = _.prop("operator")(row);
+  const { formatMessage } = useIntl();
   return (
     <Table.Row>
       <Table.Cell width={5}>
@@ -163,7 +165,10 @@ const ConditionCell = ({ row, alias }) => {
                   _.toPairs,
                   _.map(([key, value]) => (
                     <div key={key} className="smaller">
-                      {value}
+                      {`${formatMessage({
+                        id: `filtersGrid.field.modifier.${row.modifier.name}.${key}`,
+                        defaultMessage: key,
+                      })}: ${value}`}
                     </div>
                   ))
                 )(row)}

package/src/components/NewRuleImplementation.js

@@ -4,12 +4,13 @@ import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { Divider, Header, Grid } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
+import { Loading } from "@truedat/core/components";
+import { useOperators } from "@truedat/core/hooks";
 import { getFieldType } from "@truedat/core/services/fieldType";
 import {
   createRuleImplementation,
   updateRuleImplementation,
 } from "../routines";
-import { getRuleImplementationOperators } from "../selectors/getRuleImplementationOperators";
 import RuleImplementationForm from "./ruleImplementationForm/RuleImplementationForm";
 import RuleImplementationRawForm from "./ruleImplementationForm/RuleImplementationRawForm";
 import ImplementationSummary from "./ImplementationSummary";
@@ -598,10 +599,16 @@ const mapStateToProps = (state) => ({
   ruleImplementationRaw: state.ruleImplementationRaw,
   structuresFields: state.structuresFields,
   structuresSiblings: state.structuresSiblings,
-  operators: getRuleImplementationOperators(state),
 });
 
+export const ImplementationLoader = (props) => {
+  const { data, error, loading } = useOperators();
+  if (error) return null;
+  if (loading) return <Loading />;
+  return <NewRuleImplementation operators={data} {...props} />;
+};
+
 export default connect(mapStateToProps, {
   createRuleImplementation,
   updateRuleImplementation,
-})(NewRuleImplementation);
+})(ImplementationLoader);

package/src/components/__tests__/NewRuleImplementation.spec.js

@@ -3,9 +3,8 @@ import React from "react";
 import { waitFor, within } from "@testing-library/react";
 import { render } from "@truedat/test/render";
 import { DOMAIN_QUERY, DOMAINS_QUERY } from "@truedat/core/api/queries";
-import { multipleTemplatesMock } from "@truedat/test/mocks";
+import { functionsMock, multipleTemplatesMock } from "@truedat/test/mocks";
 import userEvent from "@testing-library/user-event";
-import defaultMessages from "@truedat/test/messages";
 import NewRuleImplementation, {
   NewRuleImplementation as NewRuleImplementationComponent,
 } from "../NewRuleImplementation";
@@ -41,10 +40,6 @@ const domainMock = {
   result: { data: { domain: { id: "2", actions: domainActions } } },
 };
 
-const messages = {
-  en: { ...defaultMessages.en },
-};
-
 describe("<NewRuleImplementation />", () => {
   const createRuleImplementation = jest.fn();
   const updateRuleImplementation = jest.fn();
@@ -63,6 +58,7 @@ describe("<NewRuleImplementation />", () => {
   };
   const renderOpts = {
     mocks: [
+      functionsMock,
       multipleTemplatesMock({
         scope: "ri",
         domainIds: null,
@@ -71,7 +67,6 @@ describe("<NewRuleImplementation />", () => {
       domainMock,
     ],
     state: { ruleImplementationCreating: false },
-    messages,
     fallback: "lazy",
   };
 
@@ -85,15 +80,15 @@ describe("<NewRuleImplementation />", () => {
     await waitFor(() =>
       expect(queryByText(/loading/i)).not.toBeInTheDocument()
     );
+    await waitFor(() =>
+      expect(queryByText(/Information/i)).toBeInTheDocument()
+    );
     expect(container).toMatchSnapshot();
   });
 
   it("calculate aliases when not informed", async () => {
-    const props = {
-      ...newRuleImplementationProps,
-    };
     const { container, queryByText } = render(
-      <NewRuleImplementationComponent {...props} />,
+      <NewRuleImplementationComponent {...newRuleImplementationProps} />,
       renderOpts
     );
     await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
@@ -109,6 +104,7 @@ describe("<NewRuleImplementation> NewRuleImplementation doSubmit", () => {
 
   const renderOptsImplementationEdit = {
     mocks: [
+      functionsMock,
       multipleTemplatesMock({
         scope: "ri",
         domainIds: [2],
@@ -116,13 +112,6 @@ describe("<NewRuleImplementation> NewRuleImplementation doSubmit", () => {
       domainsMock,
       domainMock,
     ],
-    messages: {
-      en: {
-        ...defaultMessages.en,
-        // This is in td-web
-        "filtersGrid.field.modifier.cast_as_date": "Cast as date",
-      },
-    },
     state: ruleImplementationLoaderGlobalState,
     fallback: "lazy",
     dispatch,

package/src/components/__tests__/__fixtures__/NewRuleImplementationProps.js

@@ -1614,7 +1614,7 @@ export const newRuleImplementationProps = {
       modifiers: [
         {
           name: "cast_as_date",
-          cast_as: "date",
+          type: "date",
           params: [
             {
               name: "format",

package/src/components/__tests__/__fixtures__/newRuleImplementationHelper.js

@@ -752,7 +752,7 @@ const ruleImplementationOperators = {
     modifiers: [
       {
         name: "cast_as_date",
-        cast_as: "date",
+        type: "date",
         params: [
           {
             name: "format",

package/src/components/ruleImplementationForm/FieldModifier.js

@@ -1,7 +1,8 @@
-import { getOr } from "lodash/fp";
+import { getOr, isEmpty } from "lodash/fp";
+import PropTypes from "prop-types";
 import React from "react";
 import { useIntl } from "react-intl";
-import { Form, Icon } from "semantic-ui-react";
+import { Form, Icon, Segment } from "semantic-ui-react";
 
 export default function FieldModifier({
   modifier,
@@ -12,40 +13,56 @@ export default function FieldModifier({
   const { formatMessage } = useIntl();
 
   return (
-    <div className={"flex-row-align-end"}>
-      <Form.Field>
-        <label>
-          {formatMessage({ id: `filtersGrid.field.modifier.${modifier.name}` })}
-        </label>
-        {getOr(
-          [],
-          "params"
-        )(modifier).map((param, key) => (
-          <input
-            key={key}
-            placeholder={formatMessage({
-              id: `filtersGrid.field.modifier.${modifier.name}.${param.name}`,
-            })}
-            value={getOr("", `params.${param.name}`)(value)}
-            onChange={({ target }) => {
-              onChange({
-                ...value,
-                params: {
-                  ...getOr({}, "params")(value),
-                  [param.name]: target.value,
-                },
-              });
-            }}
+    <Form.Field className={"flex-column-align-end"}>
+      <label>
+        {formatMessage({ id: `filtersGrid.field.modifier.${modifier.name}` })}
+        {removable ? (
+          <Icon
+            name="delete"
+            className="selectable force-margin-bottom"
+            onClick={() => onChange(null)}
           />
-        ))}
-      </Form.Field>
-      {removable && (
-        <Icon
-          name="x"
-          className="selectable force-margin-bottom"
-          onClick={() => onChange(null)}
-        />
+        ) : null}
+      </label>
+      {isEmpty(modifier?.params) ? null : (
+        <Segment>
+          {getOr(
+            [],
+            "params"
+          )(modifier).map((param, key) => (
+            <>
+              <label>
+                {formatMessage({
+                  id: `filtersGrid.field.modifier.${modifier.name}.${param.name}`,
+                })}
+              </label>
+              <input
+                key={key}
+                placeholder={formatMessage({
+                  id: `filtersGrid.field.modifier.${modifier.name}.${param.name}`,
+                })}
+                value={getOr("", `params.${param.name}`)(value)}
+                onChange={({ target }) => {
+                  onChange({
+                    ...value,
+                    params: {
+                      ...getOr({}, "params")(value),
+                      [param.name]: target.value,
+                    },
+                  });
+                }}
+              />
+            </>
+          ))}
+        </Segment>
       )}
-    </div>
+    </Form.Field>
   );
 }
+
+FieldModifier.propTypes = {
+  modifier: PropTypes.object,
+  value: PropTypes.object,
+  onChange: PropTypes.func,
+  removable: PropTypes.bool,
+};

package/src/components/ruleImplementationForm/FiltersField.js

@@ -107,6 +107,7 @@ export const FiltersField = ({
     case "field":
     case "field_list":
       const structureFields = getStructureFields(parentStructures);
+      const isFieldList = value_type === "field_list";
       return value_type_filter == "any" ? (
         <StructureSelectorInputField
           active={active}
@@ -128,15 +129,17 @@ export const FiltersField = ({
       ) : (
         <>
           <StructureFieldsDropdown
-            multiple={value_type === "field_list"}
+            multiple={isFieldList}
             label={label}
             inline={false}
             parentStructures={parentStructures}
             structureFields={structureFields}
-            typeCastModifiers={typeCastModifiers}
-            filters={
-              value_type === "field_list" ? null : { field_type: [fieldType] }
+            typeCastModifiers={
+              isFieldList
+                ? _.filter(({ params }) => _.isEmpty(params))(typeCastModifiers)
+                : typeCastModifiers
             }
+            filters={{ field_type: [fieldType] }}
             onSelectField={(value, modifier) => {
               onChange(
                 null,

package/src/components/ruleImplementationForm/FiltersFormGroup.js

@@ -34,9 +34,9 @@ export const FiltersFormGroup = ({
   const structureFieldType = clause?.structure?.field_type;
   const modifiers = _.path(`${structureFieldType}.modifiers`)(operators);
   const modifierValue = clause?.modifier;
-  const modifier = _.find({ name: modifierValue?.name })(modifiers);
+  const selectedModifier = _.find({ name: modifierValue?.name })(modifiers);
 
-  const fieldType = modifier?.cast_as || structureFieldType;
+  const fieldType = selectedModifier?.type || structureFieldType;
   const nestedCondition = !_.isEmpty(siblings);
   const structureFields = getStructureFields(parentStructures);
 
@@ -70,7 +70,9 @@ export const FiltersFormGroup = ({
               />
             )}
           </Form.Field>
-          {clause?.structure && !_.isEmpty(modifiers) && (
+          {clause?.structure &&
+          !_.isEmpty(modifiers) &&
+          _.isEmpty(selectedModifier) ? (
             <Dropdown
               className={"icon-dropdown-margin"}
               size="mini"
@@ -81,9 +83,9 @@ export const FiltersFormGroup = ({
                   <Dropdown.Item
                     key={key}
                     icon={
-                      modifier.cast_as
+                      modifier.type
                         ? formatMessage({
-                            id: `field_type.icon.${modifier.cast_as}`,
+                            id: `field_type.icon.${modifier.type}`,
                             defaultMessage: "hashtag",
                           })
                         : null
@@ -98,11 +100,11 @@ export const FiltersFormGroup = ({
                 ))}
               </Dropdown.Menu>
             </Dropdown>
-          )}
+          ) : null}
         </div>
-        {modifier && (
+        {selectedModifier && (
           <FieldModifier
-            modifier={modifier}
+            modifier={selectedModifier}
             value={modifierValue}
             onChange={(value) => onModifierChange(index, value)}
             removable

package/src/components/ruleImplementationForm/PopulationForm.js

@@ -1,8 +1,6 @@
 import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
-import { FormattedMessage } from "react-intl";
-import { Grid, Icon, Segment } from "semantic-ui-react";
 import { dropAt, replaceAt } from "@truedat/core/services/arrays";
 import { FiltersGrid } from "./FiltersGrid";
 

package/src/components/ruleImplementationForm/operators.js

@@ -71,7 +71,7 @@ export default (operators, type, nested, scope, formatMessage) => {
       _.map((m) => ({ ...m, sourceType: key }))(value.modifiers || [])
     ),
     _.flatten,
-    _.filter(({ cast_as }) => cast_as === type)
+    _.filter({ type: type })
   )(operators);
 
   return {

package/src/selectors/getRuleImplementationOperators.js

@@ -1,296 +0,0 @@
-import _ from "lodash/fp";
-import { createSelector } from "reselect";
-
-const defaultOperators = {
-  any: {
-    operators: [
-      { name: "unique", scope: "validation" },
-      { name: "unique", value_type: "field_list" },
-      { name: "not_empty" },
-      { name: "empty" },
-      {
-        group: "references",
-        name: "references",
-        value_type: "field",
-        value_type_filter: "any",
-        scope: "validation",
-      },
-      {
-        group: "references",
-        name: "not_references",
-        value_type: "field",
-        value_type_filter: "any",
-        scope: "validation",
-      },
-    ],
-  },
-  boolean: {
-    operators: [{ name: "is_true" }, { name: "is_false" }],
-  },
-  number: {
-    operators: [
-      { group: "eq", name: "eq", value_type: "number" },
-      { group: "eq", name: "eq", value_type: "field" },
-      { group: "not_eq", name: "not_eq", value_type: "number" },
-      { group: "not_eq", name: "not_eq", value_type: "field" },
-      { group: "gt", name: "gt", value_type: "number" },
-      { group: "gt", name: "gt", value_type: "field" },
-      { group: "lt", name: "lt", value_type: "number" },
-      { group: "lt", name: "lt", value_type: "field" },
-      { group: "gte", name: "gte", value_type: "number" },
-      { group: "gte", name: "gte", value_type: "field" },
-      { group: "lte", name: "lte", value_type: "number" },
-      { group: "lte", name: "lte", value_type: "field" },
-      {
-        group: "between",
-        name: "between",
-        value_type: "number",
-        arity: 2,
-      },
-      {
-        group: "between",
-        name: "between",
-        value_type: "field",
-        arity: 2,
-      },
-      {
-        group: "format",
-        name: "number_of_decimals",
-        value_type: "number",
-        scope: "validation",
-      },
-    ],
-  },
-  string: {
-    operators: [
-      { group: "eq", name: "eq", value_type: "string" },
-      { group: "eq", name: "eq", value_type: "field" },
-      { group: "not_eq", name: "not_eq", value_type: "string" },
-      { group: "not_eq", name: "not_eq", value_type: "field" },
-      { group: "length", name: "length_gt", value_type: "number" },
-      { group: "length", name: "length_lt", value_type: "number" },
-      {
-        group: "length",
-        name: "length_eq",
-        value_type: "number",
-        scope: "validation",
-      },
-      {
-        group: "length",
-        name: "length_not_eq",
-        value_type: "number",
-        scope: "validation",
-      },
-      {
-        group: "length",
-        name: "length_gte",
-        value_type: "number",
-      },
-      {
-        group: "length",
-        name: "length_lte",
-        value_type: "number",
-      },
-      {
-        group: "length",
-        name: "length_between",
-        value_type: "number",
-        arity: 2,
-      },
-      { name: "contains", value_type: "string" },
-      {
-        name: "not_contains",
-        value_type: "string",
-      },
-
-      {
-        name: "starts_with",
-        value_type: "string",
-      },
-      { name: "ends_with", value_type: "string" },
-      {
-        name: "in_list",
-        value_type: "string_list",
-      },
-      {
-        name: "not_in_list",
-        value_type: "string_list",
-      },
-      {
-        group: "format",
-        name: "number_of_decimals",
-        value_type: "number",
-        scope: "validation",
-      },
-      {
-        name: "format_of",
-        group: "format",
-        value_type: "string",
-        fixed_values: [
-          "email",
-          "phone",
-          "number",
-          "decimal",
-          "date",
-          "dni",
-          "dni_or_cif",
-          "season",
-          "timestamp",
-        ],
-        scope: "validation",
-      },
-      {
-        name: "regex_format",
-        value_type: "string",
-      },
-    ],
-  },
-  date: {
-    operators: [
-      { group: "eq", name: "eq", value_type: "date" },
-      { group: "eq", name: "eq", value_type: "field" },
-      { group: "not_eq", name: "not_eq", value_type: "date" },
-      { group: "not_eq", name: "not_eq", value_type: "field" },
-      { group: "gt", name: "gt", value_type: "date" },
-      { group: "gt", name: "gt", value_type: "field" },
-      { group: "gte", name: "gte", value_type: "date" },
-      { group: "gte", name: "gte", value_type: "field" },
-      { group: "lt", name: "lt", value_type: "date" },
-      { group: "lt", name: "lt", value_type: "field" },
-      { group: "lte", name: "lte", value_type: "date" },
-      { group: "lte", name: "lte", value_type: "field" },
-      {
-        name: "between",
-        value_type: "date",
-        arity: 2,
-      },
-      {
-        group: "eq",
-        name: "eq_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "lt",
-        name: "lt_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "lte",
-        name: "lte_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "gt",
-        name: "gt_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "gte",
-        name: "gte_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        name: "variation_on_count",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-        scope: "validation",
-        arity: 2,
-      },
-    ],
-  },
-  timestamp: {
-    operators: [
-      { group: "eq", name: "eq", value_type: "timestamp" },
-      { group: "eq", name: "eq", value_type: "field" },
-      { group: "not_eq", name: "not_eq", value_type: "timestamp" },
-      { group: "not_eq", name: "not_eq", value_type: "field" },
-      { group: "gt", name: "gt", value_type: "timestamp" },
-      { group: "gt", name: "gt", value_type: "field" },
-      { group: "gte", name: "gte", value_type: "timestamp" },
-      { group: "gte", name: "gte", value_type: "field" },
-      { group: "lt", name: "lt", value_type: "timestamp" },
-      { group: "lt", name: "lt", value_type: "field" },
-      { group: "lte", name: "lte", value_type: "timestamp" },
-      { group: "lte", name: "lte", value_type: "field" },
-      {
-        name: "between",
-        value_type: "timestamp",
-        arity: 2,
-      },
-      {
-        group: "eq",
-        name: "eq_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "not_eq",
-        name: "not_eq_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "lt",
-        name: "lt_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "lte",
-        name: "lte_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "gt",
-        name: "gt_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        group: "gte",
-        name: "gte_var",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-      },
-      {
-        name: "variation_on_count",
-        value_type: "string",
-        fixed_values: ["D-0", "D-1", "M-0", "M-1", "M-2", "Y-0", "Y-1"],
-        scope: "validation",
-        arity: 2,
-      },
-    ],
-  },
-};
-
-const ruleImplementationOperators = (state) =>
-  state.ruleImplementationOperators;
-
-export const getRuleImplementationOperators = createSelector(
-  [ruleImplementationOperators],
-  (operators) =>
-    _.flow(
-      _.defaultTo(defaultOperators),
-      _.toPairs,
-      _.map(([key, value]) =>
-        _.map((o) => ({ category: key, ...o }))(value.operators)
-      ),
-      _.flatten,
-      _.map.convert({ cap: false })((o, i) => ({ id: i, ...o })),
-      _.groupBy("category"),
-      _.reduce.convert({ cap: false })(
-        (acc, value, key) =>
-          _.set(key, {
-            operators: _.map((o) => _.omit(["category"])(o))(value),
-            modifiers: _.propOr([], `${key}.modifiers`)(operators),
-          })(acc),
-        {}
-      )
-    )(operators)
-);