@truedat/dd 8.10.2 → 8.10.3

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

@@ -1,52 +1,28 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`<LineageRoutes /> renders correctly with GRAPH route 1`] = `
-<div>
-  <div>
-    LineageForm
-  </div>
-  <div>
-    GraphRedirector
-  </div>
-  <div>
-    LineageGraph
-  </div>
-  <div>
-    GraphLoader
-  </div>
-</div>
-`;
-
 exports[`<LineageRoutes /> renders correctly with GRAPHS route 1`] = `
 <div>
-  <div>
-    LineageForm
-  </div>
-  <div>
-    GraphRedirector
-  </div>
-  <div>
-    LineageGraph
-  </div>
-</div>
-`;
-
-exports[`<LineageRoutes /> renders correctly with LINEAGE_EVENTS route 1`] = `
-<div>
-  <div>
-    LineageEvents
-  </div>
-</div>
-`;
-
-exports[`<LineageRoutes /> renders correctly with SAMPLE route 1`] = `
-<div>
-  <div>
-    LineageSample
+  <div
+    class="ui icon visible bottom attached message center"
+  >
+    <i
+      aria-hidden="true"
+      class="warning sign icon"
+    />
+    <div
+      class="content"
+    >
+      <div
+        class="header"
+      >
+        view.unauthorized.head
+      </div>
+      <p>
+        view.unauthorized.content
+      </p>
+    </div>
   </div>
 </div>
 `;
 
 exports[`<LineageRoutes /> renders correctly with default route 1`] = `<div />`;
-
-exports[`<LineageRoutes /> renders unauthorized component when not authorized 1`] = `<div />`;

package/src/components/index.js

@@ -12,6 +12,12 @@ import LineageDownloadButton from "./LineageDownloadButton";
 import LineageGroup from "./LineageGroup";
 import LineageLink from "./LineageLink";
 import LineageRoutes from "./LineageRoutes";
+import LineageHeader from "./LineageHeader";
+import LineageEventsPanel from "./LineageEventsPanel";
+import LineageSelectionPanel from "./LineageSelectionPanel";
+import Graphs from "./Graphs";
+import { LineageResourceToggle } from "./LineageResourceToggle";
+import LineageDomainSelectorSkeleton from "./LineageDomainSelectorSkeleton";
 import StructureCrumbs from "./StructureCrumbs";
 import StructureEvents from "./StructureEvents";
 import StructureFieldRow from "./StructureFieldRow";
