@truedat/dd 8.12.2 → 8.12.5

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

@@ -202,4 +202,100 @@ describe("<StructureNoteActions />", () => {
         .querySelector(".clipboard.check.icon"),
     ).toBeInTheDocument();
   });
+
+  it("disables 'pending_approval' when mandatory fields are missing", async () => {
+    const doStructureNoteAction = jest.fn();
+    const template = {
+      content: [
+        {
+          name: "g1",
+          fields: [{ name: "required", type: "string", cardinality: "1" }],
+        },
+      ],
+    };
+    const props = {
+      doStructureNoteAction,
+      actions: {
+        pending_approval: {
+          href: "url",
+          input: { status: "pending_approval" },
+          method: "PATCH",
+        },
+      },
+      structure: { id: 1 },
+      template,
+      content: {},
+    };
+
+    const rendered = render(<StructureNoteActions {...props} />);
+    await waitForLoad(rendered);
+
+    const item = (await rendered.findByText(/pending_approval/i)).closest(
+      ".item",
+    );
+    expect(item).toHaveClass("disabled");
+    expect(doStructureNoteAction).not.toHaveBeenCalled();
+  });
+
+  it("disables 'published' when mandatory fields are missing", async () => {
+    const doStructureNoteAction = jest.fn();
+    const template = {
+      content: [
+        {
+          name: "g1",
+          fields: [{ name: "required", type: "string", cardinality: "1" }],
+        },
+      ],
+    };
+    const props = {
+      doStructureNoteAction,
+      actions: {
+        published: {
+          href: "url",
+          input: { status: "published" },
+          method: "PATCH",
+        },
+      },
+      structure: { id: 1 },
+      template,
+      content: {},
+    };
+
+    const rendered = render(<StructureNoteActions {...props} />);
+    await waitForLoad(rendered);
+
+    const item = (await rendered.findByText(/published/i)).closest(".item");
+    expect(item).toHaveClass("disabled");
+    expect(doStructureNoteAction).not.toHaveBeenCalled();
+  });
+
+  it("keeps 'edited' enabled when mandatory fields are missing", async () => {
+    const doStructureNoteAction = jest.fn();
+    const template = {
+      content: [
+        {
+          name: "g1",
+          fields: [{ name: "required", type: "string", cardinality: "1" }],
+        },
+      ],
+    };
+    const props = {
+      doStructureNoteAction,
+      actions: {
+        edited: {
+          href: "edit-url",
+          method: "GET",
+        },
+      },
+      structure: { id: 1 },
+      template,
+      content: {},
+    };
+
+    const rendered = render(<StructureNoteActions {...props} />);
+    await waitForLoad(rendered);
+
+    const item = (await rendered.findByText(/edited/i)).closest(".item");
+    expect(item).not.toHaveClass("disabled");
+  });
 });

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

@@ -1,6 +1,6 @@
 import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
