@truedat/dd 8.13.4 → 8.13.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dd",
-  "version": "8.13.4",
+  "version": "8.13.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.13.4",
+    "@truedat/test": "8.13.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": "4ec142f1c856aa669b232b12250c800a19ab9ace"
+  "gitHead": "c0943c8cf31e82a81fdca24d68ef57406fe5bcbc"
 }

package/src/components/StructureNotesEdit.js

@@ -6,7 +6,7 @@ import { Button, Form, Segment } from "semantic-ui-react";
 import { useIntl } from "react-intl";
 import HistoryBackButton from "@truedat/core/components/HistoryBackButton";
 import { selectTemplate, selectDomains } from "@truedat/df/routines";
-import { applyTemplate } from "@truedat/df/utils";
+import { applyTemplate, validateContent } from "@truedat/df/utils";
 import SuggestionsWidget from "@truedat/ai/components/suggestions/SuggestionsWidget";
 import { doStructureNoteAction } from "../routines";
 import { getLatestDfContent } from "../selectors/getSortedStructureNotes";
@@ -38,6 +38,7 @@ export const StructureNotesEdit = ({
   latestDfContent,
 }) => {
   const [content, setContent] = useState(latestDfContent);
+  const [originalContent] = useState(latestDfContent);
   const explicitEmptiesRef = useRef({});
   const isModification = !_.isEmpty(latestDfContent);
   const initializedRef = useRef(false);
@@ -56,7 +57,11 @@ export const StructureNotesEdit = ({
 
   const { formatMessage, locale } = useIntl();
 
-  const submitDisabled = !template;
+  const hasDateRestrictionErrors = validateContent(
+    template,
+    originalContent,
+  )(content).some(({ error }) => error === "date out of range");
+  const submitDisabled = !template || hasDateRestrictionErrors;
 
   const handleFormChange = (newContent) => {
     const clearedFields = _.flow(
@@ -128,6 +133,7 @@ export const StructureNotesEdit = ({
         <DynamicForm
           onChange={handleFormChange}
           content={content}
+          originalContent={originalContent}
           isModification={isModification}
         />
         <Button

package/src/components/SystemForm.js

@@ -31,9 +31,17 @@ export const SystemForm = ({
 }) => {
   const { formatMessage } = useIntl();
   const [system, setSystem] = useState(editSystem || {});
+  const [originalContent] = useState(() =>
+    _.isEmpty(editSystem)
+      ? undefined
+      : _.cloneDeep(editSystem.dynamic_content || {}),
+  );
 
   const isNonEmpty = _.flow(_.trim, _.negate(_.isEmpty));
-  const isValidContent = _.flow(validateContent(template), _.isEmpty);
+  const isValidContent = _.flow(
+    validateContent(template, originalContent),
+    _.isEmpty,
+  );
   const isValid = _.conforms({
     name: isNonEmpty,
     external_id: isNonEmpty,
@@ -105,6 +113,7 @@ export const SystemForm = ({
               template={template}
               onChange={handleContentChange}
               content={dynamic_content || {}}
+              originalContent={originalContent}
             />
           )}
           <div className="actions">

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

@@ -12,12 +12,14 @@ jest.mock("@truedat/ai/components/suggestions/SuggestionsWidget", () => ({
 
 let dynamicFormOnChange;
 let dynamicFormContent;
+let dynamicFormOriginalContent;
 
 jest.mock("@truedat/df/components/DynamicForm", () => ({
   __esModule: true,
-  default: ({ onChange, content }) => {
+  default: ({ onChange, content, originalContent }) => {
     dynamicFormOnChange = onChange;
     dynamicFormContent = content;
+    dynamicFormOriginalContent = originalContent;
     return <div data-testid="dynamic-form" />;
   },
 }));
@@ -27,6 +29,108 @@ describe("<StructureNotesEdit />", () => {
     jest.clearAllMocks();
     dynamicFormOnChange = undefined;
     dynamicFormContent = undefined;
+    dynamicFormOriginalContent = undefined;
+  });
+
+  describe("date restrictions when editing", () => {
+    const template = {
+      id: 2,
+      content: [
+        {
+          name: "dates",
+          fields: [
+            {
+              name: "fecha",
+              type: "date",
+              restrictions: { resolved: { min: null, max: "2026-10-15" } },
+            },
+            { name: "description", type: "string" },
+          ],
+        },
+      ],
+    };
+    const latestDfContent = {
+      fecha: { value: "2026-10-16", origin: "user" },
+      description: { value: "Original", origin: "user" },
+    };
+    const props = {
+      structure: { id: 1, domain_ids: [1] },
+      template,
+      applyTemplate: applyTemplate(template),
+      latestDfContent,
+      selectTemplate: jest.fn(),
+      selectDomains: jest.fn(),
+      doStructureNoteAction: jest.fn(),
+      structureNotes: { structureNotes: [] },
+    };
+
+    it("keeps Save enabled for an unchanged out-of-range date", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      expect(await rendered.findByText(/save/i)).toBeEnabled();
+    });
+
+    it("passes persisted originals to the widgets", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      expect(dynamicFormOriginalContent).toEqual(latestDfContent);
+    });
+
+    it("keeps Save enabled when only another field is edited", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      await act(async () => {
+        dynamicFormOnChange({
+          ...latestDfContent,
+          description: { value: "Updated", origin: "user" },
+        });
+      });
+
+      expect(await rendered.findByText(/save/i)).toBeEnabled();
+    });
+
+    it("disables Save when the date changes to another invalid value", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      await act(async () => {
+        dynamicFormOnChange({
+          ...latestDfContent,
+          fecha: { value: "2026-10-17", origin: "user" },
+        });
+      });
+
+      expect(await rendered.findByText(/save/i)).toBeDisabled();
+    });
+
+    it("restores the exemption when the original date is restored", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      await act(async () => {
+        dynamicFormOnChange({
+          ...latestDfContent,
+          fecha: { value: "2026-10-17", origin: "user" },
+        });
+      });
+      await act(async () => dynamicFormOnChange({ ...latestDfContent }));
+
+      expect(await rendered.findByText(/save/i)).toBeEnabled();
+    });
+
+    it("still validates dates on creation", async () => {
+      const rendered = render(
+        <StructureNotesEdit {...props} latestDfContent={{}} />,
+      );
+      await waitForLoad(rendered);
+
+      await act(async () => dynamicFormOnChange(latestDfContent));
+
+      expect(await rendered.findByText(/save/i)).toBeDisabled();
+    });
   });
 
   it("matches the latest snapshot", async () => {

package/src/components/__tests__/SystemForm.dateRestrictions.spec.js

@@ -0,0 +1,102 @@
+import { act } from "@testing-library/react";
+import { render, waitForLoad } from "@truedat/test/render";
+import DynamicForm from "@truedat/df/components/DynamicForm";
+import { SystemForm } from "../SystemForm";
+
+jest.mock("@truedat/df/components/DynamicForm", () => jest.fn(() => null));
+jest.mock("@truedat/df/templates/components/TemplateLoader", () => () => null);
+
+const content = { date: { value: "2025-01-01", origin: "user" } };
+const template = {
+  name: "system",
+  content: [
+    {
+      name: "dates",
+      fields: [
+        {
+          name: "date",
+          type: "date",
+          cardinality: "?",
+          restrictions: { max_date: { mode: "static", value: "2024-01-01" } },
+        },
+      ],
+    },
+  ],
+};
+const system = {
+  id: 1,
+  name: "System",
+  external_id: "system",
+  dynamic_content: content,
+};
+const formProps = () => DynamicForm.mock.calls.at(-1)[0];
+
+describe("<SystemForm /> date restrictions", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("passes persisted content to the dynamic form", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    expect(formProps().originalContent).toEqual(content);
+  });
+
+  it("allows unchanged persisted dates outside the current range", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    expect(
+      rendered.getByRole("button", { name: "actions.update" }),
+    ).toBeEnabled();
+  });
+
+  it("rejects changed dates outside the current range", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    act(() =>
+      formProps().onChange({ date: { value: "2025-02-01", origin: "user" } }),
+    );
+    expect(
+      rendered.getByRole("button", { name: "actions.update" }),
+    ).toBeDisabled();
+  });
+
+  it("keeps the edit baseline after content changes", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    act(() =>
+      formProps().onChange({ date: { value: "2023-01-01", origin: "user" } }),
+    );
+    expect(formProps().originalContent).toEqual(content);
+  });
+
+  it("does not supply an original for creation", async () => {
+    const rendered = render(
+      <SystemForm template={template} createSystem={jest.fn()} />,
+    );
+    await waitForLoad(rendered);
+    expect(formProps().originalContent).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,78 @@
+import { doStructureNoteAction } from "../../routines";
+import { ddMessage, initialState } from "../ddMessage";
+
+describe("reducers: ddMessage on a failed structure note action", () => {
+  it("surfaces the backend's field error", () => {
+    const state = ddMessage(initialState, {
+      type: doStructureNoteAction.FAILURE,
+      payload: {
+        status: 422,
+        data: {
+          errors: {
+            fecha: ["2026-06-30 is not within the allowed range"],
+          },
+        },
+      },
+    });
+
+    expect(state.error).toBe(true);
+    expect(state.header).toBe("alert.doStructureNoteAction.failed.header");
+    expect(state.content).toBe("2026-06-30 is not within the allowed range");
+  });
+
+  it("names every field that failed", () => {
+    const state = ddMessage(initialState, {
+      type: doStructureNoteAction.FAILURE,
+      payload: {
+        status: 422,
+        data: {
+          errors: {
+            fecha: ["2026-06-30 is not within the allowed range"],
+            nombre: ["can't be blank"],
+          },
+        },
+      },
+    });
+
+    expect(state.content).toContain(
+      "2026-06-30 is not within the allowed range",
+    );
+    expect(state.content).toContain("can't be blank");
+  });
+
+  it("still falls back to the header when the payload carries no errors", () => {
+    const state = ddMessage(initialState, {
+      type: doStructureNoteAction.FAILURE,
+      payload: { status: 500, data: {} },
+    });
+
+    expect(state.error).toBe(true);
+    expect(state.header).toBe("alert.doStructureNoteAction.failed.header");
+    expect(state.content).toBeFalsy();
+  });
+
+  it("keeps a non-validation error message when the backend sends one", () => {
+    const state = ddMessage(initialState, {
+      type: doStructureNoteAction.FAILURE,
+      payload: { status: 400, data: { error: "structure note is locked" } },
+    });
+
+    expect(state.content).toBe("structure note is locked");
+  });
+
+  it("passes structured date errors to the shared Alert", () => {
+    const error = {
+      name: "structureNote.error.errors.date_restrictions.out_of_range",
+      field: "fecha max fija",
+      values: { limit: "2026-10-15" },
+    };
+
+    const state = ddMessage(initialState, {
+      type: doStructureNoteAction.FAILURE,
+      payload: { status: 422, data: { errors: [error] } },
+    });
+
+    expect(state.errorList).toEqual([error]);
+    expect(state.content).toBeUndefined();
+  });
+});

package/src/reducers/ddMessage.js

@@ -132,11 +132,26 @@ const ddMessage = (state = initialState, { type, payload }) => {
         error: true,
         header: "alert.doStructureNoteAction.failed.header",
         icon: "attention",
-        content: payload?.data?.error,
+        ...noteActionErrorMessage(payload),
       };
     default:
       return state;
   }
 };
 
+const noteActionErrorMessage = (payload) => {
+  const errors = payload?.data?.errors;
+
+  if (Array.isArray(errors)) {
+    return { errorList: errors };
+  }
+
+  if (errors && typeof errors === "object") {
+    const messages = Object.values(errors).flat().filter(Boolean);
+    if (messages.length) return { content: messages.join(" ") };
+  }
+
+  return { content: payload?.data?.error };
+};
+
 export { ddMessage };