@truedat/bg 8.13.5 → 8.13.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/bg",
-  "version": "8.13.5",
+  "version": "8.13.6",
   "description": "Truedat Web Business Glossary",
   "sideEffects": [
     "**/*.css",
@@ -57,7 +57,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.5",
+    "@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 @@
     "semantic-ui-react": "^3.0.0-beta.2",
     "swr": "^2.3.3"
   },
-  "gitHead": "9b87cbb7143f20b305b84077c1fcf004e5b27726"
+  "gitHead": "c0943c8cf31e82a81fdca24d68ef57406fe5bcbc"
 }

package/src/concepts/components/ConceptEdit.js

@@ -7,6 +7,7 @@ import { applyTemplate } from "@truedat/df/utils";
 import { useLanguage } from "@truedat/core/i18n";
 import { splitTranslatableFields } from "@truedat/core/services/i18nContent";
 import { useTemplate } from "@truedat/core/hooks";
+import { Loading, TemplateLoadError } from "@truedat/core/components";
 import { conceptAction } from "../routines";
 import ConceptForm from "./ConceptForm";
 
@@ -25,6 +26,10 @@ export const ConceptEdit = ({
   const { domain } = concept;
   const [i18nConcept, setI18nConcept] = useState(content);
   const { defaultLang, altLangs } = useLanguage();
+  const [originalI18nConcept] = useState(() => ({
+    ...concept.i18n_content,
+    [defaultLang]: { content: concept.dynamic_content },
+  }));
 
   const templateFields = splitTranslatableFields(template);
   const translatableKeys = _.keys(templateFields.translatable);
@@ -66,6 +71,7 @@ export const ConceptEdit = ({
       resourceId={concept.business_concept_id}
       template={template}
       i18nConcept={i18nConcept}
+      originalI18nConcept={originalI18nConcept}
       loading={templateLoading || localesLoading}
       setI18nConcept={setI18nConcept}
       onSubmit={handleSubmit}
@@ -91,12 +97,28 @@ export const ConceptEditLoader = (props) => {
   const { dynamic_content: propContent, name: propName, domain } = concept;
 
   const { locales } = useLanguage();
-  const { data, loading: templateLoading } = useTemplate({
+  const {
+    data,
+    error: templateError,
+    loading: templateLoading,
+    refetch: refetchTemplate,
+  } = useTemplate({
     name: templateName,
     domainIds: [domain?.id],
   });
 
   const template = _.prop("template")(data);
+
+  if (templateError && !templateLoading) {
+    return <TemplateLoadError onRetry={() => refetchTemplate()} />;
+  }
+
+  if (templateLoading && !template) return <Loading />;
+
+  if (!template) {
+    return <TemplateLoadError onRetry={() => refetchTemplate()} />;
+  }
+
   const processedContent = applyTemplate(template);
 
   const translatableKeys = _.keys(

package/src/concepts/components/ConceptForm.js

@@ -22,15 +22,29 @@ import { useAvailabilityCheck as useTranslatableCheck } from "@truedat/ai/hooks/
 import { splitTranslatableFields } from "@truedat/core/services/i18nContent";
 import { TranslationModal } from "@truedat/ai/components";
 import { useWebContext } from "@truedat/core/webContext";
+import { validateContent } from "@truedat/df/utils";
 
 const SelectDynamicFormWithTranslations = lazy(
   () => import("@truedat/df/components/SelectDynamicFormWithTranslations"),
 );
 
+export const conceptHasDateRestrictionErrors = (
+  template,
+  i18nConcept,
+  originalI18nConcept,
+) =>
+  Object.entries(i18nConcept || {}).some(([lang, { content } = {}]) =>
+    validateContent(
+      template,
+      originalI18nConcept?.[lang]?.content,
+    )(content || {}).some(({ error }) => error === "date out of range"),
+  );
+
 const ConceptForm = ({
   actionKey,
   domainId,
   i18nConcept,
+  originalI18nConcept,
   loading,
   onSubmit,
   resourceId,
@@ -240,7 +254,16 @@ const ConceptForm = ({
     )(i18nConcept);
   const validTemplate = () =>
     _.isObject(template) && isNonEmptyString(template?.name);
-  const isInvalid = !validDomain() || !validNames() || !validTemplate();
+  const hasDateRestrictionErrors = conceptHasDateRestrictionErrors(
+    template,
+    i18nConcept,
+    originalI18nConcept,
+  );
+  const isInvalid =
+    !validDomain() ||
+    !validNames() ||
+    !validTemplate() ||
+    hasDateRestrictionErrors;
 
   const renderDomainSelector = () =>
     actionKey === "create" ? (
@@ -274,6 +297,9 @@ const ConceptForm = ({
         required
         header={renderFormHeader()}
         i18nContent={_.mapValues("content", i18nConcept)}
+        originalI18nContent={
+          originalI18nConcept && _.mapValues("content", originalI18nConcept)
+        }
         name={template?.name}
         actionKey={actionKey}
         onChangeContent={handleI18nConceptContentChange}
@@ -354,6 +380,7 @@ ConceptForm.propTypes = {
   domainId: PropTypes.number,
   template: PropTypes.object,
   i18nConcept: PropTypes.object,
+  originalI18nConcept: PropTypes.object,
   onSubmit: PropTypes.func,
   resourceId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
   setDomainId: PropTypes.func,

package/src/concepts/components/ConceptRoutes.js

@@ -230,9 +230,8 @@ const ConceptRoutes = ({
             element={
               <>
                 <ConceptCrumbs conceptAction="concepts.actions.edit" />
-                <TemplatesLoader scope="bg" />
                 <ConceptLoader />
-                {conceptLoaded && templatesLoaded ? <ConceptEdit /> : null}
+                {conceptLoaded ? <ConceptEdit /> : null}
               </>
             }
           />

package/src/concepts/components/__tests__/ConceptEdit.dateRestrictions.spec.js

@@ -0,0 +1,84 @@
+import { act, render } from "@testing-library/react";
+import ConceptForm from "../ConceptForm";
+import { ConceptEdit } from "../ConceptEdit";
+
+jest.mock("../ConceptForm", () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock("@truedat/core/i18n", () => ({
+  useLanguage: () => ({ defaultLang: "en", altLangs: ["es"] }),
+}));
+
+const savedDate = { value: "2027-01-01", origin: "user" };
+const concept = {
+  domain: { id: 1 },
+  dynamic_content: { fecha: savedDate },
+  i18n_content: { es: { content: { fecha: savedDate } } },
+};
+const props = {
+  concept,
+  content: {
+    en: { content: concept.dynamic_content },
+    es: {
+      content: {
+        ...concept.i18n_content.es.content,
+        newDate: { value: "2027-01-01", origin: "default" },
+      },
+    },
+  },
+  template: {},
+  conceptAction: jest.fn(),
+  processedContent: (content) => content,
+};
+
+const formProps = () => ConceptForm.mock.calls.at(-1)[0];
+
+describe("ConceptEdit date restriction originals", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("uses persisted default-language dates as the baseline", () => {
+    render(<ConceptEdit {...props} />);
+
+    expect(formProps().originalI18nConcept.en.content).toEqual(
+      concept.dynamic_content,
+    );
+  });
+
+  it("does not exempt defaults inserted into translated content", () => {
+    render(<ConceptEdit {...props} />);
+
+    expect(formProps().originalI18nConcept.es.content).not.toHaveProperty(
+      "newDate",
+    );
+  });
+
+  it("keeps the baseline when editable content changes", () => {
+    render(<ConceptEdit {...props} />);
+
+    act(() => {
+      formProps().setI18nConcept({
+        en: { content: { fecha: { value: "2027-02-01", origin: "user" } } },
+      });
+    });
+
+    expect(formProps().originalI18nConcept.en.content.fecha).toEqual(savedDate);
+  });
+
+  it("keeps the edit-session baseline across refreshed source props", () => {
+    const { rerender } = render(<ConceptEdit {...props} />);
+
+    rerender(
+      <ConceptEdit
+        {...props}
+        concept={{
+          ...concept,
+          dynamic_content: { fecha: { value: "2027-02-01", origin: "user" } },
+        }}
+      />,
+    );
+
+    expect(formProps().originalI18nConcept.en.content.fecha).toEqual(savedDate);
+  });
+});

package/src/concepts/components/__tests__/ConceptEdit.spec.js

@@ -1,6 +1,8 @@
+import { fireEvent } from "@testing-library/react";
 import { render } from "@truedat/test/render";
 import { waitFor } from "@testing-library/react";
 import { LangProviderWrapper } from "@truedat/core/i18n";
+import { useTemplate } from "@truedat/core/hooks";
 import ConceptEdit from "../ConceptEdit";
 
 jest.mock("@truedat/ai/hooks/useTranslations", () => {
@@ -58,6 +60,7 @@ jest.mock("@truedat/core/hooks", () => ({
   useTemplate: jest.fn(() => ({
     loading: false,
     data: { template },
+    refetch: jest.fn(),
   })),
 }));
 
@@ -126,10 +129,36 @@ describe("<ConceptEdit />", () => {
   const props = {
     concept,
   };
+
+  beforeEach(() => {
+    useTemplate.mockReturnValue({
+      loading: false,
+      data: { template },
+      refetch: jest.fn(),
+    });
+  });
+
   it("matches the latest snapshot", async () => {
     const { container, queryByText } = renderComponent(props);
 
     await waitFor(() => expect(queryByText(/foo_user/i)).toBeInTheDocument());
     expect(container).toMatchSnapshot();
   });
+
+  it("shows a visible retry message when its template fails to load", () => {
+    const refetch = jest.fn();
+    useTemplate.mockReturnValue({
+      loading: false,
+      error: new Error("template request failed"),
+      refetch,
+    });
+
+    const { getByText, getByRole } = renderComponent({
+      concept: { ...concept, type: "template1" },
+    });
+
+    expect(getByText(/templates could not be loaded/i)).toBeInTheDocument();
+    fireEvent.click(getByRole("button", { name: /retry/i }));
+    expect(refetch).toHaveBeenCalledTimes(1);
+  });
 });

package/src/concepts/components/__tests__/ConceptEditLoader.spec.js

@@ -0,0 +1,159 @@
+import { fireEvent, render } from "@testing-library/react";
+import { render as renderWithProviders } from "@truedat/test/render";
+import { LangProviderWrapper } from "@truedat/core/i18n";
+import { useTemplate } from "@truedat/core/hooks";
+import ConceptForm from "../ConceptForm";
+import { ConceptEditLoader } from "../ConceptEdit";
+
+jest.mock("@truedat/core/hooks", () => ({
+  useTemplate: jest.fn(),
+}));
+
+jest.mock("../ConceptForm", () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+const template = {
+  name: "concept-template",
+  content: [
+    {
+      fields: [
+        { name: "description", widget: "string" },
+        { name: "owner", widget: "dropdown" },
+      ],
+    },
+  ],
+};
+
+const concept = {
+  business_concept_id: 42,
+  type: template.name,
+  name: "BCV name",
+  domain: { id: 7 },
+  dynamic_content: {
+    description: { value: "BCV description", origin: "user" },
+    owner: { value: "alice", origin: "user" },
+  },
+  i18n_content: {
+    es: {
+      name: "Nombre traducido",
+      content: {
+        description: { value: "Descripción BCV", origin: "user" },
+      },
+    },
+  },
+};
+
+describe("ConceptEditLoader", () => {
+  const props = {
+    concept,
+    templateName: template.name,
+    conceptAction: jest.fn(),
+    action: {},
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("waits for the BCV template before initializing the form with BCV content", () => {
+    useTemplate.mockReturnValueOnce({ loading: true }).mockReturnValueOnce({
+      loading: false,
+      data: { template },
+      refetch: jest.fn(),
+    });
+
+    const { rerender } = render(
+      <LangProviderWrapper langs={["en", "es"]}>
+        <ConceptEditLoader {...props} />
+      </LangProviderWrapper>,
+    );
+
+    expect(ConceptForm).not.toHaveBeenCalled();
+
+    rerender(
+      <LangProviderWrapper langs={["en", "es"]}>
+        <ConceptEditLoader {...props} />
+      </LangProviderWrapper>,
+    );
+
+    expect(ConceptForm).toHaveBeenCalledTimes(1);
+    const formProps = ConceptForm.mock.calls[0][0];
+    expect(formProps.i18nConcept.en).toMatchObject({
+      name: "BCV name",
+      content: concept.dynamic_content,
+    });
+    expect(formProps.i18nConcept.es).toMatchObject({
+      name: "Nombre traducido",
+      content: {
+        description: { value: "Descripción BCV", origin: "user" },
+      },
+    });
+    expect(formProps.template).toEqual(template);
+  });
+
+  it("shows a retry message when the completed query has no template", () => {
+    useTemplate.mockReturnValue({
+      loading: false,
+      data: { template: null },
+      refetch: jest.fn(),
+    });
+
+    const rendered = renderWithProviders(
+      <LangProviderWrapper langs={["en", "es"]}>
+        <ConceptEditLoader {...props} />
+      </LangProviderWrapper>,
+    );
+
+    expect(
+      rendered.getByText(/templates could not be loaded/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByRole("button", { name: /retry/i }),
+    ).toBeInTheDocument();
+    expect(ConceptForm).not.toHaveBeenCalled();
+  });
+
+  it("loads the form after retrying a failed template query", () => {
+    const refetch = jest.fn(() => {
+      useTemplate.mockReturnValue({
+        loading: true,
+        refetch,
+      });
+    });
+    useTemplate.mockReturnValue({
+      loading: false,
+      error: new Error("template request failed"),
+      refetch,
+    });
+    const component = () => (
+      <LangProviderWrapper langs={["en", "es"]}>
+        <ConceptEditLoader {...props} />
+      </LangProviderWrapper>
+    );
+    const rendered = renderWithProviders(component());
+
+    fireEvent.click(rendered.getByRole("button", { name: /retry/i }));
+    expect(refetch).toHaveBeenCalledTimes(1);
+
+    rendered.rerender(component());
+    expect(ConceptForm).not.toHaveBeenCalled();
+    expect(
+      rendered.queryByText(/templates could not be loaded/i),
+    ).not.toBeInTheDocument();
+
+    useTemplate.mockReturnValue({
+      loading: false,
+      data: { template },
+      refetch,
+    });
+    rendered.rerender(component());
+
+    expect(ConceptForm).toHaveBeenCalled();
+    expect(ConceptForm.mock.calls[0][0].i18nConcept.en).toMatchObject({
+      name: concept.name,
+      content: concept.dynamic_content,
+    });
+  });
+});

package/src/concepts/components/__tests__/ConceptForm.spec.js

@@ -1,7 +1,7 @@
 import { waitFor } from "@testing-library/react";
 import { render, waitForLoad } from "@truedat/test/render";
 import { domainsMock, multipleTemplatesMock } from "@truedat/test/mocks";
-import ConceptForm from "../ConceptForm";
+import ConceptForm, { conceptHasDateRestrictionErrors } from "../ConceptForm";
 
 jest.mock("@truedat/ai/hooks/useSuggestions", () => {
   const originalModule = jest.requireActual("@truedat/ai/hooks/useSuggestions");
@@ -76,7 +76,103 @@ const props = {
 const templateVariables = { scope: "bg", domainIds: [1] };
 const domainVariables = { action: "createBusinessConcept" };
 
+const dateTemplate = {
+  content: [
+    {
+      name: "dates",
+      fields: [
+        {
+          name: "fecha",
+          type: "date",
+          restrictions: { resolved: { min: null, max: "2026-10-15" } },
+        },
+      ],
+    },
+  ],
+};
+
+const savedConcept = {
+  en: { content: { fecha: { value: "2026-10-16", origin: "user" } } },
+};
+
 describe("<ConceptForm />", () => {
+  it("allows an unchanged existing date outside the latest restriction", () => {
+    expect(
+      conceptHasDateRestrictionErrors(
+        dateTemplate,
+        {
+          en: {
+            name: "Updated name",
+            content: { fecha: { value: "2026-10-16", origin: "user" } },
+          },
+        },
+        savedConcept,
+      ),
+    ).toBe(false);
+  });
+
+  it("rejects a modified date outside the latest restriction", () => {
+    expect(
+      conceptHasDateRestrictionErrors(
+        dateTemplate,
+        { en: { content: { fecha: { value: "2026-10-17", origin: "user" } } } },
+        savedConcept,
+      ),
+    ).toBe(true);
+  });
+
+  it("does not exempt a new language using another language's saved date", () => {
+    expect(
+      conceptHasDateRestrictionErrors(
+        dateTemplate,
+        {
+          ...savedConcept,
+          es: { content: { fecha: { value: "2026-10-16", origin: "user" } } },
+        },
+        savedConcept,
+      ),
+    ).toBe(true);
+  });
+
+  it("detects an invalid date so Save can be disabled", () => {
+    const template = {
+      content: [
+        {
+          name: "dates",
+          fields: [
+            {
+              name: "fecha",
+              type: "date",
+              restrictions: {
+                resolved: { min: null, max: "2026-10-15" },
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    expect(
+      conceptHasDateRestrictionErrors(template, {
+        en: {
+          content: {
+            fecha: { value: "2026-10-16", origin: "user" },
+          },
+        },
+      }),
+    ).toBe(true);
+
+    expect(
+      conceptHasDateRestrictionErrors(template, {
+        en: {
+          content: {
+            fecha: { value: "2026-10-15", origin: "user" },
+          },
+        },
+      }),
+    ).toBe(false);
+  });
+
   describe("with multiple templates", () => {
     const renderOpts = {
       mocks: [

package/src/concepts/components/__tests__/ConceptRoutes.spec.js

@@ -152,10 +152,12 @@ describe("<ConceptRoutes />", () => {
       state: {
         concept: { business_concept_id: "123" },
         templatesLoading: false,
-        templates: { some: "template" },
+        templates: [],
       },
     });
     await waitForLoad(rendered);
+    expect(rendered.getByText("ConceptEdit")).toBeInTheDocument();
+    expect(rendered.queryByText("TemplatesLoader")).not.toBeInTheDocument();
     expect(rendered.container).toMatchSnapshot();
   });
 

package/src/concepts/components/__tests__/__snapshots__/ConceptRoutes.spec.js.snap

@@ -19,9 +19,6 @@ exports[`<ConceptRoutes /> renders correctly with concept edit route 1`] = `
   <div>
     ConceptCrumbs
   </div>
-  <div>
-    TemplatesLoader
-  </div>
   <div>
     ConceptLoader
   </div>