-import { StructureNotes } from "../StructureNotes";
+import { StructureNotes, findTemplate } from "../StructureNotes";
 
 jest.mock("@truedat/df/components/DynamicFormViewer", () => {
   const DynamicFormViewer = () => <div>DynamicFormViewer</div>;
@@ -111,4 +111,173 @@ describe("<StructureNotes />", () => {
     );
     expect(rendered.container).toMatchSnapshot();
   });
+
+  it("disables publish/pending_approval when df_content has missing mandatory fields", async () => {
+    const props = {
+      structure: { id: 1 },
+      structureNotes: { _actions: {}, loading: false },
+      activeStructureNotes: [
+        {
+          id: 4,
+          status: "draft",
+          dynamic_content: null,
+          df_content: null,
+          version: "4",
+          _actions: {
+            pending_approval: {
+              href: "url",
+              input: { status: "pending_approval" },
+              method: "PATCH",
+            },
+            published: {
+              href: "url",
+              input: { status: "published" },
+              method: "PATCH",
+            },
+          },
+        },
+      ],
+      versionedStructureNotes: [],
+      template: {
+        id: 2,
+        content: [
+          {
+            name: "g1",
+            fields: [{ name: "required", type: "string", cardinality: "1" }],
+          },
+        ],
+        scope: "dd",
+      },
+      doStructureNoteAction: () => {},
+    };
+
+    const rendered = render(<StructureNotes {...props} />);
+    await waitForLoad(rendered);
+
+    const pendingItem = (
+      await rendered.findByText(/pending_approval/i)
+    ).closest(".item");
+    expect(pendingItem).toHaveClass("disabled");
+
+    const publishedItem = (await rendered.findByText(/published/i)).closest(
+      ".item",
+    );
+    expect(publishedItem).toHaveClass("disabled");
+  });
+
+  it("shows missing mandatory label in header when draft has missing fields", async () => {
+    const props = {
+      structure: { id: 1 },
+      structureNotes: { _actions: {}, loading: false },
+      activeStructureNotes: [
+        {
+          id: 4,
+          status: "draft",
+          dynamic_content: null,
+          df_content: null,
+          version: "4",
+          _actions: {
+            published: {
+              href: "url",
+              input: { status: "published" },
+              method: "PATCH",
+            },
+          },
+        },
+      ],
+      versionedStructureNotes: [],
+      template: {
+        id: 2,
+        content: [
+          {
+            name: "g1",
+            fields: [{ name: "required", type: "string", cardinality: "1" }],
+          },
+        ],
+        scope: "dd",
+      },
+      doStructureNoteAction: () => {},
+    };
+
+    const rendered = render(<StructureNotes {...props} />);
+    await waitForLoad(rendered);
+
+    expect(
+      await rendered.findByText(/missing required fields/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".td-missing-mandatory-label"),
+    ).toBeInTheDocument();
+  });
+
+  it("does not show missing mandatory label when all fields are complete", async () => {
+    const props = {
+      structure: { id: 1 },
+      structureNotes: { _actions: {}, loading: false },
+      activeStructureNotes: [
+        {
+          id: 4,
+          status: "draft",
+          dynamic_content: { required: { value: "ok", origin: "user" } },
+          df_content: { required: { value: "ok", origin: "user" } },
+          version: "4",
+          _actions: {
+            published: {
+              href: "url",
+              input: { status: "published" },
+              method: "PATCH",
+            },
+          },
+        },
+      ],
+      versionedStructureNotes: [],
+      template: {
+        id: 2,
+        content: [
+          {
+            name: "g1",
+            fields: [{ name: "required", type: "string", cardinality: "1" }],
+          },
+        ],
+        scope: "dd",
+      },
+      doStructureNoteAction: () => {},
+    };
+
+    const rendered = render(<StructureNotes {...props} />);
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.queryByText(/missing required fields/i),
+    ).not.toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".td-missing-mandatory-label"),
+    ).not.toBeInTheDocument();
+  });
+
+  it("resolves the template from structure_type.template_id", () => {
+    const templates = [
+      { id: 1, name: "other" },
+      { id: 2, name: "Business Concept", content: [] },
+    ];
+    expect(
+      findTemplate({
+        templates,
+        structure: { structure_type: { template_id: 2 } },
+      }),
+    ).toEqual(templates[1]);
+    expect(
+      findTemplate({
+        templates,
+        structure: { structure_type: { template_id: 1 } },
+      }),
+    ).toEqual(templates[0]);
+    expect(
+      findTemplate({
+        templates,
+        structure: { structure_type: { template: { id: 2 } } },
+      }),
+    ).toBeUndefined();
+    expect(findTemplate({ templates, structure: {} })).toBeUndefined();
+  });
 });

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

@@ -1,5 +1,5 @@
 import userEvent from "@testing-library/user-event";
-import { waitFor } from "@testing-library/react";
+import { act, waitFor } from "@testing-library/react";
 import { render, waitForLoad } from "@truedat/test/render";
 import { applyTemplate } from "@truedat/df/utils";
 import SuggestionsWidget from "@truedat/ai/components/suggestions/SuggestionsWidget";
