@truedat/core 8.13.4 → 8.13.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/core",
-  "version": "8.13.4",
+  "version": "8.13.6",
   "description": "Truedat Web Core",
   "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.4",
+    "@truedat/test": "8.13.6",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "redux-saga-test-plan": "^4.0.6"
@@ -99,5 +99,5 @@
     "swr": "^2.3.3",
     "turndown": "^7.2.2"
   },
-  "gitHead": "4ec142f1c856aa669b232b12250c800a19ab9ace"
+  "gitHead": "c0943c8cf31e82a81fdca24d68ef57406fe5bcbc"
 }

package/src/components/Alert.js

@@ -11,10 +11,14 @@ import { AlertExporter } from "./AlertExporter";
 const existingList = (list) => list && !_.isEmpty(list);
 
 const safeFormat = (formatMessage) => (descriptor, values) => {
+  const fallback = descriptor.defaultMessage ?? descriptor.id;
+
   try {
-    return formatMessage(descriptor, values);
+    const formatted = formatMessage(descriptor, values);
+
+    return formatted === descriptor.id ? fallback : formatted;
   } catch {
-    return descriptor.defaultMessage ?? descriptor.id;
+    return fallback;
   }
 };
 
@@ -34,14 +38,14 @@ const formatErrorMessages = (error, formatMessage) => {
     });
   }
 
