@truedat/dq 4.28.8 → 4.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.28.8",
+  "version": "4.29.0",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -31,7 +31,7 @@
     "@babel/plugin-transform-modules-commonjs": "^7.15.0",
     "@babel/preset-env": "^7.15.0",
     "@babel/preset-react": "^7.14.5",
-    "@truedat/test": "4.28.8",
+    "@truedat/test": "4.29.0",
     "babel-jest": "^27.0.6",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -82,8 +82,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.4.10",
-    "@truedat/core": "4.28.8",
-    "@truedat/df": "4.28.8",
+    "@truedat/core": "4.29.0",
+    "@truedat/df": "4.29.0",
     "axios": "^0.19.2",
     "graphql": "^15.5.3",
     "path-to-regexp": "^1.7.0",
@@ -103,5 +103,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "33a7f73dd4ffbd31d1df270c8453c3a876412990"
+  "gitHead": "42028609748cd7f1686ea783264a9cdfa7b0ca8f"
 }

package/src/components/ImplementationSummary.js

@@ -11,7 +11,7 @@ const defaults = [
   "implementationKey",
   "dataset",
   "population",
-  "validations"
+  "validations",
 ];
 
 const concatValues = (values, link) => _.join(link)(values);
@@ -36,24 +36,25 @@ const FormattedLink = ({ value, operator = {} }) =>
 
 FormattedLink.propTypes = {
   value: PropTypes.object,
-  operator: PropTypes.object
+  operator: PropTypes.object,
 };
 
 const path = ({ name, path = [] }) => concatValues([...path, name], " > ");
 
-const empty = rows => rows && _.every(r => _.isEmpty(r) || _.isNil(r))(rows);
+const empty = (rows) =>
+  rows && _.every((r) => _.isEmpty(r) || _.isNil(r))(rows);
 
-const nilOrEmpty = v => _.isNil(v) || v === "";
+const nilOrEmpty = (v) => _.isNil(v) || v === "";
 
 const filterNilOrEmpties = (values, keys) =>