@@ -10,9 +10,23 @@ jest.mock("@truedat/ai/components/suggestions/SuggestionsWidget", () => ({
   default: jest.fn(() => null),
 }));
 
+let dynamicFormOnChange;
+let dynamicFormContent;
+
+jest.mock("@truedat/df/components/DynamicForm", () => ({
+  __esModule: true,
+  default: ({ onChange, content }) => {
+    dynamicFormOnChange = onChange;
+    dynamicFormContent = content;
+    return <div data-testid="dynamic-form" />;
+  },
+}));
+
 describe("<StructureNotesEdit />", () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    dynamicFormOnChange = undefined;
+    dynamicFormContent = undefined;
   });
 
   it("matches the latest snapshot", async () => {
@@ -121,4 +135,174 @@ describe("<StructureNotesEdit />", () => {
       }),
     );
   });
+
+  it("preserves explicit empty fields when a field is cleared", async () => {
+    const doStructureNoteAction = jest.fn();
+    const template = {
+      id: 2,
+      content: [
+        {
+          name: "test-group",
+          fields: [
+            {
+              name: "foo",
+              type: "string",
+              values: null,
+            },
+            {
+              name: "bar",
+              type: "string",
+              values: null,
+            },
+          ],
+        },
+      ],
+    };
+
+    const props = {
+      structure: { id: 1 },
+      template,
+      doStructureNoteAction,
+      selectTemplate: () => {},
+      selectDomain: () => {},
+      structureNotes: {
+        structureNotes: [],
+      },
+      latestDfContent: {
+        foo: { value: "foo value", origin: "user" },
+        bar: { value: "bar value", origin: "user" },
+      },
+      applyTemplate: applyTemplate(template),
+      selectDomains: jest.fn(),
+    };
+
+    const rendered = render(<StructureNotesEdit {...props} />);
+    await waitForLoad(rendered);
+
+    await act(async () => {
+      dynamicFormOnChange({
+        foo: { value: "foo value", origin: "user" },
+      });
+    });
+
+    const user = userEvent.setup({ delay: null });
+    await user.click(await rendered.findByText(/save/i));
+
+    await waitFor(() => {
+      expect(doStructureNoteAction.mock.calls.length).toBe(1);
+    });
+    expect(doStructureNoteAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: {
+          input: {
+            df_content: {
+              foo: { value: "foo value", origin: "user" },
+              bar: { value: "", origin: "user" },
+            },
+          },
+        },
+        dataStructureId: 1,
+        redirect: true,
+      }),
+    );
+  });
+
+  it("does not reset local content when latestDfContent changes)", async () => {
+    const doStructureNoteAction = jest.fn();
+    const template = {
+      id: 2,
+      content: [
+        {
+          name: "test-group",
+          fields: [
+            {
+              name: "foo",
+              type: "string",
+              values: null,
+            },
+          ],
+        },
+      ],
+    };
+
+    const props = {
+      structure: { id: 1 },
+      template,
+      doStructureNoteAction,
+      selectTemplate: () => {},
+      selectDomain: () => {},
+      structureNotes: {
+        structureNotes: [],
+      },
+      latestDfContent: { foo: { value: "saved value", origin: "user" } },
+      applyTemplate: applyTemplate(template),
+      selectDomains: jest.fn(),
+    };
+
+    const rendered = render(<StructureNotesEdit {...props} />);
+    await waitForLoad(rendered);
+
+    await act(async () => {
+      dynamicFormOnChange({
+        foo: { value: "local edit", origin: "user" },
+      });
+    });
+    expect(dynamicFormContent).toEqual({
+      foo: { value: "local edit", origin: "user" },
+    });
+
+    const updatedProps = {
+      ...props,
+      latestDfContent: { foo: { value: "saved value", origin: "user" } },
+    };
+    await act(async () => {
+      rendered.rerender(<StructureNotesEdit {...updatedProps} />);
+    });
+
+    expect(dynamicFormContent).toEqual({
+      foo: { value: "local edit", origin: "user" },
+    });
+  });
+
+  it("Save button is enabled when mandatory fields are missing", async () => {
+    const doStructureNoteAction = jest.fn();
+    const template = {
+      id: 2,
+      content: [
+        {
+          name: "test-group",
+          fields: [
+            {
+              name: "required_field",
+              type: "string",
+              cardinality: "1",
+              values: null,
+            },
+          ],
+        },
+      ],
+    };
+
+    const props = {
+      structure: { id: 1 },
+      template,
+      doStructureNoteAction,
+      selectTemplate: () => {},
+      selectDomain: () => {},
+      structureNotes: {
+        structureNotes: [],
+      },
+      latestDfContent: {},
+      applyTemplate: applyTemplate(template),
+      selectDomains: jest.fn(),
+    };
+
+    const rendered = render(<StructureNotesEdit {...props} />);
+    await waitForLoad(rendered);
+
+    const saveButton = await rendered.findByRole("button", {
+      name: /actions\.save/i,
+    });
+    expect(saveButton).not.toBeDisabled();
+  });
 });

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

