@truedat/df 6.6.5 → 6.7.0

package/src/templates/utils/__tests__/filterDomains.spec.js

@@ -13,53 +13,98 @@ describe("filterDomains", () => {
 
   it("filters domains on content if value not present", () => {
     const result = {
-      foo: "foo",
+      foo: { value: "foo", origin: "default" },
     };
-    expect(filterDomains(templateContent)({ foo: "foo", bar: "z" })).toEqual(
-      result
-    );
-    expect(filterDomains(templateContent)({ foo: "foo", bar: "z" }, 1)).toEqual(
-      result
-    );
+    expect(
+      filterDomains(templateContent)({
+        foo: { value: "foo", origin: "default" },
+        bar: { value: "z", origin: "default" },
+      })
+    ).toEqual(result);
+    expect(
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: "z", origin: "default" },
+        },
+        1
+      )
+    ).toEqual(result);
 
-    expect(filterDomains(templateContent)({ foo: "foo", bar: "z" }, 2)).toEqual(
-      result
-    );
+    expect(
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: "z", origin: "default" },
+        },
+        2
+      )
+    ).toEqual(result);
 
-    expect(filterDomains(templateContent)({ foo: "foo", bar: "a" }, 3)).toEqual(
-      result
-    );
+    expect(
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: "a", origin: "default" },
+        },
+        3
+      )
+    ).toEqual(result);
   });
 
   it("do not filter domain single value if correct", () => {
-    expect(filterDomains(templateContent)({ foo: "foo", bar: "a" }, 1)).toEqual(
-      {
-        foo: "foo",
-        bar: "a",
-      }
-    );
+    expect(
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: "a", origin: "default" },
+        },
+        1
+      )
+    ).toEqual({
+      foo: { value: "foo", origin: "default" },
+      bar: { value: "a", origin: "default" },
+    });
 
-    expect(filterDomains(templateContent)({ foo: "foo", bar: "e" }, 2)).toEqual(
-      {
-        foo: "foo",
-        bar: "e",
-      }
-    );
+    expect(
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: "e", origin: "default" },
+        },
+        2
+      )
+    ).toEqual({
+      foo: { value: "foo", origin: "default" },
+      bar: { value: "e", origin: "default" },
+    });
   });
 
   it("do not filter domain multiple value if correct", () => {
     expect(
-      filterDomains(templateContent)({ foo: "foo", bar: ["a"] }, 1)
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: ["a"], origin: "default" },
+        },
+        1
+      )
     ).toEqual({
-      foo: "foo",
-      bar: ["a"],
+      foo: { value: "foo", origin: "default" },
+      bar: { value: ["a"], origin: "default" },
     });
 
     expect(
-      filterDomains(templateContent)({ foo: "foo", bar: ["e"] }, 2)
+      filterDomains(templateContent)(
+        {
+          foo: { value: "foo", origin: "default" },
+          bar: { value: ["e"], origin: "default" },
+        },
+        2
+      )
     ).toEqual({
-      foo: "foo",
-      bar: ["e"],
+      foo: { value: "foo", origin: "default" },
+      bar: { value: ["e"], origin: "default" },
     });
   });
 });

package/src/templates/utils/__tests__/filterSwitches.spec.js

