@truedat/dd 8.13.5 → 8.13.7

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

@@ -2,6 +2,10 @@
 
 exports[`<LineageRoutes /> renders correctly with GRAPHS route 1`] = `
 <div>
+  <div
+    aria-live="polite"
+    class="lineage-generation-notices"
+  />
   <div
     class="ui icon visible bottom attached message center"
   >
@@ -25,4 +29,11 @@ exports[`<LineageRoutes /> renders correctly with GRAPHS route 1`] = `
 </div>
 `;
 
-exports[`<LineageRoutes /> renders correctly with default route 1`] = `<div />`;
+exports[`<LineageRoutes /> renders correctly with default route 1`] = `
+<div>
+  <div
+    aria-live="polite"
+    class="lineage-generation-notices"
+  />
+</div>
+`;

package/src/components/__tests__/fixtures/graphGenerationMessages.json

@@ -0,0 +1,28 @@
+{
+  "en": {
+    "lineage.graph.loading": "Analyzing...",
+    "lineage.graph.wait.background": "Generate in background",
+    "lineage.graph.wait.background.notice": "The graph is being generated in the background. We will notify you when it is ready.",
+    "lineage.graph.wait.close": "Close and continue generating in background",
+    "lineage.graph.wait.completed": "The graph is ready.",
+    "lineage.graph.wait.continue": "Keep waiting",
+    "lineage.graph.wait.dismiss": "Dismiss notification",
+    "lineage.graph.wait.explanation": "This graph is taking longer than expected. You can keep waiting or continue working while it is generated in the background.",
+    "lineage.graph.wait.failed": "Unable to complete graph generation. Please try again.",
+    "lineage.graph.wait.open": "Open graph",
+    "lineage.graph.wait.waiting": "Waiting…"
+  },
+  "es": {
+    "lineage.graph.loading": "Analizando...",
+    "lineage.graph.wait.background": "Generar en segundo plano",
+    "lineage.graph.wait.background.notice": "El grafo se está generando en segundo plano. Te avisaremos cuando esté listo.",
+    "lineage.graph.wait.close": "Cerrar y continuar generando en segundo plano",
+    "lineage.graph.wait.completed": "El grafo está listo.",
+    "lineage.graph.wait.continue": "Seguir esperando",
+    "lineage.graph.wait.dismiss": "Descartar notificación",
+    "lineage.graph.wait.explanation": "Este grafo está tardando más de lo esperado. Puedes seguir esperando o continuar trabajando mientras se genera en segundo plano.",
+    "lineage.graph.wait.failed": "No se ha podido completar la generación del grafo. Vuelve a intentarlo.",
+    "lineage.graph.wait.open": "Abrir grafo",
+    "lineage.graph.wait.waiting": "Esperando…"
+  }
+}

package/src/messages/en.js

@@ -195,35 +195,6 @@ export default {
   "joinType.left": "outer left",
   "joinType.right": "outer right",
   "joinType.full_outer": "full outer join",
-  "lineage.events.header": "My graphs",
-  "lineage.events.props.graph_data": "Graph",
-  "lineage.events.props.inserted_at": "Date",
-  "lineage.events.props.message": "Message",
-  "lineage.events.props.status": "Status",
-  "lineage.events.search.results.empty": "No graphs found",
-  "lineage.events.subheader": "Lineage graphs",
-  "lineage.form.header": "Select Structures",
-  "lineage.form.levels.all.label": "All",
-  "lineage.form.levels.header": "Levels",
-  "lineage.form.levels.select.input": "Select...",
-  "lineage.form.levels.select.label": "Depth",
-  "lineage.graph.loading": "Analyzing...",
-  "lineage.graph.loading.background.launched": "Background task launched",
-  "lineage.graph.loading.background.existing":
-    "The task for this graph was already launched",
-  "lineage.graph.loading.polling": "Poll retry #{retry}",
-  "lineage.graph.status.already_calculated": "Already calculated",
-  "lineage.graph.status.already_started": "Already started",
-  "lineage.graph.status.completed": "Completed",
-  "lineage.graph.status.failed": "Failed",
-  "lineage.graph.status.just_started": "Just started",
-  "lineage.graph.status.started": "Started",
-  "lineage.graph.status.timed_out": "Timed out",
-  "lineage.graph.metadata.header": "Information",
-  "lineage.graph.metadata.close.button": "Close",
-  "lineage.group.placeholder": "Select Top Level Structure",
-  "lineage.resources.placeholder": "Select Child Structures",
-  "lineage.subgroup.placeholder": "Select Child Structure",
   metadata: "Metadata",
   "metadataView.fields": "Available metadata fields",
   "metadataView.fields.placeholder":

package/src/messages/es.js

@@ -199,36 +199,6 @@ export default {
   "joinType.left": "outer left",
   "joinType.right": "outer right",
   "joinType.full_outer": "full outer join",
-  "lineage.events.header": "Mis grafos",
-  "lineage.events.props.graph_data": "Grafo",
-  "lineage.events.props.inserted_at": "Fecha",
-  "lineage.events.props.message": "Mensaje",
-  "lineage.events.props.status": "Estado",
-  "lineage.events.search.results.empty": "Ningún grafo encontrado",
-  "lineage.events.subheader": "Grafos de linaje",
-  "lineage.form.header": "Seleccionar Estructuras",
-  "lineage.form.levels.all.label": "Completo",
-  "lineage.form.levels.header": "Niveles",
-  "lineage.form.levels.select.input": "Seleccionar...",
-  "lineage.form.levels.select.label": "Profundidad",
-  "lineage.graph.loading": "Analizando...",
-  "lineage.graph.loading.background.launched":
-    "Tarea en segundo plano lanzada para grafo",
-  "lineage.graph.loading.background.existing":
-    "La tarea en segundo plano para este grafo ya fue lanzada",
-  "lineage.graph.loading.polling": "Sondeo #{retry}",
-  "lineage.graph.status.already_calculated": "Previamente calculado",
-  "lineage.graph.status.already_started": "Previamente iniciado",
-  "lineage.graph.status.completed": "Finalizado",
-  "lineage.graph.status.failed": "Fallido",
-  "lineage.graph.status.just_started": "Acaba de iniciarse",
-  "lineage.graph.status.started": "Iniciado",
-  "lineage.graph.status.timed_out": "Tiempo de espera máximo sobrepasado",
-  "lineage.graph.metadata.header": "Información",
-  "lineage.graph.metadata.close.button": "Cerrar",
-  "lineage.group.placeholder": "Seleccionar Estructura Padre",
-  "lineage.resources.placeholder": "Seleccionar Estructuras Hijos",
-  "lineage.subgroup.placeholder": "Seleccionar Estructura Hijo",
   metadata: "Metadata",
   "metadataView.fields": "Campos",
   "metadataView.fields.placeholder":

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

@@ -0,0 +1,113 @@
+import { graphGenerationState as reduce } from "../graphGenerationState";
+import {
+  backgroundGraph,
+  clearGraph,
+  graphGeneration,
+  fetchLineageEvents,
+} from "../../routines";
+
+test("a new request backgrounds the previous one and ignores unrelated events", () => {
+  let state = reduce(undefined, graphGeneration.request({ requestId: "a" }));
+  state = reduce(state, graphGeneration({ requestId: "a", hash: "hash-a" }));
+  state = reduce(state, graphGeneration.request({ requestId: "b" }));
+  state = reduce(
+    state,
+    fetchLineageEvents.success({
+      data: [{ graph_hash: "other", graph_id: 2, status: "COMPLETED" }],
+    }),
+  );
+  expect(state.jobs.a).toMatchObject({ status: "pending", background: true });
+  expect(state.jobs.b.background).toBe(false);
+});
+
+test("background completion matches a graph id, is stable and cannot be reverted by a late poll", () => {
+  let state = reduce(undefined, graphGeneration.request({ requestId: "a" }));
+  state = reduce(state, backgroundGraph());
+  state = reduce(
+    state,
+    graphGeneration.success({
+      requestId: "a",
+      graphId: 5,
+      status: "awaitingEvent",
+    }),
+  );
+  const complete = fetchLineageEvents.success({
+    data: [{ graph_id: 5, status: "COMPLETED" }],
+  });
+  state = reduce(state, complete);
+  expect(state.jobs.a.status).toBe("completed");
+  expect(reduce(state, complete)).toEqual(state);
+  expect(
+    reduce(
+      state,
+      graphGeneration.success({ requestId: "a", status: "awaitingEvent" }),
+    ),
+  ).toEqual(state);
+});
+
+test("failed events notify failure and completed events without an id cannot be opened", () => {
+  let state = reduce(undefined, graphGeneration.request({ requestId: "a" }));
+  state = reduce(state, graphGeneration({ requestId: "a", hash: "a" }));
+  state = reduce(state, backgroundGraph());
+  state = reduce(
+    state,
+    fetchLineageEvents.success({
+      data: [{ graph_hash: "a", status: "COMPLETED" }],
+    }),
+  );
+  expect(state.jobs.a.status).toBe("pending");
+  state = reduce(
+    state,
+    fetchLineageEvents.success({
+      data: [{ graph_hash: "a", status: "FAILED" }],
+    }),
+  );
+  expect(state.jobs.a.status).toBe("failed");
+});
+
+test.each([clearGraph(), backgroundGraph({ notify: false })])(
+  "implicit background and manual close do not enable notifications: %j",
+  (action) => {
+    let state = reduce(undefined, graphGeneration.request({ requestId: "a" }));
+    state = reduce(state, action);
+    expect(state.jobs.a.notify).toBe(false);
+  },
+);
+test("only an explicit background choice enables notifications", () => {
+  let state = reduce(undefined, graphGeneration.request({ requestId: "a" }));
+  state = reduce(state, graphGeneration.request({ requestId: "b" }));
+  expect(state.jobs.a.notify).not.toBe(true);
+  state = reduce(state, backgroundGraph());
+  expect(state.jobs.b.notify).toBe(true);
+});
+
+test("unrelated and repeated events preserve state and job references", () => {
+  let state = reduce(undefined, graphGeneration.request({ requestId: "a" }));
+  state = reduce(state, graphGeneration({ requestId: "a", hash: "a" }));
+  state = reduce(state, backgroundGraph());
+  expect(reduce(state, fetchLineageEvents.success({ data: [] }))).toBe(state);
+  const event = fetchLineageEvents.success({
+    data: [{ graph_hash: "a", graph_id: 5, status: "COMPLETED" }],
+  });
+  const completed = reduce(state, event);
+  expect(completed.jobs.a.status).toBe("completed");
+  expect(reduce(completed, event)).toBe(completed);
+});
+
+test("event indexing preserves the first match across graph id and hash", () => {
+  const state = {
+    active: "a",
+    jobs: { a: { graphId: 5, hash: "a", notify: true, status: "pending" } },
+  };
+  const next = reduce(
+    state,
+    fetchLineageEvents.success({
+      data: [
+        { graph_hash: "a", graph_id: 6, status: "COMPLETED" },
+        { graph_id: 5, status: "FAILED" },
+        { graph_hash: "a", graph_id: 7, status: "FAILED" },
+      ],
+    }),
+  );
+  expect(next.jobs.a).toMatchObject({ graphId: 6, status: "completed" });
+});

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 };

package/src/reducers/graphGenerationState.js

@@ -0,0 +1,113 @@
+import {
+  backgroundGraph,
+  clearGraph,
+  dismissGraphGeneration,
+  graphGeneration,
+  fetchLineageEvents,
+} from "../routines";
+import {
+  isCompletedStatus,
+  isFailedStatus,
+} from "../components/lineageEventHelpers";
+
+export const initialState = { active: null, jobs: {} };
+
+export const graphGenerationState = (
+  state = initialState,
+  { type, payload },
+) => {
+  const activeJob = state.jobs[state.active];
+  switch (type) {
+    case graphGeneration.REQUEST:
+      return {
+        active: payload.requestId,
+        jobs: {
+          ...Object.fromEntries(
+            Object.entries(state.jobs).filter(
+              ([, job]) =>
+                job.notify || (!job.background && job.status === "failed"),
+            ),
+          ),
+          ...(activeJob?.status === "pending"
+            ? { [state.active]: { ...activeJob, background: true } }
+            : {}),
+          [payload.requestId]: {
+            requestId: payload.requestId,
+            status: "pending",
+            background: false,
+          },
+        },
+      };
+    case backgroundGraph.TRIGGER:
+    case clearGraph.TRIGGER:
+      return activeJob?.status === "pending"
+        ? {
+            ...state,
+            jobs: {
+              ...state.jobs,
+              [state.active]: {
+                ...activeJob,
+                background: true,
+                notify:
+                  type === backgroundGraph.TRIGGER
+                    ? payload?.notify !== false
+                    : activeJob.notify === true,
+              },
+            },
+          }
+        : state;
+    case graphGeneration.TRIGGER:
+    case graphGeneration.SUCCESS:
+    case graphGeneration.FAILURE: {
+      const job = state.jobs[payload.requestId];
+      if (!job || ["completed", "failed"].includes(job.status)) return state;
+      return {
+        ...state,
+        jobs: { ...state.jobs, [payload.requestId]: { ...job, ...payload } },
+      };
+    }
+    case fetchLineageEvents.SUCCESS: {
+      const byId = new Map();
+      const byHash = new Map();
+      (payload.data || []).forEach((event, index) => {
+        const entry = { event, index };
+        if (event.graph_id != null && !byId.has(String(event.graph_id)))
+          byId.set(String(event.graph_id), entry);
+        if (event.graph_hash && !byHash.has(event.graph_hash))
+          byHash.set(event.graph_hash, entry);
+      });
+      const entries = Object.entries(state.jobs).map(([key, job]) => {
+        if (!job.notify || !["pending", "awaitingEvent"].includes(job.status))
+          return [key, job];
+        const idMatch =
+          job.graphId != null ? byId.get(String(job.graphId)) : undefined;
+        const hashMatch = job.hash ? byHash.get(job.hash) : undefined;
+        const event = (
+          idMatch && (!hashMatch || idMatch.index < hashMatch.index)
+            ? idMatch
+            : hashMatch
+        )?.event;
+        if (isFailedStatus(event?.status))
+          return [key, { ...job, status: "failed" }];
+        if (isCompletedStatus(event?.status) && event.graph_id != null)
+          return [
+            key,
+            { ...job, status: "completed", graphId: event.graph_id },
+          ];
+        return [key, job];
+      });
+      return entries.some(([key, job]) => state.jobs[key] !== job)
+        ? { ...state, jobs: Object.fromEntries(entries) }
+        : state;
+    }
+    case dismissGraphGeneration.TRIGGER:
+      return {
+        ...state,
+        jobs: Object.fromEntries(
+          Object.entries(state.jobs).filter(([key]) => key !== payload),
+        ),
+      };
+    default:
+      return state;
+  }
+};

package/src/reducers/graphLoading.js

@@ -1,4 +1,5 @@
 import {
+  backgroundGraph,
   clearGraph,
   clearStructure,
   createGraph,
@@ -10,6 +11,7 @@ import {
 
 export const graphLoading = (state = false, { type, payload }) => {
   switch (type) {
+    case backgroundGraph.TRIGGER:
     case clearGraph.TRIGGER:
       return false;
     case clearStructure.TRIGGER:

package/src/reducers/index.js

@@ -19,6 +19,7 @@ import { grantSelectedFilter } from "./grantSelectedFilter";
 import { grantsPageSize } from "./grantsPageSize";
 
 import { graph } from "./graph";
+import { graphGenerationState } from "./graphGenerationState";
 import { graphLoading } from "./graphLoading";
 import { graphRedirect } from "./graphRedirect";
 import { lineageEvents } from "./lineageEvents";
@@ -98,6 +99,7 @@ export {
   grantSelectedFilter,
   grantsPageSize,
   graph,
+  graphGenerationState,
   graphLoading,
   graphRedirect,
   lineageEvents,

package/src/routines.js

@@ -6,6 +6,7 @@ export const addStructureSelectedFilter = createRoutine(
   "ADD_STRUCTURE_SELECTED_FILTER",
 );
 export const applyUserSearchFilter = createRoutine("APPLY_USER_SEARCH_FILTER");
+export const backgroundGraph = createRoutine("BACKGROUND_GRAPH");
 export const bulkUpdateStructures = createRoutine("BULK_UPDATE_STRUCTURES");
 export const cancelPoll = createRoutine("CANCEL_POLL");
 export const checkoutGrantRequest = createRoutine("CHECKOUT_GRANT_REQUEST");
@@ -66,6 +67,7 @@ export const deleteTag = createRoutine("DELETE_TAG");
 export const deleteUserSearchFilter = createRoutine(
   "DELETE_USER_SEARCH_FILTER",
 );
+export const dismissGraphGeneration = createRoutine("DISMISS_GRAPH_GENERATION");
 export const doStructureNoteAction = createRoutine("DO_STRUCTURE_NOTE_ACTION");
 export const downloadCsvGraph = createRoutine("DOWNLOAD_CSV_GRAPH");
 export const downloadReferenceDataset = createRoutine(
@@ -104,6 +106,7 @@ export const fetchUserSearchFilters = createRoutine(
   "FETCH_USER_SEARCH_FILTERS",
 );
 export const filterStructures = createRoutine("FILTER_STRUCTURES");
+export const graphGeneration = createRoutine("GRAPH_GENERATION");
 export const hoverNode = createRoutine("HOVER_NODE");
 export const initSvg = createRoutine("INIT_SVG");
 export const linkStructureToStructure = createRoutine(