@truedat/dq 4.35.7 → 4.36.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [4.36.2] 2022-01-17
+
+### Added
+
+- [TD-3178] Show join details in implementation summary
+
+## [4.35.8] 2022-01-07
+
+### Added
+
+- [TD-4390] Support for alias on Implementation
+
 ## [4.35.5] 2021-12-20
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.35.7",
+  "version": "4.36.2",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -82,8 +82,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.4.10",
-    "@truedat/core": "4.35.7",
-    "@truedat/df": "4.35.7",
+    "@truedat/core": "4.36.2",
+    "@truedat/df": "4.36.2",
     "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": "99812619b928d7802bb2f33df3f3321c9c36995e"
+  "gitHead": "0f4c09d90582210ae7c98e945b8c0b7af0f9a61d"
 }

package/src/components/ConditionSummary.js

@@ -74,7 +74,12 @@ OperatorMessage.propTypes = {
   operator: PropTypes.object,
 };
 
-const ConditionCell = ({ row }) => {
+const ConditionCell = ({ row, alias }) => {
+  const alias_text = _.flow(
+    _.find({ index: row.structure?.parent_index }),
+    _.propOr(null, "text")
+  )(alias);
+
   const values = getValues(row);
   const operator = _.prop("operator")(row);
   return (
@@ -87,10 +92,10 @@ const ConditionCell = ({ row }) => {
                 id: _.path("structure.id")(row),
               })}
             >
-              <span className="highlighted">{`"${_.pathOr(
-                "",
-                "structure.name"
-              )(row)}"`}</span>
+              <span className="highlighted">
+                {alias_text && `(${alias_text}).`}{" "}
+                {`"${_.pathOr("", "structure.name")(row)}"`}
+              </span>
             </Link>
             {row?.modifier && (
               <>
@@ -155,9 +160,10 @@ const ConditionCell = ({ row }) => {
 
 ConditionCell.propTypes = {
   row: PropTypes.object,
+  alias: PropTypes.array,
 };
 
-export const ConditionSummary = ({ rows, type, icon }) =>
+export const ConditionSummary = ({ rows, type, icon, alias }) =>
   empty(rows) ? null : (
     <>
       <Header as="h3">
@@ -185,7 +191,7 @@ export const ConditionSummary = ({ rows, type, icon }) =>
           </Table.Header>
           <Table.Body>
             {rows.map((row, i) => (
-              <ConditionCell key={i} row={row} />
+              <ConditionCell key={i} row={row} alias={alias} />
             ))}
           </Table.Body>
         </Table>

package/src/components/ImplementationSummary.js

@@ -1,12 +1,13 @@
 import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
-import { Header, Icon, Table, Segment } from "semantic-ui-react";
+import { Header, Icon, Table, Segment, List } from "semantic-ui-react";
 import { Link } from "react-router-dom";
 import { FormattedMessage } from "react-intl";
 import { linkTo } from "@truedat/core/routes";
 import ConditionSummary, { empty, path } from "./ConditionSummary";
 import InformationSummary from "./InformationSummary";
+import "../styles/ImplementationSummary.less";
 
 const defaults = [
   "executable",
@@ -39,7 +40,45 @@ FormattedLink.propTypes = {
   operator: PropTypes.object,
 };
 
-const DatasetSummary = ({ rows }) =>
+const AliasText = ({ alias, clause }) => {
+  const text = _.flow(
+    _.find({ index: clause?.parent_index }),
+    _.propOr(null, "text")
+  )(alias);
+  return _.isNull(text) ? clause?.name : `(${text}).${clause?.name}`;
+};
+
+AliasText.propTypes = {
+  alias: PropTypes.array,
+  clause: PropTypes.object,
+};
+
+const UnionSummary = ({ alias, row }) => {
+  return empty(row) || !(row?.clauses && _.size(row?.clauses) > 0) ? null : (
+    <List id="union-list">
+      <List.Item>
+        <List.Header>
+          <FormattedMessage id="structureSelector.union.criteria" />
+        </List.Header>
+      </List.Item>
+      {row.clauses.map((clause, k) =>
+        _.size(clause) > 0 ? (
+          <List.Item key={k}>
+            {clause.left && <AliasText alias={alias} clause={clause.left} />} ={" "}
+            {clause.right && <AliasText alias={alias} clause={clause.right} />}
+          </List.Item>
+        ) : null
+      )}
+    </List>
+  );
+};
+
+UnionSummary.propTypes = {
+  row: PropTypes.object,
+  alias: PropTypes.array,
+};
+
+const DatasetSummary = ({ rows, alias }) =>
   empty(rows) ? null : (
     <>
       <Header as="h3">
@@ -61,16 +100,19 @@ const DatasetSummary = ({ rows }) =>
             {rows.map((row, i) => (
               <Table.Row key={i}>
                 {_.has("structure")(row) && (
-                  <Table.Cell key={i}>
+                  <Table.Cell>
                     <Link
                       to={linkTo.STRUCTURE({
                         id: _.pathOr("", "structure.id")(row),
                       })}
                     >
-                      <span key={i} className="highlighted">{`"${path(
+                      <p className="highlighted">{`"${path(
                         _.propOr({}, "structure")(row)
-                      )}"`}</span>
+                      )}"`}</p>
                     </Link>
+
+                    {row.alias?.text && <span>({row.alias.text})</span>}
+                    <UnionSummary alias={alias} row={row} />
                   </Table.Cell>
                 )}
               </Table.Row>
@@ -83,12 +125,14 @@ const DatasetSummary = ({ rows }) =>
 
 DatasetSummary.propTypes = {
   rows: PropTypes.array,
+  alias: PropTypes.array,
 };
 
 export const ImplementationSummary = ({ ruleImplementation, activeSteps }) => {
   const steps = _.isEmpty(activeSteps) ? defaults : activeSteps;
   const { dataset, population, validations } =
     _.pick(steps)(ruleImplementation);
+  const alias = _.map(_.propOr({}, "alias"))(dataset);
   return (
     <>
       {(_.includes("implementationKey")(steps) ||
@@ -96,16 +140,22 @@ export const ImplementationSummary = ({ ruleImplementation, activeSteps }) => {
         <InformationSummary ruleImplementation={ruleImplementation} />
       )}
       {dataset && _.includes("dataset")(steps) && (
-        <DatasetSummary rows={dataset} />
+        <DatasetSummary rows={dataset} alias={alias} />
       )}
       {population && _.includes("population")(steps) && (
-        <ConditionSummary type="population" icon="user" rows={population} />
+        <ConditionSummary
+          type="population"
+          icon="user"
+          rows={population}
+          alias={alias}
+        />
       )}
       {validations && _.includes("validations")(steps) && (
         <ConditionSummary
           type="validations"
           icon="setting"
           rows={validations}
+          alias={alias}
         />
       )}
     </>

package/src/components/NewRuleImplementation.js

@@ -29,7 +29,9 @@ const updateDatasetKey = (data) =>
   )(data);
 
 const updateConditionValue = (acc, value, key) => {
-  if (key === "structure") return _.set(key, _.pick(["id"])(value))(acc);
+  if (key === "structure") {
+    return _.set(key, _.pick(["id", "parent_index"])(value))(acc);
+  }
   if (key === "modifier")
     return _.set(
       key,
@@ -52,9 +54,9 @@ const updateConditionValue = (acc, value, key) => {
   if (key == "value")
     return _.set(
       key,
-      _.map((v) => (_.has("id")(v) ? _.pick(["id"])(v) : _.pick(["raw"])(v)))(
-        value
-      )
+      _.map((v) =>
+        _.has("id")(v) ? _.pick(["id", "parent_index"])(v) : _.pick(["raw"])(v)
+      )(value)
     )(acc);
   if (key === "population") return _.set(key, conditionAttributes(value))(acc);
 
@@ -69,7 +71,7 @@ const updateConditionKey = (condition) =>
 
 const datasetAttributes = (dataset) =>
   _.flow(
-    _.map(_.pickAll(["structure", "clauses", "join_type"])),
+    _.map(_.pickAll(["structure", "clauses", "join_type", "alias"])),
     _.map(updateDatasetKey)
   )(dataset);
 
@@ -172,6 +174,63 @@ const enrichOperator = (operators, scope, field_type, operator) => {
   return { ...op_extra, ...operator };
 };
 
+const withDefaultAlias = (dataset) => {
+  const maxAliasIndex = _.max([
+    ..._.flow(_.map("alias.index"), _.reject(_.isNil))(dataset),
+    0,
+  ]);
+  const newDataset = dataset.map((s, index) => ({
+    ...s,
+    alias: s.alias || {
+      index: index + maxAliasIndex,
+      text: `${s?.structure?.name} (${index + maxAliasIndex})`,
+    },
+  }));
+
+  const updateStructure = updateStructureParentIndex(newDataset);
+  return _.map((ds) => ({
+    ...ds,
+    clauses:
+      ds.clauses &&
+      _.map(({ left, right }) => ({
+        left: updateStructure(left),
+        right: updateStructure(right),
+      }))(ds.clauses),
+  }))(newDataset);
+};
+
+const updateStructureParentIndex = (structures) => (structure) => {
+  if (
+    _.isArray(_.path("path")(structure)) &&
+    _.isNil(_.path("parent_index")(structure))
+  ) {
+    const { path } = structure;
+    const parentPath = _.initial(path);
+    const parentName = _.last(path);
+
+    const parent = _.find(
+      (p) =>
+        _.isEqual(p.structure?.path)(parentPath) &&
+        _.isEqual(p.structure?.name)(parentName)
+    )(structures);
+
+    return { ...structure, parent_index: parent.alias.index };
+  }
+  return structure;
+};
+
+const withConditionDefaultAlias = (conditions, structures) =>
+  _.map((p) => {
+    return {
+      ...p,
+      structure: updateStructureParentIndex(structures)(p.structure),
+      value:
+        !_.isEqual("references")(p.operator.group) && _.isArray(p.value)
+          ? _.map(updateStructureParentIndex(structures))(p.value)
+          : p.value,
+    };
+  })(conditions);
+
 export const NewRuleImplementation = ({
   canManageRaw,
   clone,
@@ -187,6 +246,10 @@ export const NewRuleImplementation = ({
   template,
   applyTemplate,
 }) => {
+  const precalculatedDataset = _.flow(
+    _.propOr([{}], "dataset"),
+    withDefaultAlias
+  )(ruleImplementationProps);
   const [ruleImplementation, setRuleImplementation] = useState(
     edition
       ? {
@@ -198,22 +261,28 @@ export const NewRuleImplementation = ({
           implementationType: _.prop("implementation_type")(
             ruleImplementationProps
           ),
-          dataset: _.propOr([{}], "dataset")(ruleImplementationProps),
-          population: addFieldType(
-            ruleImplementationProps,
-            structuresFields,
-            structuresSiblings,
-            "population",
-            "population",
-            operators
+          dataset: precalculatedDataset,
+          population: withConditionDefaultAlias(
+            addFieldType(
+              ruleImplementationProps,
+              structuresFields,
+              structuresSiblings,
+              "population",
+              "population",
+              operators
+            ),
+            precalculatedDataset
           ),
-          validations: addFieldType(
-            ruleImplementationProps,
-            structuresFields,
-            structuresSiblings,
-            "validations",
-            "validation",
-            operators
+          validations: withConditionDefaultAlias(
+            addFieldType(
+              ruleImplementationProps,
+              structuresFields,
+              structuresSiblings,
+              "validations",
+              "validation",
+              operators
+            ),
+            precalculatedDataset
           ),
           rawContent: {
             ..._.prop("raw_content")(ruleImplementationProps),
@@ -246,9 +315,33 @@ export const NewRuleImplementation = ({
         }
   );
 
+  const withoutUnusedAliasText = (dataset) => {
+    const duplicatedStructures = _.flow(
+      _.groupBy("structure.id"),
+      _.pickBy((x) => x.length > 1),
+      _.keys,
+      _.map(Number)
+    )(dataset);
+    return _.map((ds) =>
+      _.has("structure.id")(ds) &&
+      _.includes(ds.structure.id)(duplicatedStructures)
+        ? _.path("alias.text")(ds)
+          ? ds
+          : {
+              ...ds,
+              alias: {
+                ...ds.alias,
+                text: `${ds.structure.name} (${ds.alias.index})`,
+              },
+            }
+        : { ...ds, alias: { ...ds.alias, text: null } }
+    )(dataset);
+  };
+
   const setDataset = (dataset) => {
+    const cleanDataset = withoutUnusedAliasText(dataset);
     //remove invalid references of fields in validations and populations after dataset edition
-    const datasetStructures = _.map(_.path("structure.id"))(dataset);
+    const datasetStructures = _.map(_.path("structure.id"))(cleanDataset);
     const all_fields = _.flow(
       _.pickAll(datasetStructures),
       _.values,
@@ -282,7 +375,7 @@ export const NewRuleImplementation = ({
 
     setRuleImplementation({
       ...ruleImplementation,
-      dataset,
+      dataset: cleanDataset,
       population: _.isEmpty(population_within_dataset)
         ? []
         : population_within_dataset,