@truedat/dd 8.12.4 → 8.12.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dd",
-  "version": "8.12.4",
+  "version": "8.12.6",
   "description": "Truedat Web Data Dictionary",
   "sideEffects": false,
   "module": "src/index.js",
@@ -54,7 +54,7 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@truedat/test": "8.12.4",
+    "@truedat/test": "8.12.6",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "redux-saga-test-plan": "^4.0.6"
@@ -90,5 +90,5 @@
     "svg-pan-zoom": "^3.6.2",
     "swr": "^2.3.3"
   },
-  "gitHead": "d5bc1af84c4d828bdec676b0da58385cf0d6015f"
+  "gitHead": "fe7375c2d3c6ebdaf3dacd985f56433eda477712"
 }

package/src/api/__tests__/queries.spec.js

@@ -24,18 +24,27 @@ const linksField = (field) =>
     (s) => s.kind === "Field" && s.name.value === "links",
   );
 
-const expectRelationLinks = (document) => {
+const expectResourceType = (field, value) => {
+  const resourceType = linksField(field).arguments.find(
+    (argument) => argument.name.value === "resource_type",
+  );
+  expect(resourceType.value.value).toBe(value);
+};
+
+const expectRelationLinks = (document, childrenResourceType) => {
   const parents = fieldAtPath(document, PARENT_PATH);
   const children = fieldAtPath(document, CHILD_PATH);
 
   expect(selectionNames(parents)).toEqual(expect.arrayContaining(["links"]));
   expect(selectionNames(children)).toEqual(expect.arrayContaining(["links"]));
 
-  const resourceType = linksField(parents).arguments.find(
-    (argument) => argument.name.value === "resource_type",
-  );
-  expect(resourceType.value.value).toBe("business_concept");
-  expect(linksField(children).arguments).toEqual([]);
+  expectResourceType(parents, "business_concept");
+
+  if (childrenResourceType) {
+    expectResourceType(children, childrenResourceType);
+  } else {
+    expect(linksField(children).arguments).toEqual([]);
+  }
 };
 
 describe("LEGACY_DATA_STRUCTURE_VERSION_QUERY", () => {
@@ -46,10 +55,10 @@ describe("LEGACY_DATA_STRUCTURE_VERSION_QUERY", () => {
 
 describe("buildDSVQuery", () => {
   it("requests concept links on parent and child structure relations", () => {
-    expectRelationLinks(buildDSVQuery(false));
+    expectRelationLinks(buildDSVQuery(false), "business_concept");
   });
 
   it("requests concept links on parent and child structure relations when loading metadata", () => {
-    expectRelationLinks(buildDSVQuery(true));
+    expectRelationLinks(buildDSVQuery(true), "business_concept");
   });
 });

package/src/api/queries.js

@@ -687,7 +687,7 @@ export const buildDSVQuery = (loadStructureMetadata) => gql`
             name
             description
           }
-          links
+          links(resource_type: "business_concept")
         }
       }
 

package/src/components/StructureNoteActions.js

@@ -7,6 +7,7 @@ import { FormattedMessage } from "react-intl";
 import { ConfirmModal, GroupActions } from "@truedat/core/components";
 import { linkTo } from "@truedat/core/routes";
 import { doStructureNoteAction } from "../routines";
+import { canPerformAction } from "../utils/structureNoteActions";
 
 const ModalDelete = ({
   className,
@@ -67,6 +68,8 @@ export const StructureNoteActions = ({
   doStructureNoteAction,
   actions,
   structure,
+  template,
+  content,
 }) => {
   const actionToIcon = {
     deleted: "trash alternate outline",
@@ -88,6 +91,7 @@ export const StructureNoteActions = ({
     _.toPairs,
     _.reject(([action, _data]) => !_.get(action)(actionToIcon)),
     _.map(([action, data]) => {
+      const allowed = canPerformAction(action, content, template);
       const baseAction = {
         key: action,
         icon: _.get(action)(actionToIcon),
@@ -100,8 +104,11 @@ export const StructureNoteActions = ({
         ),
         as: actionToAs(action),
         to: actionToTo(action),
+        className: "td-structure-note-action",
+        disabled: !allowed,
+        ...(!allowed ? { style: { opacity: 0.45 } } : {}),
         onClick:
-          action === "edited" || withModal(action)
+          action === "edited" || withModal(action) || !allowed
             ? undefined
             : () =>
                 doStructureNoteAction({
@@ -135,6 +142,8 @@ StructureNoteActions.propTypes = {
   doStructureNoteAction: PropTypes.func,
   actions: PropTypes.object.isRequired,
   structure: PropTypes.object.isRequired,
+  template: PropTypes.object,
+  content: PropTypes.object,
 };
 
 export default connect(null, { doStructureNoteAction })(StructureNoteActions);

package/src/components/StructureNotes.js

@@ -1,16 +1,24 @@
 import _ from "lodash/fp";
 import { lazy, useState } from "react";
 import PropTypes from "prop-types";
-import { useIntl, FormattedMessage } from "react-intl";
+import { FormattedMessage, useIntl } from "react-intl";
 import Moment from "react-moment";
 import { connect } from "react-redux";
 import { Link } from "react-router";
-import { Button, Segment, Message, Loader, Label } from "semantic-ui-react";
+import {
+  Button,
+  Segment,
+  Message,
+  Loader,
+  Label,
+  Icon,
+} from "semantic-ui-react";
 import { linkTo } from "@truedat/core/routes";
 import {
   getActiveStructureNotes,
   getVersionedStructureNotes,
 } from "../selectors/getSortedStructureNotes";
+import { getMissingMandatoryFields } from "../utils/structureNoteActions";
 
 import StructureNoteActions from "./StructureNoteActions";
 
@@ -27,6 +35,10 @@ const StructureNote = ({ structureNote, template, structure, notesSize }) => {
     structureNote?.status !== "published" ||
     !_.isEmpty(actions) ||
     notesSize > 1;
+  const noteContent =
+    structureNote?.dynamic_content || structureNote?.df_content || {};
+  const missingFields = getMissingMandatoryFields(noteContent, template);
+  const showMissingLabel = !_.isEmpty(missingFields);
   return (
     <Segment>
       <div
@@ -59,6 +71,21 @@ const StructureNote = ({ structureNote, template, structure, notesSize }) => {
                   />
                 </Label>
               )}
+              {showMissingLabel && (
+                <Label
+                  basic
+                  color="orange"
+                  size="tiny"
+                  className="td-missing-mandatory-label"
+                >
+                  <Icon name="warning sign" />
+                  <FormattedMessage
+                    id="structure.notes.actions.missing_mandatory"
+                    defaultMessage="Missing required fields: {fields}"
+                    values={{ fields: missingFields.join(", ") }}
+                  />
+                </Label>
+              )}
             </>
           )}
         </div>
@@ -70,7 +97,12 @@ const StructureNote = ({ structureNote, template, structure, notesSize }) => {
               />
             </Button>
           )}
-          <StructureNoteActions actions={actions} structure={structure} />
+          <StructureNoteActions
+            actions={actions}
+            structure={structure}
+            template={template}
+            content={noteContent}
+          />
         </div>
       </div>
       {!collapsed && (
@@ -99,6 +131,7 @@ export const StructureNotes = ({
   template,
 }) => {
   const { formatMessage } = useIntl();
+
   const [isShowingVersioned, setShowingVersioned] = useState(false);
   const notesSize = _.size(activeStructureNotes);
 
@@ -163,6 +196,11 @@ StructureNotes.propTypes = {
   template: PropTypes.object,
 };
 
+export const findTemplate = ({
+  templates,
+  structure: { structure_type } = {},
+}) => _.find(_.propEq("id", _.prop("template_id")(structure_type)))(templates);
+
 const mapStateToProps = (state) => {
   const { templates, structure, structureNotes } = state;
   return {
@@ -170,9 +208,7 @@ const mapStateToProps = (state) => {
     versionedStructureNotes: getVersionedStructureNotes(state),
     structureNotes,
     structure,
-    template: _.find(
-      _.propEq("id", _.path("structure_type.template_id")(structure)),
-    )(templates),
+    template: findTemplate({ templates, structure }),
   };
 };
 

package/src/components/StructureNotesEdit.js

@@ -1,12 +1,12 @@
 import _ from "lodash/fp";
-import { lazy, useEffect, useState } from "react";
+import { lazy, useEffect, useRef, useState } from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { Button, Form, Segment } from "semantic-ui-react";
 import { useIntl } from "react-intl";
 import { HistoryBackButton } from "@truedat/core/components";
 import { selectTemplate, selectDomains } from "@truedat/df/routines";
-import { applyTemplate, validateContent } from "@truedat/df/utils";
+import { applyTemplate } from "@truedat/df/utils";
 import SuggestionsWidget from "@truedat/ai/components/suggestions/SuggestionsWidget";
 import { doStructureNoteAction } from "../routines";
 import { getLatestDfContent } from "../selectors/getSortedStructureNotes";
@@ -17,6 +17,16 @@ const TemplateLoader = lazy(
   () => import("@truedat/df/templates/components/TemplateLoader"),
 );
 
+const isInformed = _.flow(
+  _.cond([
+    [_.isArray, _.isEmpty],
+    [_.isObject, _.isEmpty],
+    [_.isString, _.isEmpty],
+    [_.stubTrue, _.isNil],
+  ]),
+  (value) => !value,
+);
+
 export const StructureNotesEdit = ({
   applyTemplate,
   structure,
@@ -28,8 +38,9 @@ export const StructureNotesEdit = ({
   latestDfContent,
 }) => {
   const [content, setContent] = useState(latestDfContent);
-
+  const explicitEmptiesRef = useRef({});
   const isModification = !_.isEmpty(latestDfContent);
+  const initializedRef = useRef(false);
 
   useEffect(() => {
     selectDomains(structure.domain_ids);
@@ -37,18 +48,37 @@ export const StructureNotesEdit = ({
   }, [template, structure, selectTemplate, selectDomains]);
 
   useEffect(() => {
-    if (template && latestDfContent) {
+    if (!initializedRef.current && template && latestDfContent) {
+      initializedRef.current = true;
       setContent(applyTemplate(latestDfContent, structure.domain_id));
     }
   }, [applyTemplate, template, latestDfContent, structure.domain_id]);
 
   const { formatMessage, locale } = useIntl();
 
-  const submitDisabled =
-    !template || _.size(validateContent(template)(content)) > 0;
+  const submitDisabled = !template;
+
+  const handleFormChange = (newContent) => {
+    const clearedFields = _.flow(
+      _.pickBy((value) => isInformed(value.value)),
+      _.omit(Object.keys(newContent)),
+      _.mapValues(() => ({ value: "", origin: "user" })),
+    )(content);
+
+    explicitEmptiesRef.current = {
+      ..._.omit(
+        Object.keys(_.pickBy((value) => isInformed(value.value))(newContent)),
+      )(explicitEmptiesRef.current),
+      ...clearedFields,
+    };
+    setContent(newContent);
+  };
 
   const handleSubmit = () => {
-    const df_content = applyTemplate(content, structure.domain_id);
+    const df_content = {
+      ...applyTemplate(content, structure.domain_id),
+      ...explicitEmptiesRef.current,
+    };
     const draftNoteAction = _.flow(
       _.get("structureNotes"),
       _.find({ status: "draft" }),
@@ -96,7 +126,7 @@ export const StructureNotesEdit = ({
       />
       <Form>
         <DynamicForm
-          onChange={setContent}
+          onChange={handleFormChange}
           content={content}
           isModification={isModification}
         />

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__/__snapshots__/StructureNoteActions.spec.js.snap

@@ -21,8 +21,9 @@ exports[`<StructureNoteActions /> matches the latest snapshot 1`] = `
     >
       <div
         aria-checked="false"
+        aria-disabled="false"
         aria-selected="true"
-        class="selected item td-icon-text-control"
+        class="selected item td-structure-note-action td-icon-text-control"
         role="option"
         style="pointer-events: all;"
       >

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

@@ -8,6 +8,9 @@ exports[`<StructureNotesEdit /> matches the latest snapshot 1`] = `
     <form
       class="ui form"
     >
+      <div
+        data-testid="dynamic-form"
+      />
       <button
         class="ui primary button"
       >

package/src/reducers/__tests__/ddMessage.spec.js

@@ -1,4 +1,5 @@
 import {
+  bulkUpdateStructures,
   createReferenceDataset,
   deleteReferenceDataset,
   updateReferenceDataset,
@@ -74,6 +75,53 @@ describe("reducers: ddMessage", () => {
     });
   });
 
+  it("should handle the bulkUpdateStructures.FAILURE action with error details", () => {
+    const ddMsg = ddMessage(fooState, {
+      type: bulkUpdateStructures.FAILURE,
+      payload: { status: 422, data: { error: { message: "some message" } } },
+    });
+    expect(ddMsg).toMatchObject({
+      error: true,
+      header: "structures.bulkUpdateStructures.failed.header",
+      content: "some message",
+    });
+  });
+
+  it("should handle bulkUpdateStructures.FAILURE with string payload (timeout)", () => {
+    const ddMsg = ddMessage(fooState, {
+      type: bulkUpdateStructures.FAILURE,
+      payload: "timeout of 0ms exceeded",
+    });
+    expect(ddMsg).toMatchObject({
+      error: true,
+      header: "structures.bulkUpdateStructures.failed.timeout.header",
+      content: "timeout of 0ms exceeded",
+    });
+  });
+
+  it("should handle bulkUpdateStructures.FAILURE with string payload (generic network error)", () => {
+    const ddMsg = ddMessage(fooState, {
+      type: bulkUpdateStructures.FAILURE,
+      payload: "Network Error",
+    });
+    expect(ddMsg).toMatchObject({
+      error: true,
+      header: "structures.bulkUpdateStructures.failed.header",
+      content: "Network Error",
+    });
+  });
+
+  it("should handle bulkUpdateStructures.FAILURE with 504 status as timeout", () => {
+    const ddMsg = ddMessage(fooState, {
+      type: bulkUpdateStructures.FAILURE,
+      payload: { status: 504, data: {} },
+    });
+    expect(ddMsg).toMatchObject({
+      error: true,
+      header: "structures.bulkUpdateStructures.failed.timeout.header",
+    });
+  });
+
   it("should handle the createReferenceDataset.SUCCESS action", () => {
     expect(ddMessage(fooState, createReferenceDataset.success())).toMatchObject(
       { header: "alert.createReferenceDataset.success.header" },

package/src/reducers/__tests__/structureRedirect.spec.js

@@ -1,10 +1,12 @@
 import { clearRedirect } from "@truedat/core/routines";
+import { STRUCTURES } from "@truedat/core/routes";
 import {
   createReferenceDataset,
   deleteReferenceDataset,
   updateReferenceDataset,
   updateStructureType,
   updateStructure,
+  bulkUpdateStructures,
 } from "../../routines";
 import { structureRedirect, initialState } from "../structureRedirect";
 
@@ -69,4 +71,24 @@ describe("reducers: structureRedirect", () => {
       ),
     ).toBe("/referenceDatasets/42");
   });
+
+  it("should redirect to STRUCTURES when bulkUpdateStructures.SUCCESS has no errors", () => {
+    const payload = { data: { errors: [] } };
+    expect(
+      structureRedirect(fooState, {
+        type: bulkUpdateStructures.SUCCESS,
+        payload,
+      }),
+    ).toBe(STRUCTURES);
+  });
+
+  it("should not redirect when bulkUpdateStructures.SUCCESS has errors", () => {
+    const payload = { data: { errors: [{ message: "err" }] } };
+    expect(
+      structureRedirect(fooState, {
+        type: bulkUpdateStructures.SUCCESS,
+        payload,
+      }),
+    ).toBe(fooState);
+  });
 });

package/src/reducers/ddMessage.js

@@ -19,6 +19,38 @@ const ddMessage = (state = initialState, { type, payload }) => {
       return initialState;
     case bulkUpdateStructures.SUCCESS:
       return getUploadAlertMessage(payload);
+    case bulkUpdateStructures.FAILURE: {
+      const isTimeout =
+        typeof payload === "string"
+          ? /timeout|timed out|ECONNABORTED/i.test(payload)
+          : payload?.status === 504 ||
+            /timeout/i.test(payload?.data?.error?.message || "");
+
+      if (isTimeout) {
+        return {
+          error: true,
+          header: "structures.bulkUpdateStructures.failed.timeout.header",
+          icon: "attention",
+          content:
+            typeof payload === "string"
+              ? payload
+              : payload?.data?.error?.message,
+          initialMaxListItems: 5,
+        };
+      }
+
+      return {
+        error: true,
+        header: "structures.bulkUpdateStructures.failed.header",
+        icon: "attention",
+        content:
+          typeof payload === "string"
+            ? payload
+            : payload?.data?.error?.message ||
+              "structures.bulkUpdateStructures.failed.generic.content",
+        initialMaxListItems: 5,
+      };
+    }
     case uploadStructuresDomains.SUCCESS: {
       const messagesImp = _.has("errors")(payload.data)
         ? _.flow(

package/src/reducers/structureRedirect.js

@@ -47,8 +47,13 @@ export const structureRedirect = (
       return initialState;
     case updateStructure.SUCCESS:
       return payload?.redirect || state;
-    case bulkUpdateStructures.SUCCESS:
-      return STRUCTURES;
+    case bulkUpdateStructures.SUCCESS: {
+      const errors = payload?.data?.errors;
+      if (!errors || errors.length === 0) {
+        return STRUCTURES;
+      }
+      return state;
+    }
     case createSystem.SUCCESS: {
       const id = _.path("data.id")(payload);
       return linkTo.SYSTEM_STRUCTURES({ id });

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

@@ -53,4 +53,18 @@ describe("selectors: getUploadAlertMessage", () => {
       "structures.bulkUpdateStructures.failed.note.only_draft_are_editable",
     );
   });
+
+  it("returns uploadFailed with errors array when status is 422", () => {
+    const data = { errors: [{ message: "some_error" }] };
+    const result = getUploadAlertMessage({ status: 422, data });
+    expect(result.error).toBe(true);
+    expect(result.header).toBe("structures.bulkUpdateStructures.failed.header");
+    expect(result.messages.length).toBe(1);
+  });
+
+  it("returns uploadFailed when status is 500", () => {
+    const result = getUploadAlertMessage({ status: 500, data: {} });
+    expect(result.error).toBe(true);
+    expect(result.header).toBe("structures.bulkUpdateStructures.failed.header");
+  });
 });

package/src/selectors/messages.js

@@ -48,6 +48,32 @@ const uploadAccepted = () => {
   };
 };
 
+const uploadFailed = (data) => ({
+  error: true,
+  header: "structures.bulkUpdateStructures.failed.header",
+  icon: "attention",
+  color: "red",
+  text: "",
+  messages: _.has("errors")(data)
+    ? _.flow(
+        _.propOr([], "errors"),
+        _.map((error) => ({
+          id: `structures.bulkUpdateStructures.failed.note.${error.message}`,
+          fields: {
+            row: error.row,
+            id: error.id,
+            field: error.field,
+            externalId: error.external_id,
+            message: error.message,
+          },
+          defaultMessage: "structures.bulkUploadStructures.success.errors",
+        })),
+      )(data)
+    : [],
+  fields: data?.errors ? { count_errors: data.errors.length } : {},
+  initialMaxListItems: 5,
+});
+
 export const getUploadAlertMessage = ({ status, data }) => {
   if (status === 202) {
     return uploadAccepted();
@@ -55,4 +81,8 @@ export const getUploadAlertMessage = ({ status, data }) => {
   if (status === 200) {
     return uploadWithErrors(data);
   }
+  if (status >= 400) {
+    return uploadFailed(data || {});
+  }
+  return uploadAccepted();
 };

package/src/utils/__tests__/structureNoteActions.spec.js

@@ -0,0 +1,196 @@
+import {
+  hasMandatoryErrors,
+  canPerformAction,
+  getMissingMandatoryFields,
+} from "../structureNoteActions";
+
+describe("hasMandatoryErrors", () => {
+  const template = {
+    content: [
+      {
+        name: "group",
+        fields: [
+          {
+            name: "required_field",
+            type: "string",
+            cardinality: "1",
+          },
+          {
+            name: "optional_field",
+            type: "string",
+            cardinality: "?",
+          },
+        ],
+      },
+    ],
+  };
+
+  it("returns false when content is null/undefined", () => {
+    expect(hasMandatoryErrors(null, template)).toBe(false);
+    expect(hasMandatoryErrors(undefined, template)).toBe(false);
+  });
+
+  it("returns false when template is null/undefined", () => {
+    expect(hasMandatoryErrors({}, null)).toBe(false);
+    expect(hasMandatoryErrors({}, undefined)).toBe(false);
+  });
+
+  it("returns true when a mandatory field is missing", () => {
+    const content = { optional_field: { value: "x", origin: "user" } };
+    expect(hasMandatoryErrors(content, template)).toBe(true);
+  });
+
+  it("returns false when all mandatory fields are populated", () => {
+    const content = {
+      required_field: { value: "ok", origin: "user" },
+      optional_field: { value: "x", origin: "user" },
+    };
+    expect(hasMandatoryErrors(content, template)).toBe(false);
+  });
+
+  it("returns true when a mandatory field is present but empty", () => {
+    const content = {
+      required_field: { value: "", origin: "user" },
+    };
+    expect(hasMandatoryErrors(content, template)).toBe(true);
+  });
+
+  it("returns true when a mandatory field is null", () => {
+    const content = {
+      required_field: { value: null, origin: "user" },
+    };
+    expect(hasMandatoryErrors(content, template)).toBe(true);
+  });
+});
+
+describe("getMissingMandatoryFields", () => {
+  const template = {
+    content: [
+      {
+        name: "group",
+        fields: [
+          {
+            name: "required_field",
+            type: "string",
+            cardinality: "1",
+          },
+          {
+            name: "another_required",
+            type: "string",
+            cardinality: "+",
+          },
+          {
+            name: "optional_field",
+            type: "string",
+            cardinality: "?",
+          },
+        ],
+      },
+    ],
+  };
+
+  it("returns empty array when content is null/undefined", () => {
+    expect(getMissingMandatoryFields(null, template)).toEqual([]);
+    expect(getMissingMandatoryFields(undefined, template)).toEqual([]);
+  });
+
+  it("returns empty array when template is null/undefined", () => {
+    expect(getMissingMandatoryFields({}, null)).toEqual([]);
+    expect(getMissingMandatoryFields({}, undefined)).toEqual([]);
+  });
+
+  it("returns list of missing field names", () => {
+    const content = { optional_field: { value: "x", origin: "user" } };
+    const missing = getMissingMandatoryFields(content, template);
+    expect(missing).toContain("required_field");
+    expect(missing).toContain("another_required");
+    expect(missing).toHaveLength(2);
+  });
+
+  it("returns empty array when all mandatory fields are populated", () => {
+    const content = {
+      required_field: { value: "ok", origin: "user" },
+      another_required: { value: ["a"], origin: "user" },
+      optional_field: { value: "x", origin: "user" },
+    };
+    expect(getMissingMandatoryFields(content, template)).toEqual([]);
+  });
+});
+
+describe("canPerformAction (TD-7093)", () => {
+  const template = {
+    content: [
+      {
+        name: "group",
+        fields: [
+          {
+            name: "required_field",
+            type: "string",
+            cardinality: "1",
+          },
+        ],
+      },
+    ],
+  };
+
+  const fullContent = { required_field: { value: "ok", origin: "user" } };
+  const partialContent = { optional_field: { value: "x", origin: "user" } };
+
+  describe("publishing actions", () => {
+    it("returns false for 'published' when mandatory fields are missing", () => {
+      expect(canPerformAction("published", partialContent, template)).toBe(
+        false,
+      );
+    });
+
+    it("returns true for 'published' when all mandatory fields are populated", () => {
+      expect(canPerformAction("published", fullContent, template)).toBe(true);
+    });
+
+    it("returns false for 'pending_approval' when mandatory fields are missing", () => {
+      expect(
+        canPerformAction("pending_approval", partialContent, template),
+      ).toBe(false);
+    });
+
+    it("returns true for 'pending_approval' when all mandatory fields are populated", () => {
+      expect(canPerformAction("pending_approval", fullContent, template)).toBe(
+        true,
+      );
+    });
+  });
+
+  describe("draft actions", () => {
+    it("always allows 'edited' even with partial content", () => {
+      expect(canPerformAction("edited", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'draft' even with partial content", () => {
+      expect(canPerformAction("draft", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'deleted' even with partial content", () => {
+      expect(canPerformAction("deleted", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'rejected' even with partial content", () => {
+      expect(canPerformAction("rejected", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'deprecated' even with partial content", () => {
+      expect(canPerformAction("deprecated", partialContent, template)).toBe(
+        true,
+      );
+    });
+  });
+
+  describe("edge cases", () => {
+    it("returns true for publishing actions when template is missing (no validation possible)", () => {
+      expect(canPerformAction("published", partialContent, null)).toBe(true);
+    });
+
+    it("returns true for publishing actions when content is missing (no validation possible)", () => {
+      expect(canPerformAction("published", null, template)).toBe(true);
+    });
+  });
+});

package/src/utils/structureNoteActions.js

@@ -0,0 +1,22 @@
+import { validateContent } from "@truedat/df/utils";
+
+export const getMissingMandatoryFields = (content, template) => {
+  if (!template || !content) return [];
+  const errors = validateContent(template)(content);
+  return Array.isArray(errors)
+    ? errors
+        .filter((err) => err && err.error === "missing required" && err.field)
+        .map((err) => err.field)
+    : [];
+};
+
+export const hasMandatoryErrors = (content, template) => {
+  return getMissingMandatoryFields(content, template).length > 0;
+};
+
+export const canPerformAction = (action, content, template) => {
+  if (action === "pending_approval" || action === "published") {
+    return !hasMandatoryErrors(content, template);
+  }
+  return true;
+};