@@ -66,6 +72,12 @@ export {
   LineageGroup,
   LineageLink,
   LineageRoutes,
+  LineageHeader,
+  LineageEventsPanel,
+  LineageSelectionPanel,
+  Graphs,
+  LineageResourceToggle,
+  LineageDomainSelectorSkeleton,
   StructureCrumbs,
   StructureEvents,
   StructureFieldRow,

package/src/components/lineageDomainCache.js

@@ -0,0 +1,101 @@
+import _ from "lodash/fp";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { API_NODES } from "../api";
+
+export const LINEAGE_DOMAIN_CACHE_KEY = "truedat.lineage.domains";
+export const LINEAGE_DOMAIN_AVAILABILITY_CACHE_KEY =
+  "truedat.lineage.domainAvailability";
+export const LINEAGE_DOMAIN_CACHE_TTL = 60 * 1000;
+
+const DOMAIN_AVAILABILITY_CONCURRENCY = 4;
+
+const hasLineageNodes = (nodes = []) => {
+  if (_.isEmpty(nodes)) return false;
+
+  const hasVisibleNodes = _.some(
+    (node) => !_.isEmpty(node.groups) || !_.isEmpty(node.resources),
+  )(nodes);
+  const hasOnlyExplicitEmptyNodes = _.every(
+    (node) =>
+      (_.has("groups")(node) || _.has("resources")(node)) &&
+      _.isEmpty(node.groups) &&
+      _.isEmpty(node.resources),
+  )(nodes);
+
+  return hasVisibleNodes || !hasOnlyExplicitEmptyNodes;
+};
+
+const checkDomainLineage = async ({ id }) => {
+  try {
+    const { data = [] } = await apiJson(
+      `${API_NODES}?domain_id=${encodeURIComponent(id)}`,
+      JSON_OPTS,
+    );
+
+    return [`${id}`, hasLineageNodes(data)];
+  } catch (_error) {
+    return [`${id}`, true];
+  }
+};
+
+export const checkDomainsLineage = async (domains = []) => {
+  const results = [];
+
+  const chunkCount = Math.ceil(
+    domains.length / DOMAIN_AVAILABILITY_CONCURRENCY,
+  );
+
+  for (const chunkIndex of Array.from({ length: chunkCount }, (_, i) => i)) {
+    const start = chunkIndex * DOMAIN_AVAILABILITY_CONCURRENCY;
+    const chunk = domains.slice(start, start + DOMAIN_AVAILABILITY_CONCURRENCY);
+    const chunkResults = await Promise.all(chunk.map(checkDomainLineage));
+
+    results.push(...chunkResults);
+  }
+
+  return results;
+};
+
+const domainIdsSignature = (domains = []) =>
+  domains
+    .map(({ id }) => `${id}`)
+    .sort()
+    .join("|");
+
+export const readDomainAvailabilityCache = (domains = []) => {
+  if (typeof localStorage === "undefined") return null;
+
+  try {
+    const cached = JSON.parse(
+      localStorage.getItem(LINEAGE_DOMAIN_AVAILABILITY_CACHE_KEY),
+    );
+
+    if (!cached?.expiresAt || cached.expiresAt <= Date.now()) {
+      localStorage.removeItem(LINEAGE_DOMAIN_AVAILABILITY_CACHE_KEY);
+      return null;
+    }
+
+    if (
+      (cached.domainIds || []).sort().join("|") !== domainIdsSignature(domains)
+    )
+      return null;
+
+    return cached.checks || null;
+  } catch (_error) {
+    localStorage.removeItem(LINEAGE_DOMAIN_AVAILABILITY_CACHE_KEY);
+    return null;
+  }
+};
+
+export const writeDomainAvailabilityCache = (domains = [], checks = []) => {
+  if (typeof localStorage === "undefined") return;
+
+  localStorage.setItem(
+    LINEAGE_DOMAIN_AVAILABILITY_CACHE_KEY,
+    JSON.stringify({
+      checks,
+      domainIds: domains.map(({ id }) => `${id}`),
+      expiresAt: Date.now() + LINEAGE_DOMAIN_CACHE_TTL,
+    }),
+  );
+};

package/src/components/lineageEventHelpers.js

@@ -0,0 +1,195 @@
+const isCompletedStatus = (status) =>
+  ["completed", "finalizado", "success", "succeeded"].includes(
+    `${status || ""}`.toLowerCase(),
+  );
+
+const isFailedStatus = (status) =>
+  ["failed", "fallido", "error"].includes(`${status || ""}`.toLowerCase());
+
+const parseGraphData = (graphData) => {
+  if (!graphData) return null;
+  if (typeof graphData !== "string") return graphData;
+
+  try {
+    return JSON.parse(graphData);
+  } catch (_error) {
+    return graphData;
+  }
+};
+
+const uniqueSortedStrings = (values = []) =>
+  [...new Set(values.map((value) => `${value}`))].sort();
+
+const graphDataOrderedNodes = (graphData) => {
+  const parsedGraphData = parseGraphData(graphData);
+
+  if (Array.isArray(parsedGraphData))
+    return parsedGraphData.map((node) => `${node}`);
+  if (parsedGraphData?.ids) {
+    return parsedGraphData.ids.map((node) => `${node}`);
+  }
+  if (parsedGraphData?.nodes) {
+    return parsedGraphData.nodes.map((node) => `${node}`);
+  }
+  if (parsedGraphData?.resources) {
+    return parsedGraphData.resources.map((node) => `${node}`);
+  }
+
+  return parsedGraphData
+    ? [
+        typeof parsedGraphData === "string"
+          ? parsedGraphData
+          : JSON.stringify(parsedGraphData),
+      ]
+    : [];
+};
+
+const graphDataNodes = (graphData) => {
+  return uniqueSortedStrings(graphDataOrderedNodes(graphData));
+};
+
+const eventTimestamp = (event = {}) => {
+  const timestamp = Date.parse(event.inserted_at);
+
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+};
+
+const newestEvent = (left, right) =>
+  eventTimestamp(right) >= eventTimestamp(left) ? right : left;
+
+const lineageEventType = (event = {}) => {
+  const parsedGraphData = parseGraphData(event.graph_data);
+  const type =
+    event.type ||
+    event.graph_type ||
+    event.graph_kind ||
+    event.opts?.type ||
+    parsedGraphData?.type ||
+    parsedGraphData?.opts?.type;
+
+  return `${type || "lineage"}`.toLowerCase() === "impact"
+    ? "impact"
+    : "lineage";
+};
+
+export const lineageEventGroupKey = (event = {}) => {
+  const nodes = graphDataNodes(event.graph_data);
+
+  return nodes.length ? nodes.join("|") : `${event.graph_id || event.id || ""}`;
+};
+
+export const groupLineageEvents = (events = []) => {
+  const groupedEvents = events.reduce((groups, event) => {
+    const key = lineageEventGroupKey(event);
+    const type = lineageEventType(event);
+    const group = groups[key] || {
+      key,
+      nodes: graphDataNodes(event.graph_data),
+      eventsByType: {},
+    };
+    const currentEvent = group.eventsByType[type];
+
+    return {
+      ...groups,
+      [key]: {
+        ...group,
+        eventsByType: {
+          ...group.eventsByType,
+          [type]: currentEvent ? newestEvent(currentEvent, event) : event,
+        },
+      },
+    };
+  }, {});
+
+  return Object.values(groupedEvents).sort((left, right) => {
+    const leftLastEvent = Object.values(left.eventsByType).reduce(newestEvent);
+    const rightLastEvent = Object.values(right.eventsByType).reduce(
+      newestEvent,
+    );
+
+    return eventTimestamp(rightLastEvent) - eventTimestamp(leftLastEvent);
+  });
+};
+
+const graphLabel = (event, index) =>
+  event.graph_id
+    ? `#${event.graph_id}`
+    : event.id
+      ? `#${event.id}`
+      : `#${index + 1}`;
+
+const graphScope = (graphData) => {
+  const parsedGraphData = parseGraphData(graphData);
+
+  if (!parsedGraphData) return "";
+  if (Array.isArray(parsedGraphData)) return parsedGraphData.join(" -> ");
+  if (typeof parsedGraphData === "string") return parsedGraphData;
+  return JSON.stringify(parsedGraphData);
+};
+
+const graphDomain = (event) => {
+  const parsedGraphData = parseGraphData(event.graph_data);
+
+  return (
+    event.domain?.name ||
+    event.domain_name ||
+    event.domain ||
+    parsedGraphData?.domain?.name ||
+    parsedGraphData?.domain_name ||
+    parsedGraphData?.domain ||
+    ""
+  );
+};
+
+const graphFirstLevel = (event) => {
+  const parsedGraphData = parseGraphData(event.graph_data);
+  const nodes = graphDataOrderedNodes(event.graph_data);
+
+  return (
+    event.first_level ||
+    event.firstLevel ||
+    event.level_name ||
+    parsedGraphData?.first_level ||
+    parsedGraphData?.firstLevel ||
+    parsedGraphData?.level_name ||
+    nodes[0] ||
+    ""
+  );
+};
+
+const graphTypeMessageId = (type) =>
+  type === "impact"
+    ? "navigation.lineage.impact"
+    : "navigation.lineage.lineage";
+
+const graphTypeIcon = (type) => (type === "impact" ? "bullseye" : "sitemap");
+
+const eventErrorMessage = (event) =>
+  [
+    event.message,
+    event.error,
+    event.error_message,
+    event.errors,
+    event.reason,
+  ].reduce((message, value) => {
+    if (message || !value) return message;
+    return typeof value === "string" ? value : JSON.stringify(value);
+  }, null);
+
+export {
+  isCompletedStatus,
+  isFailedStatus,
+  parseGraphData,
+  graphDataOrderedNodes,
+  graphDataNodes,
+  eventTimestamp,
+  newestEvent,
+  lineageEventType,
+  graphLabel,
+  graphScope,
+  graphDomain,
+  graphFirstLevel,
+  graphTypeMessageId,
+  graphTypeIcon,
+  eventErrorMessage,
+};