@@ -3,6 +3,16 @@ import { waitFor } from "@testing-library/react";
 import { render, waitForLoad } from "@truedat/test/render";
 import _ from "lodash/fp";
 import { StructureRelationRow } from "../StructureRelationRow";
+import { linksDecorator } from "../../selectors/getStructureFieldColumns";
+
+const renderRow = (props) =>
+  render(
+    <table>
+      <tbody>
+        <StructureRelationRow {...props} />
+      </tbody>
+    </table>,
+  );
 
 describe("<StructureRelationRow />", () => {
   const structure = { id: 1, name: "Structure 1", type: "Some Type 1" };
@@ -35,7 +45,7 @@ describe("<StructureRelationRow />", () => {
 
   it("matches the latest snapshot", async () => {
     const props = { relation, columns };
-    const rendered = render(<StructureRelationRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
     expect(rendered.container).toMatchSnapshot();
   });
@@ -43,7 +53,7 @@ describe("<StructureRelationRow />", () => {
   it("clicking the row will pass the relation to onClick()", async () => {
     const onClick = jest.fn();
     const props = { relation, columns, onClick };
-    const rendered = render(<StructureRelationRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
     const user = userEvent.setup({ delay: null });
 
@@ -58,7 +68,7 @@ describe("<StructureRelationRow />", () => {
     const value = _.path("structure.name")(relation);
     const onClick = jest.fn();
     const props = { relation, columns: [_.head(columns)], onClick };
-    const rendered = render(<StructureRelationRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
 
     expect(rendered.container.querySelector("td")).toHaveTextContent(value);
@@ -71,11 +81,69 @@ describe("<StructureRelationRow />", () => {
       _.set("fieldDecorator", fieldDecorator),
     )(columns);
     const props = { relation, columns: [column] };
-    const rendered = render(<StructureRelationRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
 
     expect(rendered.container.querySelector("td")).toHaveTextContent(
       "used_by_decorated",
     );
   });
+
+  it("row prints concept links", async () => {
+    const relation = {
+      id: 1,
+      relation_type,
+      structure,
+      links: [
+        { name: "foo concept", resource_id: "1" },
+        { name: "bar concept", resource_id: "2" },
+      ],
+    };
+    const props = {
+      relation,
+      columns: [{ name: "links", fieldDecorator: linksDecorator }],
+    };
+    const rendered = render(<StructureRelationRow {...props} />);
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/foo concept/i)).toBeInTheDocument();
+    expect(rendered.getByText(/bar concept/i)).toBeInTheDocument();
+    expect(rendered.getAllByRole("link")).toHaveLength(2);
+  });
+
+  it("row skips empty or invalid concept links", async () => {
+    const relation = {
+      id: 1,
+      relation_type,
+      structure,
+      links: [null, {}, { name: "foo concept", resource_id: "1" }],
+    };
+    const props = {
+      relation,
+      columns: [{ name: "links", fieldDecorator: linksDecorator }],
+    };
+    const rendered = render(<StructureRelationRow {...props} />);
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/foo concept/i)).toBeInTheDocument();
+    expect(rendered.getAllByRole("link")).toHaveLength(1);
+  });
+
+  it("row prints nothing when concept links are missing", async () => {
+    const relation = {
+      id: 1,
+      relation_type,
+      structure,
+      links: [],
+    };
+    const props = {
+      relation,
+      columns: [{ name: "links", fieldDecorator: linksDecorator }],
+    };
+    const rendered = render(<StructureRelationRow {...props} />);
+    await waitForLoad(rendered);
+
+    expect(rendered.queryByRole("link")).not.toBeInTheDocument();
+    expect(rendered.container.querySelector("td")).toBeEmptyDOMElement();
+  });
 });

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

@@ -64,4 +64,22 @@ describe("<StructureRelations />", () => {
       relations.length,
     );
   });
+
+  it("renders concept links column header", async () => {
+    const relations = [
+      {
+        id: 1,
+        relation_type,
+        structure: { id: 1, name: "foo structure", type: "foo" },
+        links: [{ name: "foo concept", resource_id: "1" }],
+      },
+    ];
+    const columnsWithLinks = [...columns, { name: "links" }];
+    const rendered = render(
+      <StructureRelations relations={relations} columns={columnsWithLinks} />,
+    );
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/structure.relation.links/i)).toBeInTheDocument();
+  });
 });

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

@@ -1,6 +1,15 @@
 import { render, waitForLoad } from "@truedat/test/render";
 import StructureRoles from "../StructureRoles";
 
+jest.mock("@truedat/core/hooks/useAclEntries", () => ({
+  ...jest.requireActual("@truedat/core/hooks/useAclEntries"),
+  useAclEntries: () => ({
+    data: { aclEntries: [], actions: { canCreate: false } },
+    loading: false,
+    mutate: jest.fn(),
+  }),
+}));
+
 jest.mock("react-router", () => ({
   ...jest.requireActual("react-router"),
   useParams: jest.fn().mockReturnValue({ id: "1" }),

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

@@ -4,6 +4,15 @@ import { render, waitForLoad } from "@truedat/test/render";
 import _ from "lodash/fp";
 import { StructureRow } from "../StructureRow";
 
+const renderRow = (props) =>
+  render(
+    <table>
+      <tbody>
+        <StructureRow {...props} />
+      </tbody>
+    </table>,
+  );
+
 describe("<StructureRow />", () => {
   const structure = {
     id: 1,
@@ -22,7 +31,7 @@ describe("<StructureRow />", () => {
 
   it("matches the latest snapshot", async () => {
     const props = { structure, columns };
-    const rendered = render(<StructureRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
     expect(rendered.container).toMatchSnapshot();
   });
@@ -30,7 +39,7 @@ describe("<StructureRow />", () => {
   it("clicking the row will pass the structure to onClick()", async () => {
     const onClick = jest.fn();
     const props = { structure, columns, onClick };
-    const rendered = render(<StructureRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
     const user = userEvent.setup({ delay: null });
 
@@ -56,7 +65,7 @@ describe("<StructureRow />", () => {
       },
     ];
     const props = { structure: testStructure, columns: testColumns };
-    const rendered = render(<StructureRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
 
     expect(rendered.container.querySelector("td")).toHaveTextContent(testValue);
@@ -71,7 +80,7 @@ describe("<StructureRow />", () => {
     };
     const testColumns = [{ name: "testObject", fieldDecorator }];
     const props = { structure: testStructure, columns: testColumns };
-    const rendered = render(<StructureRow {...props} />);
+    const rendered = renderRow(props);
     await waitForLoad(rendered);
 
     const decoratedValue = fieldDecorator(testValue);

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

@@ -1,6 +1,8 @@
 import { render, waitForLoad } from "@truedat/test/render";
 import { StructureSelector } from "../StructureSelector";
 
+jest.mock("@truedat/core/hooks/useUserFilters");
+
 const data = {
   _actions: { bulkUpdate: {} },
   data: [