-  _.filter(v => _.every(k => !nilOrEmpty(_.prop(k)(v.kv)))(keys))(values);
+  _.filter((v) => _.every((k) => !nilOrEmpty(_.prop(k)(v.kv)))(keys))(values);
 
 const valuesFromKeys = (values, keys, optionalKeys, value_modifier) =>
   _.flow(
-    _.map(v => {
+    _.map((v) => {
       return { kv: _.pick(keys)(v), optv: _.pick(optionalKeys)(v) };
     }),
-    v => filterNilOrEmpties(v, keys),
+    (v) => filterNilOrEmpties(v, keys),
     _.map.convert({ cap: false })((v, i) => {
       return { ...v.kv, ...v.optv, modifier: _.nth(i)(value_modifier) };
     })
@@ -102,7 +103,7 @@ const GeneralSummary = ({ executable, implementationKey }) => (
 
 GeneralSummary.propTypes = {
   executable: PropTypes.bool,
-  implementationKey: PropTypes.string
+  implementationKey: PropTypes.string,
 };
 
 const DatasetSummary = ({ rows }) =>
@@ -129,7 +130,7 @@ const DatasetSummary = ({ rows }) =>
                 <Table.Cell key={i}>
                   <Link
                     to={linkTo.STRUCTURE({
-                      id: _.pathOr("", "structure.id")(row)
+                      id: _.pathOr("", "structure.id")(row),
                     })}
                   >
                     <span key={i} className="highlighted">{`"${path(
@@ -146,7 +147,7 @@ const DatasetSummary = ({ rows }) =>
   );
 
 DatasetSummary.propTypes = {
-  rows: PropTypes.array
+  rows: PropTypes.array,
 };
 
 const OperatorMessage = ({ operator }) =>
@@ -155,12 +156,12 @@ const OperatorMessage = ({ operator }) =>
       id={`ruleImplementation.operator.${_.prop("name")(operator)}`}
       defaultMessage={_.prop("name")(operator)}
     >
-      {message => <span className="highlighted">{`"${message}"`}</span>}
+      {(message) => <span className="highlighted">{`"${message}"`}</span>}
     </FormattedMessage>
   ) : null;
 
 OperatorMessage.propTypes = {
-  operator: PropTypes.object
+  operator: PropTypes.object,
 };
 
 const ConditionCell = ({ row }) => {
@@ -173,7 +174,7 @@ const ConditionCell = ({ row }) => {
           <>
             <Link
               to={linkTo.STRUCTURE({
-                id: _.path("structure.id")(row)
+                id: _.path("structure.id")(row),
               })}
             >
               <span className="highlighted">{`"${_.pathOr(
@@ -181,22 +182,25 @@ const ConditionCell = ({ row }) => {
                 "structure.name"
               )(row)}"`}</span>
             </Link>
-            {row?.modifier && <>
-              <div className="smaller">
-                <FormattedMessage
-                  id={`filtersGrid.field.modifier.${row.modifier.name}`}
-                  defaultMessage={row.modifier.name}
-                />
-              </div>
+            {row?.modifier && (
+              <>
+                <div className="smaller">
+                  <FormattedMessage
+                    id={`filtersGrid.field.modifier.${row.modifier.name}`}
+                    defaultMessage={row.modifier.name}
+                  />
+                </div>
                 {_.flow(
                   _.prop("modifier.params"),
                   _.toPairs,
-                  _.map(([key, value]) => 
-                  <div 
-                    key={key}
-                    className="smaller">{value}</div>)
+                  _.map(([key, value]) => (
+                    <div key={key} className="smaller">
+                      {value}
+                    </div>
+                  ))
                 )(row)}
-            </>}
+              </>
+            )}
           </>
         )}
       </Table.Cell>
@@ -213,22 +217,25 @@ const ConditionCell = ({ row }) => {
                 <FormattedMessage id="summary.link.and" />{" "}
               </span>
             )}
-            {value?.modifier && <>
-              <div className="smaller">
-                <FormattedMessage
-                  id={`filtersGrid.field.modifier.${value.modifier.name}`}
-                  defaultMessage={value.modifier.name}
-                />
-              </div>
+            {value?.modifier && (
+              <>
+                <div className="smaller">
+                  <FormattedMessage
+                    id={`filtersGrid.field.modifier.${value.modifier.name}`}
+                    defaultMessage={value.modifier.name}
+                  />
+                </div>
                 {_.flow(
                   _.prop("modifier.params"),
                   _.toPairs,
-                  _.map(([key, value]) => 
-                  <div 
-                    key={key}
-                    className="smaller">{value}</div>)
+                  _.map(([key, value]) => (
+                    <div key={key} className="smaller">
+                      {value}
+                    </div>
+                  ))
                 )(value)}
-            </>}
+              </>
+            )}
           </Fragment>
         ))(values)}
       </Table.Cell>
@@ -237,7 +244,7 @@ const ConditionCell = ({ row }) => {
 };
 
 ConditionCell.propTypes = {
-  row: PropTypes.object
+  row: PropTypes.object,
 };
 
 const ConditionSummary = ({ rows, type, icon }) =>