@@ -35,17 +35,46 @@ describe("utils: isSwitch", () => {
 describe("utils: isSwitchValid", () => {
   it("should detect valid and invalid values", () => {
     const validator = isSwitchValid("target", "src")(switchValues1);
-    expect(validator({ src: "foo", target: "foo1" })).toBe(true);
-    expect(validator({ src: "bar", target: "bar2" })).toBe(true);
-    expect(validator({ src: "baz", target: "xyzzy" })).toBe(false);
-    expect(validator({ src: "foo", target: ["foo1"] })).toBe(true);
-    expect(validator({ src: "foo", target: "" })).toBe(true);
+    expect(
+      validator({
+        src: { value: "foo", origin: "default" },
+        target: { value: "foo1", origin: "default" },
+      })
+    ).toBe(true);
+    expect(
+      validator({
+        src: { value: "bar", origin: "default" },
+        target: { value: "bar2", origin: "default" },
+      })
+    ).toBe(true);
+    expect(
+      validator({
+        src: { value: "baz", origin: "default" },
+        target: { value: "xyzzy", origin: "default" },
+      })
+    ).toBe(false);
+    expect(
+      validator({
+        src: { value: "foo", origin: "default" },
+        target: { value: ["foo1"], origin: "default" },
+      })
+    ).toBe(true);
+    expect(
+      validator({
+        src: { value: "foo", origin: "default" },
+        target: { value: "", origin: "default" },
+      })
+    ).toBe(true);
   });
 });
 
 describe("utils: filterSwitches", () => {
   it("should remove keys with unlisted values", () => {
-    const o = { src: "foo", target: "foo1", xyzzy: "xyzzy" };
+    const o = {
+      src: { value: "foo", origin: "default" },
+      target: { value: "foo1", origin: "default" },
+      xyzzy: { value: "xyzzy", origin: "default" },
+    };
     const filter = filterSwitches(templateContent);
     expect(filter({ ...o, target2: "boo" })).toMatchObject(o);
   });

package/src/templates/utils/__tests__/filterValues.spec.js

@@ -21,12 +21,12 @@ describe("utils: validValues", () => {
   });
 
   describe("utils: filterValues", () => {
-    const xyzzy = "xyzzy";
+    const xyzzy = { value: "xyzzy", origin: "default" };
 
     it("should allow valid values to pass through", () => {
       const o = {
-        role: "u2",
-        fixed: "baz",
+        role: { value: "u2", origin: "default" },
+        fixed: { value: "baz", origin: "default" },
         xyzzy,
       };
       const result = filterValues(templateContent)(o);
@@ -34,13 +34,25 @@ describe("utils: validValues", () => {
     });
 
     it("should nullify unlisted users", () => {
-      const result = filterValues(templateContent)({ role: "ho", xyzzy });
-      expect(result).toEqual({ role: null, xyzzy });
+      const result = filterValues(templateContent)({
+        role: { value: "ho", origin: "default" },
+        xyzzy,
+      });
+      expect(result).toEqual({
+        role: { value: null, origin: "default" },
+        xyzzy,
+      });
     });
 
     it("should nullify unlisted fixed values", () => {
-      const result = filterValues(templateContent)({ fixed: "ho", xyzzy });
-      expect(result).toEqual({ fixed: null, xyzzy });
+      const result = filterValues(templateContent)({
+        fixed: { value: "ho", origin: "default" },
+        xyzzy,
+      });
+      expect(result).toEqual({
+        fixed: { value: null, origin: "default" },
+        xyzzy,
+      });
     });
   });
 });

package/src/templates/utils/__tests__/parseFieldOptions.spec.js

@@ -6,9 +6,12 @@ const parseFormatFieldOptions = parseFieldOptions(formatMessage);
 describe("utils: parseFieldOptions", () => {
   it("adds value to field", () => {
     const field = { name: "field" };
-    const content = { field: "1" };
+    const content = { field: { value: "1", origin: "default" } };
     const result = parseFormatFieldOptions(content)(field);
-    expect(result).toEqual({ ...field, value: "1" });
+    expect(result).toEqual({
+      ...field,
+      value: { value: "1", origin: "default" },
+    });
   });
 
   it("handles values switch", () => {
@@ -24,11 +27,14 @@ describe("utils: parseFieldOptions", () => {
         },
       },
     };
-    const content = { field: "1", switcher: "odd" };
+    const content = {
+      field: { value: "1", origin: "default" },
+      switcher: { value: "odd", origin: "default" },
+    };
     const result = parseFormatFieldOptions(content)(field);
     expect(result).toEqual({
       ...field,
-      value: "1",
+      value: { value: "1", origin: "default" },
       parsedValues: [
         { text: "1", value: "1" },
         { text: "3", value: "3" },
@@ -43,11 +49,11 @@ describe("utils: parseFieldOptions", () => {
         fixed: ["a", "b", "c"],
       },
     };
-    const content = { field: "b" };
+    const content = { field: { value: "b", origin: "default" } };
     const result = parseFormatFieldOptions(content)(field);
     expect(result).toEqual({
       ...field,
-      value: "b",
+      value: { value: "b", origin: "default" },
       parsedValues: [
         { text: "a", value: "a" },
         { text: "b", value: "b" },
@@ -66,11 +72,11 @@ describe("utils: parseFieldOptions", () => {
         ],
       },
     };
-    const content = { field: "a" };
+    const content = { field: { value: "a", origin: "default" } };
     const result = parseFormatFieldOptions(content)(field);
     expect(result).toEqual({
       ...field,
-      value: "a",
+      value: { value: "a", origin: "default" },
       parsedValues: [
         { text: "a", value: "a" },
         { text: "b", value: "b" },
@@ -86,11 +92,11 @@ describe("utils: parseFieldOptions", () => {
         processed_users: ["x", "y", "z"],
       },
     };
-    const content = { field: "y" };
+    const content = { field: { value: "y", origin: "default" } };
     const result = parseFormatFieldOptions(content)(field);
     expect(result).toEqual({
       ...field,
-      value: "y",
+      value: { value: "y", origin: "default" },
       parsedValues: [
         { text: "x", value: "x" },
         { text: "y", value: "y" },
@@ -109,11 +115,11 @@ describe("utils: parseFieldOptions", () => {
         },
       },
     };
-    const content = { field: "bar" };
+    const content = { field: { value: "bar", origin: "default" } };
     const result = parseFormatFieldOptions(content, selectedDomain)(field);
     expect(result).toEqual({
       ...field,
-      value: "bar",
+      value: { value: "bar", origin: "default" },
       parsedValues: [
         { text: "bar", value: "bar" },
         { text: "foo", value: "foo" },

package/src/templates/utils/__tests__/parseGroups.spec.js

@@ -16,16 +16,23 @@ describe("utils: parseGroups", () => {
         },
       ],
     };
-    const content = { field: "1", field_mandatory: "2" };
+    const content = {
+      field: { value: "1", origin: "user" },
+      field_mandatory: { value: "2", origin: "user" },
+    };
     const result = formatParseGroups(template, content);
     expect(result).toEqual([
       {
         fields: [
-          { name: "field", required: false, value: "1" },
+          {
+            name: "field",
+            required: false,
+            value: { value: "1", origin: "user" },
+          },
           {
             name: "field_mandatory",
             required: true,
-            value: "2",
+            value: { value: "2", origin: "user" },
             cardinality: "1",
           },
         ],
@@ -43,12 +50,18 @@ describe("utils: parseGroups", () => {
         },
       ],
     };
-    const content = { field: "1" };
+    const content = { field: { value: "1", origin: "user" } };
     const fieldsToOmit = ["ommitedField"];
     const result = formatParseGroups(template, content, fieldsToOmit);
     expect(result).toEqual([
       {
-        fields: [{ name: "field", required: false, value: "1" }],
+        fields: [
+          {
+            name: "field",
+            required: false,
+            value: { value: "1", origin: "user" },
+          },
+        ],
         name: "group1",
       },
     ]);
@@ -67,7 +80,10 @@ describe("utils: parseGroups", () => {
         },
       ],
     };
-    const content = { parent: "b", dependant: "value" };
+    const content = {
+      parent: { value: "b", origin: "user" },
+      dependant: { value: "value", origin: "user" },
+    };
     const fieldsToOmit = ["ommitedField"];
     const result = formatParseGroups(template, content, fieldsToOmit);
     expect(result).toEqual([
@@ -81,12 +97,12 @@ describe("utils: parseGroups", () => {
             ],
             values: { fixed: ["a", "b"] },
             required: false,
-            value: "b",
+            value: { value: "b", origin: "user" },
           },
           {
             name: "dependant",
             depends: { on: "parent", to_be: "b" },
-            value: "value",
+            value: { value: "value", origin: "user" },
             required: false,
           },
         ],
@@ -107,7 +123,7 @@ describe("utils: parseGroups", () => {
         },
       ],
     };
-    const content = { parent: ["b", "c"] };
+    const content = { parent: { value: ["b", "c"], origin: "user" } };
     const fieldsToOmit = ["ommitedField"];
     const result = formatParseGroups(template, content, fieldsToOmit);
     expect(result).toEqual([
@@ -122,7 +138,7 @@ describe("utils: parseGroups", () => {
             ],
             values: { fixed: ["a", "b", "c"] },
             required: false,
-            value: ["b", "c"],
+            value: { value: ["b", "c"], origin: "user" },
           },
         ],
         name: "group1",
@@ -153,7 +169,10 @@ describe("utils: parseGroups", () => {
         },
       ],
     };
-    const content = { parent: "b", dependant: "1" };
+    const content = {
+      parent: { value: "b", origin: "user" },
+      dependant: { value: "1", origin: "user" },
+    };
     const fieldsToOmit = ["ommitedField"];
     const result = formatParseGroups(template, content, fieldsToOmit);
     expect(result).toEqual([
@@ -167,7 +186,7 @@ describe("utils: parseGroups", () => {
             ],
             values: { fixed: ["a", "b"] },
             required: false,
-            value: "b",
+            value: { value: "b", origin: "user" },
           },
           {
             name: "dependant",
@@ -175,7 +194,7 @@ describe("utils: parseGroups", () => {
               switch: { on: "parent", values: { b: "1" } },
             },
             parsedValues: [{ text: "1", value: "1" }],
-            value: "1",
+            value: { value: "1", origin: "user" },
             required: false,
           },
         ],
@@ -194,11 +213,17 @@ describe("utils: parseGroups", () => {
         { name: "empty_group" },
       ],
     };
-    const content = { field: "1" };
+    const content = { field: { value: "1", origin: "user" } };
     const result = formatParseGroups(template, content);
     expect(result).toEqual([
       {
-        fields: [{ name: "field", required: false, value: "1" }],
+        fields: [
+          {
+            name: "field",
+            required: false,
+            value: { value: "1", origin: "user" },
+          },
+        ],
         name: "group1",
       },
     ]);
@@ -218,16 +243,30 @@ describe("utils: parseGroups", () => {
         },
       ],
     };
-    const content = { secret: "1", not_secret: "2" };
+    const content = {
+      secret: { value: "1", origin: "user" },
+      not_secret: { value: "2", origin: "user" },
+    };
     const result = formatParseGroups(template, content);
     expect(result).toEqual([
       {
-        fields: [{ name: "not_secret", required: false, value: "2" }],
+        fields: [
+          {
+            name: "not_secret",
+            required: false,
+            value: { value: "2", origin: "user" },
+          },
+        ],
         name: "group1",
       },
       {
         fields: [
-          { name: "secret", required: false, value: "1", isSecret: true },
+          {
+            name: "secret",
+            required: false,
+            value: { value: "1", origin: "user" },
+            isSecret: true,
+          },
         ],
         is_secret: true,
         name: "group2",

package/src/templates/utils/applyDefaults.js

@@ -1,18 +1,19 @@
 import _ from "lodash/fp";
+import { toEnrichedTextFormat } from "@truedat/core/services/format";
 
 const meetsDependency = (defaults, content, on, to_be) => {
-  const field = getDefaultValue(defaults, content, on);
+  const field_value = getDefaultValue(defaults, content, on);
   return (
     _.every(_.negate(_.isNil))([on, to_be]) &&
-    (_.isArray(field)
-      ? _.some((d) => to_be.includes(d))(field)
-      : to_be.includes(field))
+    (_.isArray(field_value)
+      ? _.some((d) => to_be.includes(d))(field_value)
+      : to_be.includes(field_value))
   );
 };
 
-const meetsSwitchCondition = (defaults, content, onSwitch, value) => {
-  const field = getDefaultValue(defaults, content, onSwitch);
-  return !_.isNil(onSwitch) && _.isObject(value) && _.has(field)(value);
+const meetsSwitchCondition = (defaults, content, onSwitch, values) => {
+  const field_value = getDefaultValue(defaults, content, onSwitch);
+  return !_.isNil(onSwitch) && _.isObject(values) && _.has(field_value)(values);
 };
 
 const meetsDomain = (values, domainId) =>
@@ -22,7 +23,21 @@ const standardDefault = (on, toBe, onSwitch, onDomain) =>
   _.every(_.isNil)([on, toBe, onSwitch, onDomain]);
 
 const getDefaultValue = (defaults, content, on) =>
-  _.defaultTo(_.prop(on)(defaults))(_.prop(on)(content));
+  _.get("value")(_.defaultTo(_.prop(on)(defaults))(_.prop(on)(content)));
+
+const getDefaultSwitchValue = (defaults, content, onSwitch, value) =>
+  _.isObject(value) &&
+  (_.has(onSwitch)(defaults) || _.has(onSwitch)(content)) &&
+  _.flow(
+    (d) => getDefaultValue(d, content, onSwitch),
+    (v) => _.getOr(null)(v)(value)
+  )(defaults);
+
+const getFieldType = (field, templateContent) =>
+  _.flow(
+    _.find(({ name }) => field === name),
+    _.get("type")
+  )(templateContent);
 
 export const applyDefaults = (templateContent) => (content, domainId) =>
   _.flow(
@@ -34,29 +49,55 @@ export const applyDefaults = (templateContent) => (content, domainId) =>
         { name, default: value, depends: { on, to_be: toBe } = {}, values }
       ) => {
         const onSwitch = values?.switch?.on;
+        const onSwitchValues = values?.switch?.values;
         const onDomain = values?.domain;
 
         if (standardDefault(on, toBe, onSwitch, onDomain)) {
-          return _.assoc(name, value)(acc);
+          const fieldValue =
+            getFieldType(name, templateContent) === "enriched_text"
+              ? _.set("value", toEnrichedTextFormat(value.value))(value)
+              : value;
+
+          return _.assoc(name, fieldValue)(acc);
         }
         if (meetsDependency(acc, content, on, toBe)) {
-          if (meetsSwitchCondition(acc, content, onSwitch, value)) {
-            const field = getDefaultValue(acc, content, onSwitch);
-            const defaultValue = _.prop(field)(value);
-            return _.assoc(name, defaultValue)(acc);
+          if (meetsSwitchCondition(acc, content, onSwitch, onSwitchValues)) {
+            const defaultValue = getDefaultSwitchValue(
+              acc,
+              content,
+              onSwitch,
+              value.value
+            );
+            return _.assoc(name, {
+              ...value,
+              value: defaultValue || value.value,
+            })(acc);
           } else if (meetsDomain(onDomain, domainId)) {
-            const defaultValue = _.prop(domainId)(value);
-            return _.assoc(name, defaultValue)(acc);
+            const defaultValue = _.prop(domainId)(value.value);
+            return defaultValue
+              ? _.assoc(name, { ...value, value: defaultValue })(acc)
+              : acc;
           } else {
             return _.assoc(name, value)(acc);
           }
-        } else if (meetsSwitchCondition(acc, content, onSwitch, value)) {
-          const field = getDefaultValue(acc, content, onSwitch);
-          const defaultValue = _.prop(field)(value);
-          return _.assoc(name, defaultValue)(acc);
+        } else if (
+          meetsSwitchCondition(acc, content, onSwitch, onSwitchValues)
+        ) {
+          const defaultValue = getDefaultSwitchValue(
+            acc,
+            content,
+            onSwitch,
+            value.value
+          );
+          return _.assoc(name, {
+            ...value,
+            value: defaultValue || "",
+          })(acc);
         } else if (meetsDomain(onDomain, domainId)) {
-          const defaultValue = _.prop(domainId)(value);
-          return _.assoc(name, defaultValue)(acc);
+          const defaultValue = _.prop(domainId)(value.value);
+          return defaultValue
+            ? _.assoc(name, { ...value, value: defaultValue })(acc)
+            : acc;
         }
         return acc;
       },

package/src/templates/utils/filterDepends.js

@@ -1,7 +1,9 @@
 import _ from "lodash/fp";
 
-const checkDependency = (on, to_be) =>
-  _.isArray(on) ? _.some((d) => to_be.includes(d))(on) : to_be.includes(on);
+const checkDependency = ({ value: on_value }, to_be) =>
+  _.isArray(on_value)
+    ? _.some((d) => to_be.includes(d))(on_value)
+    : to_be.includes(on_value);
 
 const arrayOrString = (to_be) => _.isString(to_be) || _.isArray(to_be);
 

package/src/templates/utils/filterDomains.js

@@ -2,7 +2,7 @@ import _ from "lodash/fp";
 
 const validDomainValue = (field, content, domainId) => {
   const name = _.prop("name")(field);
-  const value = _.prop(name)(content);
+  const value = _.prop("value")(_.prop(name)(content));
   const values = _.prop(domainId)(field?.values?.domain);
 
   return (

package/src/templates/utils/filterSwitches.js

@@ -16,13 +16,13 @@ export const isSwitchValid = (prop, on) =>
   _.flow(
     _.map.convert({ cap: false })((validValues, onValue) =>
       _.conformsTo({
-        [on]: _.eq(onValue),
-        [prop]: (v) =>
-          isEmpty(v)
+        [on]: _.conforms({ value: _.eq(onValue) }),
+        [prop]: ({ value }) =>
+          isEmpty(value)
             ? true
-            : _.isArray(v)
-            ? _.isEmpty(_.without(validValues)(v))
-            : _.includes(v)(validValues),
+            : _.isArray(value)
+            ? _.isEmpty(_.without(validValues)(value))
+            : _.includes(value)(validValues),
       })
     ),
     _.overSome

package/src/templates/utils/filterValues.js

@@ -32,11 +32,14 @@ export const filterValues = (templateContent) => {
   const vv = validValues(templateContent);
   return _.mapValues.convert({ cap: false })((value, key) =>
     _.has(key)(vv)
-      ? _.isArray(value)
-        ? _.filter((v) => _.includes(v)(_.prop(key)(vv)))(value)
-        : _.includes(value)(_.prop(key)(vv))
+      ? _.isArray(value.value)
+        ? _.set(
+            "value",
+            _.filter((v) => _.includes(v)(_.prop(key)(vv)))(value.value)
+          )(value)
+        : _.includes(value.value)(_.prop(key)(vv))
         ? value
-        : null
+        : { ...value, value: null }
       : value
   );
 };