@truedat/dq 8.5.2 → 8.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "8.5.2",
+  "version": "8.5.4",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "module": "src/index.js",
@@ -56,7 +56,7 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@truedat/test": "8.5.2",
+    "@truedat/test": "8.5.4",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "redux-saga-test-plan": "^4.0.6"
@@ -89,5 +89,5 @@
     "semantic-ui-react": "^3.0.0-beta.2",
     "swr": "^2.3.3"
   },
-  "gitHead": "d0bbace3698b98e458856143676b7f631ee8e18f"
+  "gitHead": "75272567eb3ec948a5cdeb8346ef9cacac58267f"
 }

package/src/components/RuleEventRow.js

@@ -24,7 +24,11 @@ export const RuleEventRow = ({ user, user_name, ts, payload }) => {
             content={formatMessage(
               {
                 id: `rules.events.action_${action}${
-                  typeof value === "undefined" || _.isObject(value) ? "" : "_to"
+                  action === "changed" &&
+                  typeof value !== "undefined" &&
+                  !_.isObject(value)
+                    ? "_to"
+                    : ""
                 }`,
               },
               [field, JSON.stringify(value)]

package/src/components/RuleForm.js

@@ -100,7 +100,9 @@ export const RuleForm = ({
     if (ruleData) {
       setRule({
         ...ruleData,
-        description: ruleData.description || "",
+        description: _.isString(ruleData?.description)
+          ? ruleData.description
+          : "",
         concept: {
           name: ruleData?.current_business_concept_version?.name,
           business_concept_id: ruleData.business_concept_id,

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

@@ -4,7 +4,7 @@ import { EditRule } from "../EditRule";
 
 jest.mock("@truedat/bg/concepts/hooks/useConcepts", () => {
   const originalModule = jest.requireActual(
-    "@truedat/bg/concepts/hooks/useConcepts"
+    "@truedat/bg/concepts/hooks/useConcepts",
   );
 
   return {

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

@@ -6,7 +6,8 @@ const rule = {
   business_concept_id: "2D2B3",
   domain_id: 1,
   domain: { id: 1, name: "foo", external_id: "bar" },
-  description: "desc",
+  description:
+    "# Description\n\n - this is a list\n\n_with bold_ and +italic+ text. ",
   rule_type: { name: "type1" },
 };
 

package/src/components/__tests__/__snapshots__/RuleProperties.spec.js.snap

@@ -23,8 +23,27 @@ exports[`<RuleProperties /> matches the latest snapshot 1`] = `
       <div
         class="markdown-reader"
       >
+        <h1>
+          Description
+        </h1>
+        
+
+        <ul>
+          
+
+          <li>
+            this is a list
+          </li>
+          
+
+        </ul>
+        
+
         <p>
-          desc
+          <em>
+            with bold
+          </em>
+           and +italic+ text. 
         </p>
         
 

package/src/selectors/__tests__/getParsedEvents.spec.js

@@ -165,8 +165,8 @@ describe("selectors: getParsedEvents", () => {
       payload: [
         {
           field: "description",
-          action: "changed",
-          value: "Añadimos descripción a la regla",
+          action: "changed_without_target",
+          value: events[2].payload.description,
         },
       ],
     },
@@ -178,6 +178,8 @@ describe("selectors: getParsedEvents", () => {
         { action: "changed", field: "principle", value: "Validez" },
         { action: "changed", field: "scheduler", value: "" },
         { action: "changed", field: "tags", value: "et" },
+        { action: "removed", field: "data_owner", value: null },
+        { action: "removed", field: "proyecto", value: ["P1"] },
       ],
     },
     {
@@ -201,4 +203,133 @@ describe("selectors: getParsedEvents", () => {
     expect(res).toHaveLength(0);
     expect(res).toEqual(expect.arrayContaining([]));
   });
+
+  it("appends _without_target to changed action for fields whose template type is url/table/system/image/markdown", () => {
+    const ruleTemplate = {
+      name: "quality_template",
+      content: [
+        {
+          fields: [
+            { name: "description_md", type: "markdown" },
+            { name: "doc_url", type: "url" },
+            { name: "principle", type: "string" },
+          ],
+        },
+      ],
+    };
+
+    const implementationTemplate = {
+      name: "ri_template",
+      content: [
+        {
+          fields: [
+            { name: "notes_md", type: "markdown" },
+            { name: "evidence", type: "image" },
+            { name: "comment", type: "string" },
+          ],
+        },
+      ],
+    };
+
+    const ruleEvent = {
+      id: 1,
+      service: "td_dd",
+      resource_type: "rule",
+      event: "rule_updated",
+      payload: {
+        content: {
+          changed: {
+            description_md: "# new doc",
+            doc_url: "https://example.test",
+            principle: "Validez",
+          },
+        },
+        updated_by: 1,
+      },
+    };
+
+    const implementationEvent = {
+      id: 2,
+      service: "td_dd",
+      resource_type: "implementation",
+      event: "implementation_changed",
+      payload: {
+        df_content: {
+          changed: {
+            notes_md: "## hi",
+            evidence: { url: "x" },
+            comment: "ok",
+          },
+        },
+      },
+    };
+
+    const state = {
+      events: [ruleEvent, implementationEvent],
+      rule: { df_name: "quality_template" },
+      templates: [ruleTemplate],
+      ruleImplementation: { df_name: "ri_template" },
+      allTemplates: [implementationTemplate],
+    };
+
+    const [ruleParsed, implParsed] = getParsedEvents(state);
+
+    expect(ruleParsed.payload).toEqual([
+      {
+        field: "description_md",
+        action: "changed_without_target",
+        value: "# new doc",
+      },
+      {
+        field: "doc_url",
+        action: "changed_without_target",
+        value: "https://example.test",
+      },
+      { field: "principle", action: "changed", value: "Validez" },
+    ]);
+
+    expect(implParsed.payload).toEqual([
+      {
+        field: "notes_md",
+        action: "changed_without_target",
+        value: "## hi",
+      },
+      {
+        field: "evidence",
+        action: "changed_without_target",
+        value: { url: "x" },
+      },
+      { field: "comment", action: "changed", value: "ok" },
+    ]);
+  });
+
+  it("emits added/changed/removed entries from df_content and unwraps {value, origin} fields", () => {
+    const event = {
+      id: 274884,
+      service: "td_dd",
+      resource_type: "implementation",
+      event: "implementation_changed",
+      payload: {
+        df_content: {
+          added: {
+            User: { origin: "user", value: "Inés Owner" },
+          },
+          changed: {
+            comment: { origin: "user", value: "updated" },
+          },
+          removed: {
+            tag: { origin: "default", value: "stale" },
+          },
+        },
+      },
+    };
+
+    const [parsed] = getParsedEvents({ events: [event] });
+
+    expect(parsed.payload).toEqual([
+      { field: "comment", action: "changed", value: "updated" },
+      { field: "User", action: "added", value: "Inés Owner" },
+      { field: "tag", action: "removed", value: "stale" },
+    ]);
+  });
 });

package/src/selectors/getParsedEvents.js

@@ -1,35 +1,61 @@
 import _ from "lodash/fp";
 import { createSelector } from "reselect";
 
-const getEvents = ({ events }) => {
-  return events;
-};
+const FIELDS_WITHOUT_VALUE_TYPES = [
+  "url",
+  "table",
+  "system",
+  "image",
+  "markdown",
+];
+
+const getEvents = ({ events }) => events;
+
+const getRuleTemplate = (state) =>
+  _.find(_.propEq("name", _.getOr(null, "rule.df_name", state)))(
+    _.getOr([], "templates", state),
+  );
+
+const getImplementationTemplate = (state) =>
+  _.find(_.propEq("name", _.getOr(null, "ruleImplementation.df_name", state)))(
+    _.getOr([], "allTemplates", state),
+  );
+
+const getFieldsWithoutValue = (template) =>
+  _.flow(
+    _.getOr([], "content"),
+    _.map(_.getOr([], "fields")),
+    _.flatten,
+    _.filter((f) => _.includes(_.prop("type")(f))(FIELDS_WITHOUT_VALUE_TYPES)),
+    _.map(_.prop("name")),
+  )(template);
+
+const withoutTargetAction = (action, field, fieldsWithoutValue) =>
+  _.includes(field)(fieldsWithoutValue) ? `${action}_without_target` : action;
+
+const unwrapFieldValue = (fieldValue) =>
+  _.isObject(fieldValue) && !_.isNull(fieldValue) && _.has("value", fieldValue)
+    ? fieldValue.value
+    : fieldValue;
 
 const transformFieldFormat = (field) =>
   _.isBoolean(field) ? _.toString(field) : field;
 
-const findDeep = (obj, key) =>
-  _.has(key, obj)
-    ? obj[key]
-    : _.flatten(
-        _.map((v) => (typeof v == "object" ? findDeep(v, key) : []), obj)
-      );
-
-const transformRulePayloadFormat = (payload, field) => {
-  switch (field) {
-    case "content":
-      return payload.content;
-    case "description":
-      return _.first(findDeep(payload.description, "text"));
-    default:
-      return payload[field];
-  }
-};
+const getContentChanges = (action, fields, fieldsWithoutValue) =>
+  _.flow(
+    _.toPairs,
+    _.map(([field, rawValue]) => ({
+      field,
+      action: withoutTargetAction(action, field, fieldsWithoutValue),
+      value: transformFieldFormat(unwrapFieldValue(rawValue)),
+    })),
+  )(fields || {});
 
 const getImplementationUpdatedEvent = (e) => {
   const { payload } = e;
   if (!payload) return { ...e, payload: [] };
 
+  // eslint-disable-next-line fp/no-let
   let field_config = [];
 
   const { new_domain } = payload;
@@ -45,6 +71,7 @@ const getImplementationUpdatedEvent = (e) => {
       value: domain_new_name,
     })(field_config);
   } else {
+    // eslint-disable-next-line fp/no-mutation
     field_config = _.concat({
       action: "updated",
       field: _.path("payload.implementation_key")(e),
@@ -53,129 +80,155 @@ const getImplementationUpdatedEvent = (e) => {
   return { ...e, payload: field_config };
 };
 
-const getParsedEvents = createSelector([getEvents], (events) => {
-  return _.map((d) => {
-    switch (d.event) {
-      case "implementation_created":
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.rule_name")(d),
-              action: "created",
-            },
-          ],
-        };
-      case "implementation_moved":
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.rule_name")(d),
-              action: "moved",
-            },
-          ],
-        };
-      case "implementation_restored":
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.implementation_key")(d),
-              action: "restored",
-            },
-          ],
-        };
-      case "implementation_deleted":
-        return {};
-      case "implementation_deprecated":
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.implementation_key")(d),
-              action: "deprecated",
-            },
-          ],
-        };
-      case "implementation_changed":
-        return {
-          ...d,
-          payload: _.flow(
-            _.path("payload.df_content.changed"),
-            _.keys,
-            _.map((e) => ({
-              field: e,
-              action: "changed",
-              value: transformFieldFormat(
-                _.path(`payload.df_content.changed.${e}`)(d)
+const getParsedEvents = createSelector(
+  [getEvents, getRuleTemplate, getImplementationTemplate],
+  (events, ruleTemplate, implementationTemplate) => {
+    const ruleFieldsWithoutValue = getFieldsWithoutValue(ruleTemplate);
+    const implementationFieldsWithoutValue = getFieldsWithoutValue(
+      implementationTemplate,
+    );
+
+    return _.map((d) => {
+      switch (d.event) {
+        case "implementation_created":
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.rule_name")(d),
+                action: "created",
+              },
+            ],
+          };
+        case "implementation_moved":
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.rule_name")(d),
+                action: "moved",
+              },
+            ],
+          };
+        case "implementation_restored":
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.implementation_key")(d),
+                action: "restored",
+              },
+            ],
+          };
+        case "implementation_deleted":
+          return {};
+        case "implementation_deprecated":
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.implementation_key")(d),
+                action: "deprecated",
+              },
+            ],
+          };
+        case "implementation_changed": {
+          const dfContent = _.getOr({}, "payload.df_content")(d);
+          return {
+            ...d,
+            payload: [
+              ...getContentChanges(
+                "changed",
+                dfContent.changed,
+                implementationFieldsWithoutValue,
+              ),
+              ...getContentChanges(
+                "added",
+                dfContent.added,
+                implementationFieldsWithoutValue,
+              ),
+              ...getContentChanges(
+                "removed",
+                dfContent.removed,
+                implementationFieldsWithoutValue,
               ),
-            }))
-          )(d),
-        };
-      case "implementation_status_updated":
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.implementation_key")(d),
-              action: _.path("payload.status")(d),
-            },
-          ],
-        };
-
-      case "implementation_updated":
-        return getImplementationUpdatedEvent(d);
-
-      case "rule_created":
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.name")(d),
-              action: "created",
-            },
-          ],
-        };
-      case "rule_updated":
-        const content = _.flow(
-          _.getOr({}, "payload.content.changed"),
-          _.toPairs,
-          _.map(([field, value]) => ({
-            field,
-            value,
-            action: "changed",
-          }))
-        )(d);
-        return {
-          ...d,
-          payload: [
-            ..._.flow(
-              _.path("payload"),
-              _.omit(["updated_by", "content"]),
-              _.keys,
-              _.map((field) => ({
-                field: field,
-                action: "changed",
-                value: transformRulePayloadFormat(d.payload, field),
-              }))
-            )(d),
-            ...content,
-          ],
-        };
-
-      default:
-        return {
-          ...d,
-          payload: [
-            {
-              field: _.path("payload.implementation_key")(d),
-              action: "updated",
-            },
-          ],
-        };
-    }
-  })(events);
-});
+            ],
+          };
+        }
+        case "implementation_status_updated":
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.implementation_key")(d),
+                action: _.path("payload.status")(d),
+              },
+            ],
+          };
+
+        case "implementation_updated":
+          return getImplementationUpdatedEvent(d);
+
+        case "rule_created":
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.name")(d),
+                action: "created",
+              },
+            ],
+          };
+        case "rule_updated": {
+          const content = _.getOr({}, "payload.content")(d);
+          return {
+            ...d,
+            payload: [
+              ..._.flow(
+                _.path("payload"),
+                _.omit(["updated_by", "content"]),
+                _.keys,
+                _.map((field) => ({
+                  field,
+                  action:
+                    field === "description"
+                      ? "changed_without_target"
+                      : "changed",
+                  value: d.payload[field],
+                })),
+              )(d),
+              ...getContentChanges(
+                "changed",
+                content.changed,
+                ruleFieldsWithoutValue,
+              ),
+              ...getContentChanges(
+                "added",
+                content.added,
+                ruleFieldsWithoutValue,
+              ),
+              ...getContentChanges(
+                "removed",
+                content.removed,
+                ruleFieldsWithoutValue,
+              ),
+            ],
+          };
+        }
+
+        default:
+          return {
+            ...d,
+            payload: [
+              {
+                field: _.path("payload.implementation_key")(d),
+                action: "updated",
+              },
+            ],
+          };
+      }
+    })(events);
+  },
+);
 
 export { getParsedEvents };