@@ -277,18 +284,13 @@ const ConditionSummary = ({ rows, type, icon }) =>
 ConditionSummary.propTypes = {
   icon: PropTypes.string,
   rows: PropTypes.array,
-  type: PropTypes.string
+  type: PropTypes.string,
 };
 
 export const ImplementationSummary = ({ ruleImplementation, activeSteps }) => {
   const steps = _.isEmpty(activeSteps) ? defaults : activeSteps;
-  const {
-    executable,
-    implementationKey,
-    dataset,
-    population,
-    validations
-  } = _.pick(steps)(ruleImplementation);
+  const { executable, implementationKey, dataset, population, validations } =
+    _.pick(steps)(ruleImplementation);
   return (
     <>
       {(_.includes("implementationKey")(steps) ||
@@ -317,7 +319,7 @@ export const ImplementationSummary = ({ ruleImplementation, activeSteps }) => {
 
 ImplementationSummary.propTypes = {
   activeSteps: PropTypes.array,
-  ruleImplementation: PropTypes.object
+  ruleImplementation: PropTypes.object,
 };
 
 export default ImplementationSummary;

package/src/components/NewRuleImplementation.js

@@ -8,7 +8,7 @@ import { getFieldType } from "@truedat/core/services/fieldType";
 import { applyTemplate } from "@truedat/df/utils";
 import {
   createRuleImplementation,
-  updateRuleImplementation
+  updateRuleImplementation,
 } from "../routines";
 import { getRuleImplementationOperators } from "../selectors/getRuleImplementationOperators";
 import RuleImplementationForm from "./ruleImplementationForm/RuleImplementationForm";
@@ -19,7 +19,7 @@ const TemplateLoader = React.lazy(() =>
   import("@truedat/df/templates/components/TemplateLoader")
 );
 
-const updateDatasetKey = data =>
+const updateDatasetKey = (data) =>
   _.reduce.convert({ cap: false })(
     (acc, value, key) =>
       ["structure"].includes(key)
@@ -30,13 +30,18 @@ const updateDatasetKey = data =>
 
 const updateConditionValue = (acc, value, key) => {
   if (key === "structure") return _.set(key, _.pick(["id"])(value))(acc);
-  if (key === "modifier") return _.set(key, 
-    _.isNil(value) ? null :
-    _.pick(["name", "params"])(value))(acc);
-  if (key === "value_modifier") return _.set(key, 
-    _.every(_.isNil)(value) ? [] :
-    _.map(v => _.pick(["name", "params"])(v))(value)
-  )(acc);
+  if (key === "modifier")
+    return _.set(
+      key,
+      _.isNil(value) ? null : _.pick(["name", "params"])(value)
+    )(acc);
+  if (key === "value_modifier")
+    return _.set(
+      key,
+      _.every(_.isNil)(value)
+        ? []
+        : _.map((v) => _.pick(["name", "params"])(v))(value)
+    )(acc);
   if (key === "operator")
     return _.set(
       key,
@@ -47,7 +52,7 @@ const updateConditionValue = (acc, value, key) => {
   if (key == "value")
     return _.set(
       key,
-      _.map(v => (_.has("id")(v) ? _.pick(["id"])(v) : _.pick(["raw"])(v)))(
+      _.map((v) => (_.has("id")(v) ? _.pick(["id"])(v) : _.pick(["raw"])(v)))(
         value
       )
     )(acc);
@@ -56,28 +61,30 @@ const updateConditionValue = (acc, value, key) => {
   return acc;
 };
 
-const updateConditionKey = condition =>
+const updateConditionKey = (condition) =>
   _.reduce.convert({ cap: false })(
     (acc, value, key) => updateConditionValue(acc, value, key),
     {}
   )(condition);
 
-const datasetAttributes = dataset =>
+const datasetAttributes = (dataset) =>
   _.flow(
     _.map(_.pickAll(["structure", "clauses", "join_type"])),
     _.map(updateDatasetKey)
   )(dataset);
 
-const conditionAttributes = condition =>
+const conditionAttributes = (condition) =>
   _.flow(
-    _.map(_.pickAll([
-      "structure",
-      "modifier",
-      "operator",
-      "value",
-      "value_modifier",
-      "population",
-    ])),
+    _.map(
+      _.pickAll([
+        "structure",
+        "modifier",
+        "operator",
+        "value",
+        "value_modifier",
+        "population",
+      ])
+    ),
     _.map(updateConditionKey)
   )(condition);
 
@@ -99,7 +106,7 @@ const fieldTypeFromStructure = (row, structures, operators, scope) => {
     operator,
     modifier,
     value_modifier,
-    structure: { ...structure, field_type }
+    structure: { ...structure, field_type },
   };
   return updatedRow;
 };
@@ -110,9 +117,9 @@ const withNestedPopulation = (row, siblings, operators, scope) => {
     ? row
     : {
         ...row,
-        population: _.map(populationRow =>
+        population: _.map((populationRow) =>
           fieldTypeFromStructure(populationRow, siblings, operators, scope)
-        )(population)
+        )(population),
       };
 };
 
@@ -131,7 +138,7 @@ const addFieldType = (
 ) => {
   const fields = _.flow(_.values, _.flatten)(structuresFields);
   const siblings = _.flow(_.values, _.flatten)(structuresSiblings);
-  const rows = _.map(row =>
+  const rows = _.map((row) =>
     rowFieldType(row, fields, siblings, operators, scope)
   )(_.prop(implementationPropertyName)(ruleImplementationProps));
   return _.isEmpty(rows) ? [] : rows;
@@ -148,17 +155,17 @@ const enrichOperator = (operators, scope, field_type, operator) => {
     _.flow(
       _.prop(field_type),
       _.prop("operators"),
-      _.filter(operator => inScope(operator, scope))
+      _.filter((operator) => inScope(operator, scope))
     )(operators)
   )(
     _.flow(
       _.prop("any"),
       _.prop("operators"),
-      _.filter(operator => inScope(operator, scope))
+      _.filter((operator) => inScope(operator, scope))
     )(operators)
   );
   const op_extra = _.find(
-    op =>
+    (op) =>
       _.propEq("name", operator.name)(op) &&
       _.propEq("value_type", operator.value_type)(op)
   )(type_operators);
@@ -178,7 +185,7 @@ export const NewRuleImplementation = ({
   structuresSiblings,
   operators,
   template,
-  applyTemplate
+  applyTemplate,
 }) => {
   const [ruleImplementation, setRuleImplementation] = useState(
     edition
@@ -209,10 +216,10 @@ export const NewRuleImplementation = ({
             operators
           ),
           rawContent: {
-            ..._.prop("raw_content")(ruleImplementationProps)
+            ..._.prop("raw_content")(ruleImplementationProps),
           },
           dfName: _.prop("df_name")(ruleImplementationProps),
-          dfContent: ruleImplementationProps.df_content
+          dfContent: ruleImplementationProps.df_content,
         }
       : {
           executable: true,
@@ -226,14 +233,14 @@ export const NewRuleImplementation = ({
             source_id: null,
             dataset: "",
             population: "",
-            validations: ""
+            validations: "",
           },
           dfName: "",
-          dfContent: {}
+          dfContent: {},
         }
   );
 
-  const setDataset = dataset => {
+  const setDataset = (dataset) => {
     //remove invalid references of fields in validations and populations after dataset edition
     const datasetStructures = _.map(_.path("structure.id"))(dataset);
     const all_fields = _.flow(
@@ -243,11 +250,11 @@ export const NewRuleImplementation = ({
       _.map(_.prop("data_structure_id"))
     )(structuresFields);
 
-    const belongsToDataset = structureId => {
+    const belongsToDataset = (structureId) => {
       return _.includes(structureId)(all_fields);
     };
 
-    const valueInDataset = val => {
+    const valueInDataset = (val) => {
       return (
         _.pathEq("operator.value_type_filter", "any")(val) ||
         _.isNil(_.path("value[0].id")(val)) ||
@@ -257,14 +264,14 @@ export const NewRuleImplementation = ({
 
     const validations_within_dataset = _.flow(
       _.prop("validations"),
-      _.filter(val => belongsToDataset(_.path("structure.id")(val))),
-      _.filter(val => valueInDataset(val))
+      _.filter((val) => belongsToDataset(_.path("structure.id")(val))),
+      _.filter((val) => valueInDataset(val))
     )(ruleImplementation);
 
     const population_within_dataset = _.flow(
       _.prop("population"),
-      _.filter(val => belongsToDataset(_.path("structure.id")(val))),
-      _.filter(val => valueInDataset(val))
+      _.filter((val) => belongsToDataset(_.path("structure.id")(val))),
+      _.filter((val) => valueInDataset(val))
     )(ruleImplementation);
 
     setRuleImplementation({
@@ -275,28 +282,28 @@ export const NewRuleImplementation = ({
         : population_within_dataset,
       validations: _.isEmpty(validations_within_dataset)
         ? [{}]
-        : validations_within_dataset
+        : validations_within_dataset,
     });
   };
 
   const onChange = (prop, value) =>
     setRuleImplementation({ ...ruleImplementation, [prop]: value });
 
-  const setPopulation = population => {
+  const setPopulation = (population) => {
     setRuleImplementation({ ...ruleImplementation, population });
   };
 
-  const setValidations = validations => {
+  const setValidations = (validations) => {
     setRuleImplementation({ ...ruleImplementation, validations });
   };
 
-  const setImplementationKey = implementationKey =>
+  const setImplementationKey = (implementationKey) =>
     setRuleImplementation({ ...ruleImplementation, implementationKey });
 
-  const setImplementationType = implementationType =>
+  const setImplementationType = (implementationType) =>
     setRuleImplementation({ ...ruleImplementation, implementationType });
 
-  const setImplementationRawContent = rawContent =>
+  const setImplementationRawContent = (rawContent) =>
     setRuleImplementation({ ...ruleImplementation, rawContent });
 
   useEffect(() => {
@@ -330,13 +337,12 @@ export const NewRuleImplementation = ({
         ? {
             executable: ruleImplementation.executable,
             implementation_key: _.prop("implementationKey")(ruleImplementation),
-            implementation_type: _.prop("implementationType")(
-              ruleImplementation
-            ),
+            implementation_type:
+              _.prop("implementationType")(ruleImplementation),
             df_name,
             df_content: dfContent,
             rule_id: rule.id,
-            raw_content: { ...raw_content, source }
+            raw_content: { ...raw_content, source },
           }
         : {
             executable: ruleImplementation.executable,
@@ -344,23 +350,22 @@ export const NewRuleImplementation = ({
             population: conditionAttributes(population),
             validations: conditionAttributes(validations),
             implementation_key: _.prop("implementationKey")(ruleImplementation),
-            implementation_type: _.prop("implementationType")(
-              ruleImplementation
-            ),
+            implementation_type:
+              _.prop("implementationType")(ruleImplementation),
             df_name,
             df_content: dfContent,
-            rule_id: rule.id
+            rule_id: rule.id,
           };
 
     clone || !edition
       ? createRuleImplementation({
-          rule_implementation
+          rule_implementation,
         })
       : updateRuleImplementation({
           rule_implementation: {
             ...rule_implementation,
-            id: ruleImplementation.id
-          }
+            id: ruleImplementation.id,
+          },
         });
   };
 
@@ -451,14 +456,14 @@ NewRuleImplementation.propTypes = {
   operators: PropTypes.object,
   template: PropTypes.object,
   applyTemplate: PropTypes.func,
-  sources: PropTypes.array
+  sources: PropTypes.array,
 };
 
-const mapStateToProps = state => ({
+const mapStateToProps = (state) => ({
   rule: state.rule,
   ruleImplementationProps: {
     ...state.ruleImplementation,
-    raw_content: state.ruleImplementationRaw
+    raw_content: state.ruleImplementationRaw,
   },
   ruleImplementationRaw: state.ruleImplementationRaw,
   sources: state.sources,
@@ -469,10 +474,10 @@ const mapStateToProps = state => ({
   ),
   operators: getRuleImplementationOperators(state),
   template: _.defaultTo({})(state.template),
-  applyTemplate: applyTemplate(state.template)
+  applyTemplate: applyTemplate(state.template),
 });
 
 export default connect(mapStateToProps, {
   createRuleImplementation,
-  updateRuleImplementation
+  updateRuleImplementation,
 })(NewRuleImplementation);

package/src/components/ruleImplementationForm/FieldModifier.js

@@ -1,5 +1,5 @@
 import { getOr } from "lodash/fp";
-import React from 'react';
+import React from "react";
 import { useIntl } from "react-intl";
 import { Form, Icon } from "semantic-ui-react";
 
@@ -7,35 +7,45 @@ export default function FieldModifier({
   modifier,
   value,
   onChange,
-  removable=false,
+  removable = false,
 }) {
   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 
+        <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}`})}
+            placeholder={formatMessage({
+              id: `filtersGrid.field.modifier.${modifier.name}.${param.name}`,
+            })}
             value={getOr("", `params.${param.name}`)(value)}
-            onChange={({target}) => {
+            onChange={({ target }) => {
               onChange({
                 ...value,
                 params: {
                   ...getOr({}, "params")(value),
-                  [param.name]: target.value
-                }
-              })}}
+                  [param.name]: target.value,
+                },
+              });
+            }}
           />
-        )}
+        ))}
       </Form.Field>
-      {removable && <Icon
-        name="x"
-        className="selectable force-margin-bottom"
-        onClick={() => onChange(null)}
-      />}
+      {removable && (
+        <Icon
+          name="x"
+          className="selectable force-margin-bottom"
+          onClick={() => onChange(null)}
+        />
+      )}
     </div>
   );
 }