@truedat/df 6.6.5 → 6.7.0

package/src/components/widgets/__tests__/__snapshots__/HierarchyDropdown.spec.js.snap

@@ -1,3 +1,9 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`<HierarchyDropdown /> matches the latest snapshot (min-depth 0) 1`] = `<div />`;
+
+exports[`<HierarchyDropdown /> matches the latest snapshot (min-depth 2) 1`] = `<div />`;
+
+exports[`<HierarchyDropdown /> matches the latest snapshot (missing min-depth) 1`] = `<div />`;
+
 exports[`<HierarchyDropdown /> matches the latest snapshot 1`] = `<div />`;

package/src/templates/components/templateForm/ActiveGroupForm.js

@@ -58,7 +58,10 @@ export const ActiveGroupForm = ({
       widget: "string",
       cardinality: "?",
       type: "string",
-      default: "",
+      default: {
+        value: "",
+        origin: "default",
+      },
       values: null,
     };
     const name = `${groupNamePrefix}.fields`;

package/src/templates/components/templateForm/DefaultValue.js

@@ -40,14 +40,14 @@ export const DefaultValue = ({
   const onDefaultValueChange = (e, { value }) => {
     onChange(null, {
       name: defaultField,
-      value: formatDefaultValue(type, value),
+      value: { value: formatDefaultValue(type, value), origin: "default" },
     });
   };
 
   const onMultipleDefaultValueChange = (e, { value }) => {
     onChange(null, {
       name: defaultField,
-      value: value,
+      value: { value, origin: "default" },
     });
   };
 
@@ -66,7 +66,7 @@ export const DefaultValue = ({
     <>
       {!type && fieldType === "date" && (
         <DateField
-          field={{ ...field, value: _.get("default")(field) }}
+          field={{ ...field, value: _.get("default.value")(field) }}
           onChange={(e, { value }) =>
             onDefaultValueChange(e, { name: name, value: value })
           }
@@ -74,7 +74,7 @@ export const DefaultValue = ({
       )}
       {!type && fieldType === "datetime" && (
         <DateTimeField
-          field={{ ...field, value: _.get("default")(field) }}
+          field={{ ...field, value: _.get("default.value")(field) }}
           onChange={(e, { value }) =>
             onDefaultValueChange(e, { name: name, value: value })
           }
@@ -82,7 +82,7 @@ export const DefaultValue = ({
       )}
       {!type && (fieldType === "integer" || fieldType === "float") && (
         <NumberField
-          field={{ ...field, value: _.get("default")(field) }}
+          field={{ ...field, value: _.get("default.value")(field) }}
           onChange={onDefaultValueChange}
         />
       )}
@@ -101,7 +101,7 @@ export const DefaultValue = ({
             label={formatMessage({
               id: "template.field.values.default_value",
             })}
-            value={_.get("default")(field)}
+            value={_.get("default.value")(field)}
             onChange={onDefaultValueChange}
           />
         )}
@@ -111,7 +111,7 @@ export const DefaultValue = ({
           selection
           label={formatMessage({ id: "template.field.values.default_value" })}
           onChange={onDefaultValueChange}
-          value={defaultValueFormat(_.get("default")(field))}
+          value={defaultValueFormat(_.get("default.value")(field))}
           options={_.map((v) => ({
             key: v,
             value: v,
@@ -127,7 +127,7 @@ export const DefaultValue = ({
             multiple
             label={formatMessage({ id: "template.field.values.default_value" })}
             onChange={onMultipleDefaultValueChange}
-            value={multipleDefaultValueFormat(_.get("default")(field))}
+            value={multipleDefaultValueFormat(_.get("default.value")(field))}
             options={_.map((v) => ({
               key: v,
               value: v,
@@ -144,12 +144,15 @@ export const DefaultValue = ({
           allowAdditions
           label={formatMessage({ id: "template.field.values.default_value" })}
           onChange={onMultipleDefaultValueChange}
-          value={multipleDefaultValueFormat(_.get("default")(field))}
+          value={multipleDefaultValueFormat(_.get("default.value")(field))}
           options={_.map((v) => ({
             key: v,
             value: v,
             text: v,
-          }))(["", ...multipleDefaultValueFormat(_.get("default")(field))])}
+          }))([
+            "",
+            ...multipleDefaultValueFormat(_.get("default.value")(field)),
+          ])}
         />
       )}
     </>

package/src/templates/components/templateForm/FieldForm.js

@@ -101,7 +101,10 @@ export const FieldForm = ({
       valueName,
       defaultType(getValues(value, updatedType)) || "null"
     );
-    onChange(e, { name: defaultField, value: "" });
+    onChange(e, {
+      name: defaultField,
+      value: { value: "", origin: "default" },
+    });
     onChange(e, { name: subscribableField, value: false });
     onChange(e, data);
   };
@@ -109,7 +112,10 @@ export const FieldForm = ({
   const handleTypeChange = (e, data) => {
     const { value } = data;
     changeValue(valueName, defaultType(getValues(widget, value)) || "null");
-    onChange(e, { name: defaultField, value: "" });
+    onChange(e, {
+      name: defaultField,
+      value: { value: "", origin: "default" },
+    });
     onChange(e, { name: subscribableField, value: false });
     onChange(e, data);
   };

package/src/templates/components/templateForm/__tests__/DefaultValue.spec.js

@@ -252,7 +252,7 @@ describe("<DefaultValue />", () => {
     input.simulate("change", null, { value: 3 });
     expect(onChange).toBeCalledWith(null, {
       name: defaultField,
-      value: [3],
+      value: { value: [3], origin: "default" },
     });
   });
 
@@ -264,7 +264,7 @@ describe("<DefaultValue />", () => {
     input.simulate("change", null, { value: 3 });
     expect(onChange).toBeCalledWith(null, {
       name: defaultField,
-      value: 3,
+      value: { value: 3, origin: "default" },
     });
   });
 });

package/src/templates/components/templateForm/__tests__/FieldForm.spec.js

@@ -136,7 +136,7 @@ describe("<FieldForm />", () => {
     });
     expect(onChange).toBeCalledWith(null, {
       name: "Group.fields[0].default",
-      value: "",
+      value: { value: "", origin: "default" },
     });
     expect(onChange).toBeCalledWith(null, {
       name: "Group.fields[0].subscribable",
@@ -179,7 +179,7 @@ describe("<FieldForm />", () => {
     });
     expect(onChange).toBeCalledWith(null, {
       name: "Group.fields[0].default",
-      value: "",
+      value: { value: "", origin: "default" },
     });
     expect(onChange).toBeCalledWith(null, {
       name: "Group.fields[0].subscribable",

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

@@ -1,122 +1,172 @@
 import { applyDefaults } from "..";
 
 describe("utils: applyDefaults", () => {
-  const xyzzy = ["xyzzy", {}, null];
+  const xyzzy = { value: ["xyzzy", {}, null], origin: "default" };
 
   const templateContent = [
-    { name: "foo", default: "bar" },
-    { name: "bar", default: "1" },
+    { name: "foo", default: { value: "bar", origin: "default" } },
+    { name: "bar", default: { value: "1", origin: "default" } },
     {
       name: "qux",
-      default: "quux",
+      default: { value: "quux", origin: "default" },
       depends: {
         on: "foo",
         to_be: ["bar"],
       },
     },
-    { name: "xyz", default: { 1: ["a"] }, values: { switch: { on: "bar" } } },
+    {
+      name: "xyz",
+      values: { switch: { on: "bar", values: { 1: ["a"] } } },
+      default: {
+        value: { 1: ["a"] },
+        origin: "default",
+      },
+    },
     {
       name: "xxyy",
-      default: { 1: ["a"], 2: ["c"] },
+      default: { value: { 1: ["a"], 2: ["c"] }, origin: "default" },
       values: { domain: { 1: ["a", "b"], 2: ["c", "d"] } },
     },
   ];
 
   it("should apply simple defaults if key is not present in content", () => {
-    const content = { xyzzy, bar: "2" };
+    const content = { xyzzy, bar: { value: "2", origin: "user" } };
     const result = applyDefaults(templateContent)(content);
-    expect(result).toEqual({ foo: "bar", qux: "quux", xyzzy, bar: "2" });
+    expect(result).toEqual({
+      foo: { value: "bar", origin: "default" },
+      qux: { value: "quux", origin: "default" },
+      xyzzy,
+      bar: { value: "2", origin: "user" },
+    });
   });
 
   it("should not apply simple defaults if key is present in content", () => {
-    const content = { foo: "baz", xyzzy, bar: "2" };
+    const content = {
+      foo: { value: "baz", origin: "user" },
+      xyzzy,
+      bar: { value: "2", origin: "user" },
+    };
     const result = applyDefaults(templateContent)(content);
-    expect(result).toEqual({ foo: "baz", bar: "2", xyzzy });
+    expect(result).toEqual({
+      foo: { value: "baz", origin: "user" },
+      bar: { value: "2", origin: "user" },
+      xyzzy,
+    });
   });
 
   it("should apply conditional defaults key is not present in content", () => {
-    const content = { foo: "bar", xyzzy, bar: "2" };
+    const content = {
+      foo: { value: "bar", origin: "user" },
+      xyzzy,
+      bar: { value: "2", origin: "user" },
+    };
     const result = applyDefaults(templateContent)(content);
-    expect(result).toEqual({ foo: "bar", bar: "2", qux: "quux", xyzzy });
+    expect(result).toEqual({
+      foo: { value: "bar", origin: "user" },
+      bar: { value: "2", origin: "user" },
+      qux: { value: "quux", origin: "default" },
+      xyzzy,
+    });
   });
 
   it("should not apply conditional defaults if key is present in content", () => {
-    const content = { foo: "bar", qux: "spqr", xyzzy, bar: "2" };
+    const content = {
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
+      xyzzy,
+      bar: { value: "2", origin: "user" },
+    };
     const result = applyDefaults(templateContent)(content);
-    expect(result).toEqual({ foo: "bar", qux: "spqr", xyzzy, bar: "2" });
+    expect(result).toEqual({
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
+      xyzzy,
+      bar: { value: "2", origin: "user" },
+    });
   });
 
   it("should apply conditional switch defaults if key is not present in content", () => {
     expect(
-      applyDefaults(templateContent)({ foo: "bar", qux: "spqr", xyzzy })
+      applyDefaults(templateContent)({
+        foo: { value: "bar", origin: "user" },
+        qux: { value: "spqr", origin: "user" },
+        xyzzy,
+      })
     ).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
+      bar: { value: "1", origin: "default" },
+      xyz: { value: ["a"], origin: "default" },
     });
     expect(
       applyDefaults(templateContent)({
-        foo: "bar",
-        qux: "spqr",
+        foo: { value: "bar", origin: "user" },
+        qux: { value: "spqr", origin: "user" },
         xyzzy,
-        bar: "1",
+        bar: { value: "1", origin: "user" },
       })
     ).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
+      bar: { value: "1", origin: "user" },
+      xyz: { value: ["a"], origin: "default" },
     });
   });
 
   it("should apply domain defaults", () => {
-    const defaultContent = { foo: "bar", qux: "spqr", xyzzy };
+    const defaultContent = {
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
+      xyzzy,
+    };
     expect(applyDefaults(templateContent)(defaultContent, 1)).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
-      xxyy: ["a"],
+      bar: { value: "1", origin: "default" },
+      xyz: { value: ["a"], origin: "default" },
+      xxyy: { value: ["a"], origin: "default" },
     });
 
     expect(applyDefaults(templateContent)(defaultContent, 2)).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
-      xxyy: ["c"],
+      bar: { value: "1", origin: "default" },
+      xyz: { value: ["a"], origin: "default" },
+      xxyy: { value: ["c"], origin: "default" },
     });
 
     expect(applyDefaults(templateContent)(defaultContent, 3)).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
+      bar: { value: "1", origin: "default" },
+      xyz: { value: ["a"], origin: "default" },
     });
 
     expect(
-      applyDefaults(templateContent)({ ...defaultContent, xxyy: ["b"] }, 2)
+      applyDefaults(templateContent)(
+        { ...defaultContent, xxyy: { value: ["b"], origin: "user" } },
+        2
+      )
     ).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
-      xxyy: ["b"],
+      bar: { value: "1", origin: "default" },
+      xyz: { value: ["a"], origin: "default" },
+      xxyy: { value: ["b"], origin: "user" },
     });
 
     expect(applyDefaults(templateContent)(defaultContent, null)).toEqual({
-      foo: "bar",
-      qux: "spqr",
+      foo: { value: "bar", origin: "user" },
+      qux: { value: "spqr", origin: "user" },
       xyzzy,
-      bar: "1",
-      xyz: ["a"],
+      bar: { value: "1", origin: "default" },
+      xyz: { value: ["a"], origin: "default" },
     });
   });
 });

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

@@ -18,7 +18,7 @@ const template = {
         {
           name: "wibble",
           depends: { on: "role", to_be: ["u1"] },
-          default: "wobble",
+          default: { value: "wobble", origin: "default" },
         },
         {
           name: "switch",
@@ -34,7 +34,7 @@ const template = {
         },
         {
           name: "domain",
-          default: { 2: ["d"] },
+          default: { value: { 2: ["d"] }, origin: "default" },
           values: {
             domain: {
               1: ["a", "b"],
@@ -50,20 +50,28 @@ const template = {
 describe("utils: applyTemplate", () => {
   describe("switches", () => {
     it("should filter properties with invalid switch values", () => {
-      const o = { fixed: "foo", switch: "bar2", xyzzy };
+      const o = {
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "bar2", origin: "user" },
+        xyzzy,
+      };
       const result = applyTemplate(template)(o);
       expect(result).toEqual({
-        fixed: "foo",
+        fixed: { value: "foo", origin: "user" },
         xyzzy,
       });
     });
 
     it("should not filter properties with valid switch values", () => {
-      const o = { fixed: "bar", switch: "bar2", xyzzy };
+      const o = {
+        fixed: { value: "bar", origin: "user" },
+        switch: { value: "bar2", origin: "user" },
+        xyzzy,
+      };
       const result = applyTemplate(template)(o);
       expect(result).toEqual({
-        fixed: "bar",
-        switch: "bar2",
+        fixed: { value: "bar", origin: "user" },
+        switch: { value: "bar2", origin: "user" },
         xyzzy,
       });
     });
@@ -71,100 +79,136 @@ describe("utils: applyTemplate", () => {
 
   describe("domains", () => {
     it("should filter properties with invalid domain values", () => {
-      const o = { fixed: "foo", switch: "foo1", xyzzy, domain: "foo" };
+      const o = {
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
+        xyzzy,
+        domain: { value: "foo", origin: "user" },
+      };
       const result = applyTemplate(template)(o, 1);
       expect(result).toEqual({
-        fixed: "foo",
-        switch: "foo1",
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
         xyzzy,
       });
     });
 
     it("should include domain when single value is valid", () => {
-      const o = { fixed: "foo", switch: "foo1", xyzzy, domain: "a" };
+      const o = {
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
+        xyzzy,
+        domain: { value: "a", origin: "user" },
+      };
       const result = applyTemplate(template)(o, 1);
       expect(result).toEqual({
-        fixed: "foo",
-        switch: "foo1",
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
         xyzzy,
-        domain: "a",
+        domain: { value: "a", origin: "user" },
       });
     });
 
     it("should include domain when multiple value is valid", () => {
-      const o = { fixed: "foo", switch: "foo1", xyzzy, domain: ["c", "d"] };
+      const o = {
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
+        xyzzy,
+        domain: { value: ["c", "d"], origin: "user" },
+      };
       const result = applyTemplate(template)(o, 2);
       expect(result).toEqual({
-        fixed: "foo",
-        switch: "foo1",
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
         xyzzy,
-        domain: ["c", "d"],
+        domain: { value: ["c", "d"], origin: "user" },
       });
     });
 
     it("should apply domain default", () => {
-      const o = { fixed: "foo", switch: "foo1", xyzzy };
+      const o = {
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
+        xyzzy,
+      };
       const result = applyTemplate(template)(o, 2);
       expect(result).toEqual({
-        fixed: "foo",
-        switch: "foo1",
+        fixed: { value: "foo", origin: "user" },
+        switch: { value: "foo1", origin: "user" },
         xyzzy,
-        domain: ["d"],
+        domain: { value: ["d"], origin: "default" },
       });
     });
   });
 
   describe("field filters", () => {
     it("should filter unlisted properties", () => {
-      const o = { fixed: "foo", bar: "baz", xyzzy };
+      const o = {
+        fixed: { value: "foo", origin: "user" },
+        bar: { value: "baz", origin: "user" },
+        xyzzy,
+      };
       const result = applyTemplate(template)(o);
-      expect(result).toEqual({ fixed: "foo", xyzzy });
+      expect(result).toEqual({
+        fixed: { value: "foo", origin: "user" },
+        xyzzy,
+      });
     });
   });
 
   describe("value filters", () => {
     it("should nullify unlisted values", () => {
-      const o = { fixed: "foo2", xyzzy };
+      const o = { fixed: { value: "foo2", origin: "user" }, xyzzy };
       const result = applyTemplate(template)(o);
-      expect(result).toEqual({ fixed: null, xyzzy });
+      expect(result).toEqual({ fixed: { value: null, origin: "user" }, xyzzy });
     });
   });
 
   describe("conditional defaults", () => {
     it("should be ignored if a value exists", () => {
-      const o = { role: "u1", wibble: "woo", xyzzy };
+      const o = {
+        role: { value: "u1", origin: "user" },
+        wibble: { value: "woo", origin: "user" },
+        xyzzy,
+      };
       const result = applyTemplate(template)(o);
       expect(result).toEqual({
-        role: "u1",
-        wibble: "woo",
+        role: { value: "u1", origin: "user" },
+        wibble: { value: "woo", origin: "user" },
         xyzzy,
       });
     });
 
     it("should be applied if conditions are met and no value exists", () => {
-      const o = { fixed: "boo", role: "u1", xyzzy };
+      const o = {
+        fixed: { value: "boo", origin: "user" },
+        role: { value: "u1", origin: "user" },
+        xyzzy,
+      };
       const result = applyTemplate(template)(o);
       expect(result).toEqual({
-        fixed: null,
-        role: "u1",
-        wibble: "wobble",
+        fixed: { value: null, origin: "user" },
+        role: { value: "u1", origin: "user" },
+        wibble: { value: "wobble", origin: "default" },
         xyzzy,
       });
     });
 
     it("should be applied if values of fixed field has multiple cardinality", () => {
-      const o = { fixed: ["boo", "foo", "bar", "far"] };
+      const o = {
+        fixed: { value: ["boo", "foo", "bar", "far"], origin: "user" },
+      };
       const result = applyTemplate(template)(o);
       expect(result).toEqual({
-        fixed: ["foo", "bar"],
+        fixed: { value: ["foo", "bar"], origin: "user" },
       });
     });
 
     it("applyTemplateWithoutDefaults should not apply default values", () => {
-      const o = { role: "u1" };
+      const o = { role: { value: "u1", origin: "user" } };
       const result = applyTemplateWithoutDefaults(template)(o);
       expect(result).toEqual({
-        role: "u1",
+        role: { value: "u1", origin: "user" },
       });
     });
   });

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

@@ -1,19 +1,18 @@
-import _ from "lodash/fp";
 import { filterDepends, isDepends } from "..";
 
 const depends1 = {
   name: "target",
   depends: {
     on: "src",
-    to_be: ["foo"]
-  }
+    to_be: ["foo"],
+  },
 };
 const depends2 = {
   name: "target2",
   depends: {
     on: "src",
-    to_be: ["bar"]
-  }
+    to_be: ["bar"],
+  },
 };
 const templateContent = [depends1, depends2];
 
@@ -25,7 +24,11 @@ describe("utils: isDepends", () => {
 
 describe("utils: filterDepends", () => {
   it("should remove keys with unmatched depends", () => {
-    const o = { src: "foo", target: "asd", xyzzy: "xyzzy" };
+    const o = {
+      src: { value: "foo", origin: "default" },
+      target: { value: "asd", origin: "default" },
+      xyzzy: { value: "xyzzy", origin: "default" },
+    };
     const filter = filterDepends(templateContent);
     expect(filter({ ...o, target2: "boo" })).toMatchObject(o);
   });