@truedat/dq 4.35.5 → 4.36.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [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.5",
+  "version": "4.36.0",
   "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.5",
-    "@truedat/df": "4.35.5",
+    "@truedat/core": "4.36.0",
+    "@truedat/df": "4.36.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": "7fcdb873dcb995997c4f31ef2bb3556577b40d14"
+  "gitHead": "6bf7c33362c73f97c8e5ff61f19c694ef28a0c3d"
 }

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,