-  if (_.every(["name", "code"], _.partial(_.has)(error)))
-    return formatMessage(
-      { id: error.name, defaultMessage: error.name },
-      { text: error.code },
+  if (_.has("name")(error)) {
+    const message = safe(
+      { id: error.name },
+      { text: error.code, field: error.field, ...(error.values || {}) },
     );
 
-  if (_.has("name")(error))
-    return formatMessage({ id: error.name, defaultMessage: error.name });
+    return error.field ? `${error.field}: ${message}` : message;
+  }
 
   return formatMessage({
     id: "error.unknown",

package/src/components/GlossaryMenu.js

@@ -15,7 +15,7 @@ import {
   CONCEPTS_DEPRECATED,
   CONCEPT_LINKS_MANAGEMENT,
   CONCEPT_LINKS_APPROVALS,
-  CONCEPTS_BULK_UPLOAD_EVENTS,
+  CONCEPTS_UPLOAD_JOBS,
   CONCEPTS_SUBSCOPE,
   CONCEPTS_SIDEMENU_SUBSCOPE,
   CONCEPTS_SIDEMENU_SUBSCOPE_DEPRECATED,
@@ -101,9 +101,9 @@ function buildMainConceptsSubmenuItems(
   };
   const manageUploads = {
     name: "concepts_upload_events",
-    routes: [CONCEPTS_BULK_UPLOAD_EVENTS],
+    routes: [CONCEPTS_UPLOAD_JOBS],
     groups: ["business_glossary_management"],
-    isActive: () => pathname === CONCEPTS_BULK_UPLOAD_EVENTS,
+    isActive: () => pathname === CONCEPTS_UPLOAD_JOBS,
   };
 
   return [
@@ -171,7 +171,7 @@ function buildManagementSubmenuItems() {
     },
     {
       name: "concepts_upload_events",
-      routes: [CONCEPTS_BULK_UPLOAD_EVENTS],
+      routes: [CONCEPTS_UPLOAD_JOBS],
       groups: ["business_glossary_management"],
     },
   ];

package/src/components/TemplateSelector.js

@@ -2,7 +2,7 @@ import _ from "lodash/fp";
 import PropTypes from "prop-types";
 
 import { useEffect, useRef } from "react";
-import { Form, Label } from "semantic-ui-react";
+import { Button, Form, Label, Message } from "semantic-ui-react";
 import { useIntl, FormattedMessage } from "react-intl";
 import { useQuery } from "@apollo/client";
 import { accentInsensitivePathOrder } from "../services/sort";
@@ -112,13 +112,37 @@ TemplateSelector.propTypes = {
 };
 
 const emptyTemplates = [];
+
+export const TemplateLoadError = ({ onRetry }) => (
+  <Message negative compact>
+    <Message.Content>
+      <FormattedMessage
+        id="template.selector.load_error"
+        defaultMessage="Templates could not be loaded. Check your access and try again."
+      />
+      {onRetry ? (
+        <Button size="small" onClick={onRetry}>
+          <FormattedMessage
+            id="template.selector.retry"
+            defaultMessage="Retry"
+          />
+        </Button>
+      ) : null}
+    </Message.Content>
+  </Message>
+);
+
+TemplateLoadError.propTypes = {
+  onRetry: PropTypes.func,
+};
+
 export const TemplateSelectorLoader = ({
   scope,
   onLoad,
   domainIds,
   ...props
 }) => {
-  const { loading, error, data } = useQuery(TEMPLATES_QUERY, {
+  const { loading, error, data, refetch } = useQuery(TEMPLATES_QUERY, {
     fetchPolicy: "cache-and-network",
     variables: { scope, domainIds },
   });
@@ -131,7 +155,9 @@ export const TemplateSelectorLoader = ({
     }
   }, [data, onLoad]);
 
-  if (error) return null;
+  if (error && !loading) {
+    return <TemplateLoadError onRetry={() => refetch()} />;
+  }
 
   const templates = data?.templates || emptyTemplates;
   return (

package/src/components/UploadJobDetails.js

@@ -168,7 +168,7 @@ export const ChangesDetail = ({ changes, changeDetails, scope }) => {
   const detailsId = useId();
   const details = changeDetails ?? changes;
 
-  if (!details) return null;
+  if (!details || _.isEmpty(details)) return null;
 
   const changesList = flattenChanges(details);
 

package/src/components/UploadJobParser.js

@@ -1,9 +1,11 @@
 import _ from "lodash/fp";
 import PropTypes from "prop-types";
+import { Link } from "react-router";
 import { FormattedMessage, useIntl } from "react-intl";
 import Label from "semantic-ui-react/dist/commonjs/elements/Label";
 import RuleImplementationLink from "@truedat/dq/components/RuleImplementationLink";
 import StructureNoteLink from "@truedat/dd/components/StructureNoteLink";
+import { linkTo } from "../routes";
 import { ChangesDetail, ErrorDetailsDisclosure } from "./UploadJobDetails";
 import { classifyUploadJobErrorMessage } from "./UploadJobSummary";
 
@@ -45,7 +47,13 @@ export const ResponseCell = ({
       );
     }
     case "ERROR":
-      return <ErrorDetail response={response} showOrigin={showOrigin} />;
+      return (
+        <ErrorDetail
+          response={response}
+          showOrigin={showOrigin}
+          scope={scope}
+        />
+      );
     case "COMPLETED":
       return <CompletedDetail response={response} />;
     case "INFO":
@@ -69,6 +77,19 @@ export const ResponseCell = ({
   }
 };
 
+const ConceptLink = ({ business_concept_id, id, name }) => (
+  <Link to={linkTo.CONCEPT_VERSION({ business_concept_id, id })}>{name}</Link>
+);
+
+ConceptLink.propTypes = {
+  business_concept_id: PropTypes.oneOfType([
+    PropTypes.number,
+    PropTypes.string,
+  ]),
+  id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  name: PropTypes.string,
+};
+
 export const ResultEntityCell = ({ response, status }) => {
   if (!response?.details || !["INFO", "ERROR"].includes(status)) return null;
 
@@ -78,6 +99,8 @@ export const ResultEntityCell = ({ response, status }) => {
 
   return response.details.implementation_key != null ? (
     <RuleImplementationLink {...response.details} />
+  ) : response.details.business_concept_id != null ? (
+    <ConceptLink {...response.details} />
   ) : status === "INFO" &&
     (response.details.data_structure_id != null ||
       response.details.external_id != null) ? (
@@ -113,6 +136,11 @@ ResultEntityCell.propTypes = {
         PropTypes.number,
         PropTypes.string,
       ]),
+      business_concept_id: PropTypes.oneOfType([
+        PropTypes.number,
+        PropTypes.string,
+      ]),
+      id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
       name: PropTypes.string,
     }),
   }),
@@ -187,7 +215,7 @@ const externalIdDetailValue = (details) =>
     (details?.external_id ?? "")
   );
 
-const ErrorDetail = ({ response, showOrigin }) => {
+const ErrorDetail = ({ response, showOrigin, scope }) => {
   const { formatMessage } = useIntl();
 
   if (!response || !response.type) {
@@ -196,6 +224,31 @@ const ErrorDetail = ({ response, showOrigin }) => {
   const { type } = response;
   const messagePrefix = "uploadJob.parser.detail";
 
+  const translatedFieldError = (error, details) => {
+    const rawMessageId = error?.name || error?.message;
+    const resourcePrefix =
+      scope === "concepts"
+        ? "concept.error.content."
+        : details?.implementation_key
+          ? "implementation.error."
+          : details?.rule_name
+            ? "rule.error."
+            : details?.external_id
+              ? "structureNote.error."
+              : "";
+    const messageId = error?.name
+      ? rawMessageId.startsWith(resourcePrefix) || !resourcePrefix
+        ? rawMessageId
+        : `${resourcePrefix}${rawMessageId}`
+      : rawMessageId;
+    if (!messageId) return "";
+
+    return formatMessage(
+      { id: messageId, defaultMessage: error?.message || messageId },
+      { field: error?.field, ...(error?.values || {}) },
+    );
+  };
+
   if (!showOrigin && type === "data_structure_not_found") {
     return (
       <span className="upload-job-simple-error">
@@ -204,6 +257,51 @@ const ErrorDetail = ({ response, showOrigin }) => {
     );
   }
 
+  if (!showOrigin && type === "name_not_available") {
+    const name = response.details?.name;
+
+    return (
+      <span className="upload-job-simple-error">
+        <FormattedMessage id="uploadJob.parser.error.name_not_available" />
+        {name != null ? `: ${name}` : null}
+      </span>
+    );
+  }
+
+  if (!showOrigin && type === "unexpected_error") {
+    const { type: errorType } = classifyUploadJobErrorMessage(
+      response.details?.message,
+    );
+
+    if (errorType === "unexpected_error") {
+      return (
+        <span className="upload-job-simple-error">
+          <FormattedMessage id="uploadJob.parser.error.unexpected_error" />
+        </span>
+      );
+    }
+  }
+
+  const validationErrorPairs = (errors, details) => {
+    if (_.isArray(errors)) {
+      return errors.map((e) => [
+        e?.field ?? formatMessage({ id: `${messagePrefix}.message` }),
+        translatedFieldError(e, details),
+      ]);
+    }
+
+    if (_.isObject(errors)) {
+      return Object.entries(errors).flatMap(([field, messages]) =>
+        (_.isArray(messages) ? messages : [messages]).map((message) => [
+          field,
+          message ?? "",
+        ]),
+      );
+    }
+
+    return null;
+  };
+
   const detailBuilders = {
     missing_required_headers: (details) => [
       [
@@ -276,10 +374,9 @@ const ErrorDetail = ({ response, showOrigin }) => {
         [null, externalIdDetailValue(details)],
       ].filter(([, v]) => v !== undefined && v !== ""),
     field_validation_error: (details) =>
-      details?.errors?.map((e) => [
-        e?.field ?? formatMessage({ id: `${messagePrefix}.message` }),
-        e?.message ?? "",
-      ]) ?? [[null, externalIdDetailValue(details)]],
+      validationErrorPairs(details?.errors, details) ?? [
+        [null, externalIdDetailValue(details)],
+      ],
     unprocessable_entity: (details) => [[null, externalIdDetailValue(details)]],
     structure_note_creation_error: (details) => {
       const reason = details?.reason ?? details?.error;
@@ -289,12 +386,10 @@ const ErrorDetail = ({ response, showOrigin }) => {
           ? `structures.uploadStructures.failed.note.${reason}`
           : null;
 
-      const errorPairs = details?.errors?.length
-        ? details.errors.map((e) => [
-            e?.field ?? formatMessage({ id: `${messagePrefix}.message` }),
-            e?.message ?? "",
-          ])
-        : [
+      const validationPairs = validationErrorPairs(details?.errors, details);
+
+      const errorPairs = _.isEmpty(validationPairs)
+        ? [
             [
               formatMessage({ id: `${messagePrefix}.reason` }),
               reasonMessageId
@@ -304,7 +399,8 @@ const ErrorDetail = ({ response, showOrigin }) => {
                   })
                 : String(reason ?? ""),
             ],
-          ];
+          ]
+        : validationPairs;
 
       const externalIdPair = details?.external_id
         ? [[null, externalIdDetailValue(details)]]

package/src/components/UploadJobScope.js

@@ -1,10 +1,19 @@
 import {
+  CONCEPTS_UPLOAD_JOBS,
   IMPLEMENTATIONS_UPLOAD_JOBS,
   STRUCTURE_NOTES_UPLOAD_JOBS,
   linkTo,
 } from "@truedat/core/routes";
 
 export const uploadJobScopes = {
+  concepts: {
+    listPath: CONCEPTS_UPLOAD_JOBS,
+    detailPath: (id) => linkTo.CONCEPTS_UPLOAD_JOB({ id }),
+    listHeaderId: "uploadJobs.concepts.header",
+    detailHeaderId: "uploadJob.concepts.header",
+    entityColumnMessageId: "uploadJob.results.column.concept",
+    fieldMessagePrefix: "concepts.props",
+  },
   implementations: {
     listPath: IMPLEMENTATIONS_UPLOAD_JOBS,
     detailPath: (id) => linkTo.IMPLEMENTATIONS_UPLOAD_JOB({ id }),

package/src/components/UploadJobSummary.js

@@ -52,7 +52,8 @@ export const classifyUploadJobErrorMessage = (message) => {
   const isTechnicalError =
     /^%[A-Z][A-Za-z0-9_.]*\{/.test(normalizedMessage) ||
     /^\{:/.test(normalizedMessage) ||
-    /^\*\* \(/.test(normalizedMessage);
+    /^\*\* \(/.test(normalizedMessage) ||
+    /^protocol \S+ not implemented/.test(normalizedMessage);
 
   return isTechnicalError
     ? { type: "unexpected_error" }

package/src/components/UploadJobs.js

@@ -105,6 +105,7 @@ export default function UploadJobs({ scope }) {
                           <ResponseCell
                             response={job.latest_event_response}
                             status={job.latest_status}
+                            scope={scope}
                           />
                         </Table.Cell>
                         <Table.Cell>

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

@@ -0,0 +1,87 @@
+import { renderWithIntl as render } from "@truedat/test/renderWithIntl";
+import { waitForLoad } from "@truedat/test/waitForLoad";
+import { Alert } from "../Alert";
+
+const mockFormatMessage = jest.fn(({ id }) => id);
+
+jest.mock("react-intl", () => ({
+  ...jest.requireActual("react-intl"),
+  useIntl: () => ({ formatMessage: mockFormatMessage }),
+}));
+
+beforeEach(() => mockFormatMessage.mockClear());
+
+const renderError = async (error) => {
+  const rendered = render(
+    <Alert
+      dismissAlert={jest.fn()}
+      message={{
+        error: true,
+        header: "header.id",
+        icon: "attention",
+        text: "text",
+        errorList: [error],
+      }}
+    />,
+  );
+  await waitForLoad(rendered);
+  return rendered;
+};
+
+describe("a validation error with values", () => {
+  it("shows the message and the field it came from", async () => {
+    const rendered = await renderError({
+      code: "undefined",
+      name: "concept.error.content.errors.date_restrictions.out_of_range",
+      field: "fecha max fija",
+      values: { limit: "2026-06-30" },
+    });
+
+    const text = rendered.container.textContent;
+
+    expect(text).toContain("fecha max fija");
+    expect(text).toContain(
+      "concept.error.content.errors.date_restrictions.out_of_range",
+    );
+  });
+
+  it("passes the field and limit as interpolation parameters", async () => {
+    await renderError({
+      code: "undefined",
+      name: "concept.error.content.errors.date_restrictions.out_of_range",
+      field: "fecha max fija",
+      values: { limit: "2026-06-30" },
+    });
+
+    expect(mockFormatMessage).toHaveBeenCalledWith(
+      { id: "concept.error.content.errors.date_restrictions.out_of_range" },
+      {
+        text: "undefined",
+        field: "fecha max fija",
+        limit: "2026-06-30",
+      },
+    );
+  });
+
+  it("falls back to the key when there are no values", async () => {
+    const rendered = await renderError({
+      code: "undefined",
+      name: "concept.error.content.name.is.invalid",
+    });
+
+    expect(
+      rendered.getByText("concept.error.content.name.is.invalid"),
+    ).toBeInTheDocument();
+  });
+
+  it("keeps showing a plain error with a code and no field", async () => {
+    const rendered = await renderError({
+      code: "some_code",
+      name: "createDomain.error.name.unique",
+    });
+
+    expect(
+      rendered.getByText("createDomain.error.name.unique"),
+    ).toBeInTheDocument();
+  });
+});

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

@@ -62,14 +62,31 @@ describe("<TemplateSelector />", () => {
     expect(rendered.container).toMatchSnapshot();
   });
 
-  it("is empty if templates query returns an error", async () => {
+  it("shows an actionable message if templates query returns an error", async () => {
     const renderOpts = { mocks: [errorTemplateMock(variables)] };
     const rendered = render(
       <TemplateSelector {...props} required />,
       renderOpts,
     );
     await waitForLoad(rendered);
-    expect(rendered.queryByText(/template1/i)).not.toBeInTheDocument();
+    expect(
+      rendered.getByText(/templates could not be loaded/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByRole("button", { name: /retry/i }),
+    ).toBeInTheDocument();
+  });
+
+  it("retries a failed templates query", async () => {
+    const renderOpts = {
+      mocks: [errorTemplateMock(variables), multipleTemplatesMock(variables)],
+    };
+    const rendered = render(<TemplateSelector {...props} />, renderOpts);
+    const user = userEvent.setup({ delay: null });
+
+    await user.click(await rendered.findByRole("button", { name: /retry/i }));
+
+    expect(await rendered.findByText(/template1/i)).toBeInTheDocument();
   });
 
   it("calls onChange when template is selected", async () => {

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

@@ -37,4 +37,14 @@ describe("ImplementationUploadJobBreadcrumbs", () => {
     expect(rendered.getByText(filename)).toBeInTheDocument();
     expect(rendered.container).toMatchSnapshot();
   });
+
+  it("renders breadcrumbs for concepts scope", async () => {
+    const rendered = render(<UploadJobBreadcrumbs scope="concepts" />);
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.getByText(/uploadJobs.concepts.header/i),
+    ).toBeInTheDocument();
+    expect(rendered.container).toMatchSnapshot();
+  });
 });

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

@@ -32,6 +32,10 @@ jest.mock("@truedat/dd/components/StructureNoteLink", () => ({
     );
   },
 }));
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
+  Link: ({ to, children }) => <a href={to}>{children}</a>,
+}));
 
 const changeMessages = {
   en: {
@@ -50,6 +54,8 @@ const changeMessages = {
     "uploadJob.parser.error.field_validation_error": "Field validation error",
     "uploadJob.parser.error.data_structure_not_found":
       "Data structure not found",
+    "uploadJob.parser.error.unexpected_error": "Unexpected error",
+    "uploadJob.parser.error.name_not_available": "Name not available",
     "uploadJob.parser.detail.message": "Message",
   },
 };
@@ -99,6 +105,98 @@ describe("<ResultEntityCell />", () => {
     );
   });
 
+  it("renders INFO concept links from row details", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          details: {
+            id: 5,
+            business_concept_id: 3,
+            name: "My Concept",
+          },
+        }}
+      />,
+    );
+    expect(rendered.getByRole("link", { name: "My Concept" })).toHaveAttribute(
+      "href",
+      "/concepts/3/versions/5",
+    );
+  });
+
+  it("renders ERROR concept links from row details", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="ERROR"
+        response={{
+          type: "name_not_available",
+          details: {
+            id: 5,
+            business_concept_id: 3,
+            name: "My Concept",
+          },
+        }}
+      />,
+    );
+    expect(rendered.getByRole("link", { name: "My Concept" })).toHaveAttribute(
+      "href",
+      "/concepts/3/versions/5",
+    );
+  });
+
+  it("renders concept links for unexpected_error rows with entity data", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="ERROR"
+        response={{
+          type: "unexpected_error",
+          details: {
+            id: 5,
+            business_concept_id: 3,
+            name: "My Concept",
+          },
+        }}
+      />,
+    );
+    expect(rendered.getByRole("link", { name: "My Concept" })).toHaveAttribute(
+      "href",
+      "/concepts/3/versions/5",
+    );
+  });
+
+  it("renders concept links for unchanged rows", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          type: "unchanged",
+          details: {
+            id: 5,
+            business_concept_id: 3,
+            name: "My Concept",
+          },
+        }}
+      />,
+    );
+    expect(rendered.getByRole("link", { name: "My Concept" })).toHaveAttribute(
+      "href",
+      "/concepts/3/versions/5",
+    );
+  });
+
+  it("renders no entity for historical unchanged rows without entity data", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          type: "unchanged",
+          details: { row_number: 3, sheet: "date template" },
+        }}
+      />,
+    );
+    expect(rendered.container).toBeEmptyDOMElement();
+  });
+
   it("renders implementation refs and preferred structure labels with external ids", () => {
     const implementation = render(
       <ResultEntityCell
@@ -512,6 +610,128 @@ describe("<ResponseCell />", () => {
     expect(rendered.getByText(/Already exists/i)).toBeInTheDocument();
   });
 
+  it("translates named field errors and interpolates their field and values", () => {
+    const rendered = render(
+      <ResponseCell
+        response={{
+          type: "field_validation_error",
+          details: {
+            implementation_key: "implementation-key",
+            errors: [
+              {
+                name: "errors.date_restrictions.out_of_range",
+                message: "Invalid value",
+                field: "threshold",
+                values: { min: 10, max: 20 },
+              },
+            ],
+          },
+        }}
+        status="ERROR"
+        scope="concepts"
+      />,
+      {
+        messages: {
+          en: {
+            "concept.error.content.errors.date_restrictions.out_of_range":
+              "{field} must be between {min} and {max}",
+          },
+        },
+      },
+    );
+
+    expect(
+      rendered.getByText("threshold must be between 10 and 20"),
+    ).toBeInTheDocument();
+  });
+
+  it("keeps field errors with only a message compatible", () => {
+    const rendered = render(
+      <ResponseCell
+        response={{
+          type: "field_validation_error",
+          details: {
+            errors: [{ field: "name", message: "Required" }],
+          },
+        }}
+        status="ERROR"
+      />,
+    );
+
+    expect(rendered.getByText("Required")).toBeInTheDocument();
+  });
+
+  it("translates named implementation errors and interpolates their values", () => {
+    const rendered = render(
+      <ResponseCell
+        response={{
+          type: "field_validation_error",
+          details: {
+            implementation_key: "implementation-key",
+            errors: [
+              {
+                name: "value.out_of_range",
+                message: "Invalid value",
+                field: "threshold",
+                values: { min: 10, max: 20 },
+              },
+            ],
+          },
+        }}
+        status="ERROR"
+      />,
+      {
+        messages: {
+          en: {
+            "implementation.error.value.out_of_range":
+              "{field} must be between {min} and {max}",
+          },
+        },
+      },
+    );
+
+    expect(
+      rendered.getByText("threshold must be between 10 and 20"),
+    ).toBeInTheDocument();
+  });
+
+  it("renders ERROR status with field_validation_error details as an object", () => {
+    const response = {
+      type: "field_validation_error",
+      details: {
+        id: 693,
+        name: "prueba2",
+        sheet: "termino",
+        errors: { adjuntos: ["is invalid"] },
+        row_number: 3,
+        business_concept_id: 337,
+      },
+    };
+    const rendered = render(
+      <ResponseCell response={response} status="ERROR" />,
+    );
+    expect(
+      rendered.getByText(/uploadJob.parser.error.field_validation_error/i),
+    ).toBeInTheDocument();
+    expect(rendered.getByText(/adjuntos/i)).toBeInTheDocument();
+    expect(rendered.getByText(/is invalid/i)).toBeInTheDocument();
+  });
+
+  it("renders ERROR status with field_validation_error object details with multiple messages", () => {
+    const response = {
+      type: "field_validation_error",
+      details: {
+        errors: { name: ["Required", "Too long"], type: "is invalid" },
+      },
+    };
+    const rendered = render(
+      <ResponseCell response={response} status="ERROR" />,
+    );
+    expect(rendered.getByText(/Required/i)).toBeInTheDocument();
+    expect(rendered.getByText(/Too long/i)).toBeInTheDocument();
+    expect(rendered.getByText(/is invalid/i)).toBeInTheDocument();
+  });
+
   it("renders ERROR status with deprecated_implementation details", () => {
     const response = {
       type: "deprecated_implementation",
@@ -706,6 +926,27 @@ describe("<ResponseCell />", () => {
     });
   });
 
+  it("renders no changes disclosure when change_details is empty", () => {
+    const rendered = render(
+      <ResponseCell
+        response={{
+          type: "updated",
+          details: {
+            change_details: {},
+          },
+        }}
+        status="INFO"
+      />,
+      {
+        messages: changeMessages,
+      },
+    );
+
+    expect(
+      rendered.queryByRole("button", { name: /modified fields?/i }),
+    ).not.toBeInTheDocument();
+  });
+
   it("renders boolean, null and zero change values without losing their values", async () => {
     const user = userEvent.setup({ delay: null });
     const rendered = render(
@@ -850,6 +1091,67 @@ describe("<ResultDetailCell /> errors", () => {
     expect(rendered.queryByText("unknown-note")).not.toBeInTheDocument();
   });
 
+  it("renders unexpected_error with empty details as a generic message only", () => {
+    const rendered = render(
+      <ResultDetailCell
+        response={{ type: "unexpected_error", details: {} }}
+        status="ERROR"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(rendered.getByText("Unexpected error")).toBeInTheDocument();
+    expect(rendered.queryByRole("button")).not.toBeInTheDocument();
+    expect(
+      rendered.queryByText(/protocol String\.Chars/),
+    ).not.toBeInTheDocument();
+  });
+
+  it("renders unexpected_error events with technical messages as a generic message only", () => {
+    const technicalMessage =
+      "protocol String.Chars not implemented for type Tuple. This protocol is implemented for the following type(s): Atom, BitString\n\nGot value:\n\n {:array, :map}\n";
+
+    const rendered = render(
+      <ResultDetailCell
+        response={{
+          type: "unexpected_error",
+          details: { message: technicalMessage },
+        }}
+        status="ERROR"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(rendered.getByText("Unexpected error")).toBeInTheDocument();
+    expect(rendered.queryByRole("button")).not.toBeInTheDocument();
+    expect(
+      rendered.queryByText(/protocol String\.Chars/),
+    ).not.toBeInTheDocument();
+  });
+
+  it("renders name_not_available with the conflicting name as a simple message", () => {
+    const rendered = render(
+      <ResultDetailCell
+        response={{
+          type: "name_not_available",
+          details: {
+            name: "TEST CREACION",
+            row_number: 3,
+            sheet: "date template",
+          },
+        }}
+        status="ERROR"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(
+      rendered.getByText("Name not available: TEST CREACION"),
+    ).toBeInTheDocument();
+    expect(rendered.queryByRole("button")).not.toBeInTheDocument();
+    expect(rendered.queryByText(/row_number/)).not.toBeInTheDocument();
+  });
+
   it("uses the singular error count for one field", () => {
     const rendered = render(
       <ResultDetailCell

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

@@ -25,6 +25,23 @@ describe("Upload job scopes", () => {
     );
   });
 
+  it("defines concepts upload routes and presentation metadata", () => {
+    expect(uploadJobScopes.concepts.listPath).toBe("/concepts/uploadJobs");
+    expect(uploadJobScopes.concepts.listHeaderId).toBe(
+      "uploadJobs.concepts.header",
+    );
+    expect(uploadJobScopes.concepts.detailHeaderId).toBe(
+      "uploadJob.concepts.header",
+    );
+    expect(uploadJobScopes.concepts.detailPath(12)).toBe(
+      "/concepts/uploadJobs/12",
+    );
+    expect(uploadJobScopes.concepts.entityColumnMessageId).toBe(
+      "uploadJob.results.column.concept",
+    );
+    expect(uploadJobScopes.concepts.fieldMessagePrefix).toBe("concepts.props");
+  });
+
   it("falls back to implementation semantics for unknown scopes", () => {
     expect(getUploadJobScope("other")).toMatchObject({
       listPath: null,

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

@@ -130,6 +130,33 @@ describe("<UploadJobSummary />", () => {
     });
   });
 
+  it("classifies protocol not implemented messages as unexpected errors", () => {
+    expect(
+      classifyUploadJobErrorMessage(
+        "protocol String.Chars not implemented for type Tuple. This protocol is implemented for the following type(s): Atom, BitString\n\nGot value:\n\n {:array, :map}\n",
+      ),
+    ).toEqual({ type: "unexpected_error" });
+  });
+
+  it("replaces protocol failure details with an unexpected error", () => {
+    const technicalMessage =
+      "protocol String.Chars not implemented for type Tuple. This protocol is implemented for the following type(s): Atom, BitString\n\nGot value:\n\n {:array, :map}\n";
+    const rendered = render(
+      <UploadJobSummary
+        events={[{ status: "FAILED", response: { message: technicalMessage } }]}
+        latestStatus="FAILED"
+      />,
+      { messages: summaryMessages },
+    );
+
+    expect(rendered.getByLabelText("Summary")).toHaveTextContent(
+      "Error processing the file: Unexpected error",
+    );
+    expect(rendered.getByLabelText("Summary")).not.toHaveTextContent(
+      "protocol String.Chars not implemented",
+    );
+  });
+
   it("renders a human failure message", () => {
     const rendered = render(
       <UploadJobSummary

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

@@ -189,4 +189,19 @@ describe("<UploadJobs />", () => {
     expect(rendered.getByText(/completed/i)).toBeInTheDocument();
     expect(rendered.getByText(/success/i)).toBeInTheDocument();
   });
+
+  it("renders concepts scope header", async () => {
+    useUploadJobs.mockReturnValue({
+      loading: false,
+      data: {
+        data: [],
+      },
+    });
+
+    const rendered = render(<UploadJobs scope="concepts" />);
+    await waitForLoad(rendered);
+
+    const elements = rendered.getAllByText(/uploadJobs.concepts.header/i);
+    expect(elements.length).toBeGreaterThan(0);
+  });
 });

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

@@ -132,7 +132,7 @@ exports[`<GlossaryMenu /> matches the latest snapshot, finds fixed and subscopes
           aria-checked="false"
           class="item"
           data-discover="true"
-          href="/concepts/management/bulk_upload_event"
+          href="/concepts/uploadJobs"
           name="concepts_upload_events"
           role="option"
         >

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

@@ -125,7 +125,7 @@ exports[`<SideMenu /> matches the latest snapshot 1`] = `
               aria-checked="false"
               class="item"
               data-discover="true"
-              href="/concepts/management/bulk_upload_event"
+              href="/concepts/uploadJobs"
               name="concepts_upload_events"
               role="option"
             >

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

@@ -1,5 +1,21 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`ImplementationUploadJobBreadcrumbs renders breadcrumbs for concepts scope 1`] = `
+<div>
+  <div
+    class="ui breadcrumb"
+  >
+    <a
+      class="section"
+      data-discover="true"
+      href="/concepts/uploadJobs"
+    >
+      uploadJobs.concepts.header
+    </a>
+  </div>
+</div>
+`;
+
 exports[`ImplementationUploadJobBreadcrumbs renders breadcrumbs with filename 1`] = `
 <div>
   <div

package/src/components/index.js

@@ -55,7 +55,7 @@ import SideMenu from "./SideMenu";
 import StructureFilterItem from "./StructureFilterItem";
 import Submenu from "./Submenu";
 import TaxonomyMenu from "./TaxonomyMenu";
-import TemplateSelector from "./TemplateSelector";
+import TemplateSelector, { TemplateLoadError } from "./TemplateSelector";
 import TreeSelector from "./TreeSelector";
 import Unauthorized from "./Unauthorized";
 import UploadModal from "./UploadModal";
@@ -119,6 +119,7 @@ export {
   StructureFilterItem,
   Submenu,
   TaxonomyMenu,
+  TemplateLoadError,
   TemplateSelector,
   TreeSelector,
   TrueModal,

package/src/routes.js

@@ -14,8 +14,8 @@ export const BUCKET_VIEW_CONFIG_EDIT = "/bucketViewConfigs/:id/edit";
 export const BUCKET_VIEW_CONFIG_NEW = "/bucketViewConfigs/new";
 export const CONCEPTS = "/concepts";
 export const CONCEPTS_BULK_UPDATE = "/concepts/bulk_update";
-export const CONCEPTS_BULK_UPLOAD_EVENTS =
-  "/concepts/management/bulk_upload_event";
+export const CONCEPTS_UPLOAD_JOBS = "/concepts/uploadJobs";
+export const CONCEPTS_UPLOAD_JOB = "/concepts/uploadJobs/:id";
 export const CONCEPTS_NEW = "/concepts/new";
 export const CONCEPTS_PENDING = "/concepts/pending";
 export const CONCEPTS_DEPRECATED = "/concepts/deprecated";
@@ -313,6 +313,8 @@ const routes = {
   BUCKET_VIEW_CONFIGS,
   CONCEPTS,
   CONCEPTS_BULK_UPDATE,
+  CONCEPTS_UPLOAD_JOBS,
+  CONCEPTS_UPLOAD_JOB,
   CONCEPT_LINKS_APPROVALS,
   CONCEPT_LINKS_APPROVALS_RESULTS,
   CONCEPTS_NEW,

package/src/services/__tests__/messageObjectErrors.spec.js

@@ -0,0 +1,77 @@
+import { toErrorList, phoenixFailure } from "../message";
+
+describe("errors whose entries are objects", () => {
+  it("does not stringify an object into the key", () => {
+    const [error] = toErrorList("checkoutGrantRequest.error")({
+      requests: [{ data_structure_id: 42 }],
+    });
+
+    expect(error.name).not.toContain("[object Object]");
+  });
+
+  it("falls back to the key itself when the object carries no message", () => {
+    const [error] = toErrorList("checkoutGrantRequest.error")({
+      requests: [{ data_structure_id: 42 }],
+    });
+
+    expect(error.name).toBe("checkoutGrantRequest.error.requests");
+  });
+
+  it("uses a message when the object carries one", () => {
+    const [error] = toErrorList("checkoutGrantRequest.error")({
+      requests: [{ message: "user_id is required" }],
+    });
+
+    expect(error.name).toBe(
+      "checkoutGrantRequest.error.requests.user_id is required",
+    );
+  });
+
+  it("keeps plain string entries working as before", () => {
+    const errors = toErrorList("checkoutGrantRequest.error")({
+      user_id: ["can't be blank"],
+    });
+
+    expect(errors).toEqual([
+      { name: "checkoutGrantRequest.error.user_id.can't be blank" },
+    ]);
+  });
+
+  it("a phoenix failure with an object entry does not leak it either", () => {
+    const failure = phoenixFailure("CHECKOUT_GRANT_REQUEST/FAILURE", {
+      requests: [{ data_structure_id: 42 }],
+    });
+
+    expect(JSON.stringify(failure)).not.toContain("[object Object]");
+  });
+});
+
+describe("both changeset error shapes", () => {
+  it("passes through a list the back end already normalised", () => {
+    const failure = phoenixFailure("RULE_CREATE/FAILURE", [
+      {
+        name: "rule.error.errors.date_restrictions.out_of_range",
+        field: "fecha max fija",
+        values: { limit: "2026-06-30" },
+      },
+    ]);
+
+    expect(failure.errorList).toEqual([
+      {
+        name: "rule.error.errors.date_restrictions.out_of_range",
+        field: "fecha max fija",
+        values: { limit: "2026-06-30" },
+      },
+    ]);
+  });
+
+  it("still builds keys from the older object shape", () => {
+    const failure = phoenixFailure("RULE_CREATE/FAILURE", {
+      name: ["can't be blank"],
+    });
+
+    expect(failure.errorList).toEqual([
+      { name: "ruleCreate.error.name.can't be blank" },
+    ]);
+  });
+});

package/src/services/message.js

@@ -4,7 +4,9 @@ const isErrorsFailure = (status, data) =>
   status === 422 && _.conformsTo({ errors: _.isArray })(data);
 
 const isPhoenixFailure = (status, data) =>
-  status === 422 && _.conformsTo({ errors: _.isObject })(data);
+  status === 422 &&
+  (_.conformsTo({ errors: _.isObject })(data) ||
+    _.conformsTo({ errors: _.isArray })(data));
 
 const isDefaultFailure = (status) => {
   return !!status;
@@ -79,14 +81,32 @@ export const graphQLErrors = (payload) => {
   };
 };
 
-export const toErrorList = (prefix) =>
-  _.flow(
+const errorKeyPart = (entry) => {
+  if (_.isString(entry)) return entry;
+  if (_.isObject(entry)) return entry.message || "";
+  return String(entry ?? "");
+};
+
+export const toErrorList = (prefix) => (errors) => {
+  if (_.isArray(errors)) {
+    return errors.map((error) => ({
+      name: error.name,
+      ...(error.field ? { field: error.field } : {}),
+      ...(_.isEmpty(error.values) ? {} : { values: error.values }),
+    }));
+  }
+
+  return _.flow(
     _.toPairs,
-    _.flatMap(([field, errors]) =>
-      _.map((v) => `${prefix}.${field}.${v}`)(errors),
+    _.flatMap(([field, errorList]) =>
+      _.map((entry) => {
+        const part = errorKeyPart(entry);
+        return part ? `${prefix}.${field}.${part}` : `${prefix}.${field}`;
+      })(errorList),
     ),
     _.map((name) => ({ name })),
-  );
+  )(errors);
+};
 
 export const phoenixFailure = (type, errors) => {
   const action = _.flow(_.replace("/FAILURE", ""), _.camelCase)(type);