@truedat/dd 8.11.6 → 8.11.9

package/src/utils/__tests__/lineageGraphIndex.spec.js

@@ -0,0 +1,52 @@
+import {
+  createLineageGraphIndex,
+  focusLineageFromSeeds,
+  projectLineageNodeIds,
+} from "../lineageGraphIndex";
+
+describe("lineageGraphIndex", () => {
+  const nodes = ["a", "b", "c", "d"].map((id) => ({ id }));
+  const edges = [
+    { id: "ab", source: "a", target: "b" },
+    { id: "bc", source: "b", target: "c" },
+    { id: "cd", source: "c", target: "d" },
+  ];
+
+  it("keeps the complete upstream and downstream path", () => {
+    const focus = focusLineageFromSeeds(
+      new Set(["b"]),
+      createLineageGraphIndex(nodes, edges),
+    );
+
+    expect([...focus.focusedNodeIds]).toEqual(["b", "a", "c", "d"]);
+    expect([...focus.focusedEdgeIds]).toEqual(["ab", "bc", "cd"]);
+  });
+
+  it("uses all descendants of a selected box as focus seeds", () => {
+    const groupedNodes = [
+      { id: "box" },
+      { id: "b", parentId: "box" },
+      ...nodes.filter((node) => node.id !== "b"),
+    ];
+    const index = createLineageGraphIndex(groupedNodes, edges);
+    const seeds = new Set(["box", ...index.descendantIds("box")]);
+    const focus = focusLineageFromSeeds(seeds, index);
+
+    expect(focus.focusedEdgeIds).toEqual(new Set(["ab", "bc", "cd"]));
+  });
+
+  it("projects hidden focused nodes onto their visible collapsed ancestor", () => {
+    const parentById = new Map([
+      ["field", "table"],
+      ["table", "database"],
+    ]);
+
+    expect(
+      projectLineageNodeIds(
+        new Set(["field"]),
+        parentById,
+        new Set(["database"]),
+      ),
+    ).toEqual(new Set(["database"]));
+  });
+});

package/src/utils/__tests__/lineageLayout.spec.js

@@ -0,0 +1,252 @@
+const freshLayout = () => {
+  let layout;
+  jest.isolateModules(() => {
+    layout = require("../lineageLayout").layoutVisibleLineageGraph;
+  });
+  return layout;
+};
+const node = (id) => ({
+  id,
+  width: 288,
+  height: 82,
+  position: { x: 0, y: 0 },
+  data: { label: id },
+});
+const geometry = (nodes) =>
+  Object.fromEntries(nodes.map(({ id, data }) => [id, data.absoluteGeometry]));
+const crossings = (nodes, edges) => {
+  const byId = new Map(
+    nodes.map((item) => [item.id, item.data.absoluteGeometry]),
+  );
+  let count = 0;
+  edges.forEach((a, i) =>
+    edges.slice(i + 1).forEach((b) => {
+      const as = byId.get(a.source),
+        at = byId.get(a.target);
+      const bs = byId.get(b.source),
+        bt = byId.get(b.target);
+      if (as.x === bs.x && at.x === bt.x && (as.y - bs.y) * (at.y - bt.y) < 0)
+        count += 1;
+    }),
+  );
+  return count;
+};
+
+describe("lineage ordering with independent caches", () => {
+  it("keeps legacy Global Data fields in one column despite different dependency depths", () => {
+    const field = (id, parentId) => ({
+      ...node(id),
+      parentId,
+      height: 32,
+      data: { label: id, variant: "lineage-field" },
+    });
+    const nodes = [
+      node("powerbi"),
+      { ...node("source"), parentId: "powerbi" },
+      { ...node("global-data"), parentId: "powerbi" },
+      { ...node("dashboard"), parentId: "powerbi" },
+      field("source/country", "source"),
+      field("global-data/country", "global-data"),
+      field("global-data/region", "global-data"),
+      field("global-data/income", "global-data"),
+    ];
+    const edges = [
+      { source: "source/country", target: "global-data/country" },
+      { source: "global-data/country", target: "global-data/region" },
+      { source: "global-data/region", target: "dashboard" },
+      { source: "global-data/income", target: "dashboard" },
+    ];
+    const layout = freshLayout();
+    const first = layout({ nodes, edges });
+    const positions = geometry(first);
+    const fields = nodes.filter(({ parentId }) => parentId === "global-data");
+    expect(new Set(fields.map(({ id }) => positions[id].x)).size).toBe(1);
+    expect(new Set(fields.map(({ id }) => positions[id].y)).size).toBe(3);
+    expect(positions.source.x + positions.source.w).toBeLessThan(
+      positions["global-data"].x,
+    );
+    expect(
+      positions["global-data"].x + positions["global-data"].w,
+    ).toBeLessThan(positions.dashboard.x);
+    expect(
+      geometry(
+        layout({ nodes: [...nodes].reverse(), edges: [...edges].reverse() }),
+      ),
+    ).toEqual(positions);
+    expect(
+      geometry(
+        layout({
+          nodes,
+          edges,
+          previousLayout: first,
+          anchorNodeId: "global-data",
+        }),
+      ),
+    ).toEqual(positions);
+  });
+
+  it("keeps equal neighbour scores stable in fresh, warm and permuted layouts", () => {
+    const nodes = ["a", "b", "c", "d"].map(node);
+    const edges = [
+      { source: "a", target: "c" },
+      { source: "a", target: "d" },
+      { source: "b", target: "c" },
+      { source: "b", target: "d" },
+    ];
+    const layout = freshLayout();
+    const first = layout({ nodes, edges });
+    const warm = layout({
+      nodes: [...nodes].reverse(),
+      edges: [...edges].reverse(),
+    });
+    const cold = freshLayout()({
+      nodes: [...nodes].reverse(),
+      edges: [...edges].reverse(),
+    });
+    expect(geometry(first)).toEqual(geometry(warm));
+    expect(geometry(first)).toEqual(geometry(cold));
+    expect(geometry(first).a.y).toBeLessThan(geometry(first).b.y);
+    expect(geometry(first).c.y).toBeLessThan(geometry(first).d.y);
+    expect(crossings(first, edges)).toBe(1);
+  });
+
+  it("propagates the ordering through successive columns without avoidable crossings", () => {
+    const nodes = ["a", "b", "c", "d", "e", "f", "g", "h"].map(node);
+    const edges = [
+      { source: "a", target: "d" },
+      { source: "b", target: "c" },
+      { source: "c", target: "f" },
+      { source: "d", target: "e" },
+      { source: "e", target: "h" },
+      { source: "f", target: "g" },
+    ];
+    const first = freshLayout()({ nodes, edges });
+    const permuted = freshLayout()({
+      nodes: [...nodes].reverse(),
+      edges: [...edges].reverse(),
+    });
+    expect(crossings(first, edges)).toBe(0);
+    expect(geometry(first)).toEqual(geometry(permuted));
+  });
+
+  it("keeps cached topology while applying changed dimensions and anchoring", () => {
+    const layout = freshLayout();
+    const nodes = [node("a"), node("b")];
+    const edges = [{ source: "a", target: "b" }];
+    const previousLayout = layout({ nodes, edges });
+    const expanded = layout({
+      nodes: [nodes[0], { ...nodes[1], height: 320 }],
+      edges,
+      previousLayout,
+      anchorNodeId: "b",
+    });
+    expect(geometry(expanded).b.h).toBe(320);
+    expect(geometry(expanded).b.x).toBe(geometry(previousLayout).b.x);
+    expect(geometry(expanded).b.y).toBe(geometry(previousLayout).b.y);
+    expect(layout({ nodes: [], edges })).toEqual([]);
+  });
+});
+
+describe("compound root columns", () => {
+  const compoundNode = (id) => ({
+    ...node(id),
+    data: { label: id, topology: true },
+  });
+
+  it("stacks parallel roots and converges in the next column", () => {
+    const nodes = ["a", "b", "c", "d"].map(compoundNode);
+    const edges = [
+      { source: "a", target: "c" },
+      { source: "b", target: "c" },
+      { source: "c", target: "d" },
+    ];
+    const positions = geometry(freshLayout()({ nodes, edges }));
+    expect(positions.a.x).toBe(positions.b.x);
+    expect(positions.b.y).toBe(positions.a.y + positions.a.h + 44);
+    expect(positions.c.x).toBe(positions.a.x + positions.a.w + 152);
+    expect(positions.d.x).toBe(positions.c.x + positions.c.w + 152);
+    expect(positions.c.y).toBe(positions.a.y);
+    expect(
+      geometry(
+        freshLayout()({
+          nodes: [...nodes].reverse(),
+          edges: [...edges].reverse(),
+        }),
+      ),
+    ).toEqual(positions);
+  });
+
+  it("packs cycles and disconnected roots without overlaps", () => {
+    const nodes = ["a", "b", "isolated"].map(compoundNode);
+    const edges = [
+      { source: "a", target: "b" },
+      { source: "b", target: "a" },
+    ];
+    const positions = Object.values(geometry(freshLayout()({ nodes, edges })));
+    expect(new Set(positions.map(({ x }) => x)).size).toBe(1);
+    positions.slice(1).forEach((current, i) => {
+      expect(current.y).toBeGreaterThanOrEqual(
+        positions[i].y + positions[i].h + 44,
+      );
+    });
+  });
+
+  it("keeps compound blocks contained and preserves an expanded root anchor", () => {
+    const fields = Array.from({ length: 17 }, (_, i) => ({
+      ...node(`global/field-${String(i).padStart(2, "0")}`),
+      parentId: "global",
+      height: 32,
+      data: { variant: "lineage-field" },
+    }));
+    const roots = [
+      compoundNode("global"),
+      compoundNode("peer"),
+      compoundNode("sink"),
+    ];
+    const edges = [
+      { source: "global", target: "sink" },
+      { source: "peer", target: "sink" },
+    ];
+    const layout = freshLayout();
+    const collapsed = layout({ nodes: roots, edges });
+    const expanded = geometry(
+      layout({
+        nodes: [...roots, ...fields],
+        edges,
+        previousLayout: collapsed,
+        anchorNodeId: "peer",
+      }),
+    );
+    expect(expanded.peer.x).toBe(geometry(collapsed).peer.x);
+    expect(expanded.peer.y).toBe(geometry(collapsed).peer.y);
+    expect(expanded.peer.y).toBeGreaterThanOrEqual(
+      expanded.global.y + expanded.global.h + 44,
+    );
+    expect(new Set(fields.map(({ id }) => expanded[id].x)).size).toBe(1);
+    fields.forEach(({ id }) => {
+      expect(expanded[id].y).toBeGreaterThan(expanded.global.y);
+      expect(expanded[id].y + expanded[id].h).toBeLessThan(
+        expanded.global.y + expanded.global.h,
+      );
+    });
+    expect(expanded.sink.x).toBe(expanded.global.x + expanded.global.w + 152);
+  });
+});
+
+it.each([undefined, "lineage-field"])(
+  "leaves only bottom padding after the last child (%s)",
+  (variant) => {
+    const nodes = [
+      { ...node("group"), type: "lineageGroup" },
+      {
+        ...node("child"),
+        parentId: "group",
+        data: { label: "child", variant },
+      },
+    ];
+    const result = geometry(freshLayout()({ nodes, edges: [] }));
+    expect(
+      result.group.y + result.group.h - result.child.y - result.child.h,
+    ).toBe(12);
+  },
+);

package/src/utils/__tests__/lineageTopology.spec.js

@@ -0,0 +1,256 @@
+import {
+  prepareLineageTopology,
+  createLineageGraphIndex,
+  focusLineageFromSeeds,
+  projectLineageNodeIds,
+} from "../lineageGraphIndex";
+import { layoutVisibleLineageGraph } from "../lineageLayout";
+import {
+  lineageTopologyNodes,
+  lineageEdge,
+  collapseLineageNodes,
+  aggregateCollapsedEdges,
+} from "../../components/LineageGraph";
+
+// Synthetic multi-stage lineage with nested containers and Glue field aliases.
+// Keep this fixture self-contained so CI never depends on a local data export.
+const stages = [
+  ["source", "Source Economy", "ds_a_raw_economy"],
+  ["prepared", "Global Data", "ds_a2_prepared_economy"],
+  ["user", "User Economy", "ds_a3_user_economy"],
+];
+const fieldId = (table, field, alias = false) =>
+  alias
+    ? `https://glue.eu-west-1.amazonaws.com/#/Glue/${table}/${field}`
+    : `glue:/Glue/${table}/${field}`;
+const nodes = [
+  ...stages.flatMap(([id, name, table]) => [
+    { id, name, class: "Group" },
+    { id: table, name: table, class: "Resource" },
+    ...["country", "region"].flatMap((field) => [
+      { id: fieldId(table, field), name: field, class: "Resource" },
+      { id: fieldId(table, field, true), name: field, class: "Resource" },
+    ]),
+  ]),
+  { id: "dashboard", name: "Dashboard Country VS Region", class: "Resource" },
+];
+const contains = stages.flatMap(([id, , table]) => [
+  { source: id, target: table },
+  ...["country", "region"].flatMap((field) => [
+    { source: table, target: fieldId(table, field) },
+    { source: table, target: fieldId(table, field, true) },
+  ]),
+]);
+const depends = stages.flatMap(([, , table], index) =>
+  ["country", "region"].flatMap((field) =>
+    [false, true].map((alias) => ({
+      source: fieldId(table, field, alias),
+      target:
+        index < stages.length - 1
+          ? fieldId(stages[index + 1][2], field, alias)
+          : "dashboard",
+    })),
+  ),
+);
+const topology = { nodes, contains, depends };
+const prepared = prepareLineageTopology(topology);
+const rendered = lineageTopologyNodes(prepared);
+const renderedById = new Map(rendered.map((node) => [node.id, node]));
+const edges = prepared.edges.map(
+  lineageEdge(
+    () => {},
+    (id) => id,
+    renderedById,
+  ),
+);
+const geometry = (laid) =>
+  Object.fromEntries(laid.map(({ id, data }) => [id, data.absoluteGeometry]));
+
+describe("explicit lineage topology", () => {
+  it("preserves all original identities and all dependencies from the synthetic topology", () => {
+    expect(topology.nodes).toHaveLength(19);
+    expect(contains).toHaveLength(15);
+    expect(depends).toHaveLength(12);
+    expect(prepared.nodeById.size).toBe(19);
+    expect(prepared.originalToVisibleId.size).toBe(19);
+    expect(prepared.nodes).toHaveLength(13);
+    expect(
+      prepared.nodes.filter((node) => node.originals.length === 2),
+    ).toHaveLength(6);
+    expect(
+      prepared.edges.map(({ originalSource, originalTarget }) => [
+        originalSource,
+        originalTarget,
+      ]),
+    ).toEqual(depends.map(({ source, target }) => [source, target]));
+    expect(edges.filter(Boolean)).toHaveLength(12);
+    expect(prepared.nodes.filter((node) => node.field)).toHaveLength(6);
+  });
+
+  it("renders the dashboard as one entity without fabricated fields or types", () => {
+    const dashboard = prepared.nodes.find(
+      ({ name }) => name === "Dashboard Country VS Region",
+    );
+    expect(dashboard.field).toBe(false);
+    expect(dashboard.container).toBe(false);
+    expect(
+      prepared.edges.filter(({ target }) => target === dashboard.id),
+    ).toHaveLength(4);
+    expect(renderedById.get(dashboard.id).data.fields).toEqual([]);
+    expect(renderedById.get(dashboard.id).data.entityType).toBe("");
+  });
+
+  it("does not reverse normalized dependencies in traceability", () => {
+    const traced = prepared.edges.map(
+      lineageEdge(
+        () => {},
+        (id) => id,
+        renderedById,
+        "lineage",
+      ),
+    );
+    expect(traced.map(({ source, target }) => [source, target])).toEqual(
+      edges.map(({ source, target }) => [source, target]),
+    );
+  });
+
+  it("stacks fields inside their entity and packs all sibling containers without overlaps", () => {
+    const laid = layoutVisibleLineageGraph({ nodes: rendered, edges });
+    const byId = geometry(laid);
+    laid.forEach((node) => {
+      const box = byId[node.id];
+      expect(Object.values(box).every(Number.isFinite)).toBe(true);
+      if (node.parentId) {
+        const parent = byId[node.parentId];
+        expect(box.x).toBeGreaterThanOrEqual(parent.x);
+        expect(box.y).toBeGreaterThanOrEqual(parent.y + 58);
+        expect(box.x + box.w).toBeLessThanOrEqual(parent.x + parent.w);
+        expect(box.y + box.h).toBeLessThanOrEqual(parent.y + parent.h - 12);
+      }
+      laid
+        .filter(
+          (sibling) =>
+            sibling.parentId === node.parentId && sibling.id !== node.id,
+        )
+        .forEach((sibling) => {
+          const other = byId[sibling.id];
+          expect(
+            box.x < other.x + other.w &&
+              other.x < box.x + box.w &&
+              box.y < other.y + other.h &&
+              other.y < box.y + box.h,
+          ).toBe(false);
+          if (
+            node.data.variant === "lineage-field" &&
+            sibling.data.variant === "lineage-field"
+          )
+            expect(box.x).toBe(other.x);
+        });
+    });
+    const named = (name) =>
+      byId[prepared.nodes.find((node) => node.name === name).id];
+    expect(named("ds_a_raw_economy").x).toBeLessThan(
+      named("ds_a2_prepared_economy").x,
+    );
+    expect(named("ds_a2_prepared_economy").x).toBeLessThan(
+      named("ds_a3_user_economy").x,
+    );
+    expect(named("Source Economy").x).toBeLessThan(named("Global Data").x);
+    expect(named("Global Data").x).toBeLessThan(
+      named("Dashboard Country VS Region").x,
+    );
+    const permuted = prepareLineageTopology({
+      nodes: [...topology.nodes].reverse(),
+      contains: [...contains].reverse(),
+      depends: [...depends].reverse(),
+    });
+    const permutedNodes = lineageTopologyNodes(permuted);
+    expect(
+      geometry(
+        layoutVisibleLineageGraph({
+          nodes: permutedNodes,
+          edges: permuted.edges,
+        }),
+      ),
+    ).toEqual(byId);
+  });
+
+  it("retains dependency identities when fields are hidden and keeps an expanded anchor", () => {
+    const previousLayout = layoutVisibleLineageGraph({
+      nodes: rendered,
+      edges,
+    });
+    const tableId = "ds_a_raw_economy";
+    const collapsed = collapseLineageNodes(
+      rendered,
+      new Set([tableId]),
+      () => {},
+    );
+    const visibleEdges = aggregateCollapsedEdges(edges, rendered, collapsed);
+    expect(
+      new Set(visibleEdges.flatMap((edge) => edge.data.originalEdgeIds)).size,
+    ).toBe(12);
+    const laid = layoutVisibleLineageGraph({
+      nodes: collapsed,
+      edges: visibleEdges,
+      previousLayout,
+      anchorNodeId: tableId,
+    });
+    expect(geometry(laid)[tableId].x).toBe(geometry(previousLayout)[tableId].x);
+    expect(geometry(laid)[tableId].y).toBe(geometry(previousLayout)[tableId].y);
+  });
+
+  it("focuses original aliases without creating false paths through the shared row", () => {
+    const pair = prepared.nodes.find((node) => node.originals.length === 2);
+    const [a, b] = pair.originals.map(({ id }) => id);
+    const index = createLineageGraphIndex(
+      [{ id: "in" }, { id: a }, { id: b }, { id: "out" }],
+      [
+        { id: "e1", source: "in", target: a },
+        { id: "e2", source: b, target: "out" },
+      ],
+    );
+    expect(focusLineageFromSeeds(["in"], index).focusedEdgeIds).toEqual(
+      new Set(["e1"]),
+    );
+    const focus = focusLineageFromSeeds([a, b], index);
+    expect(focus.focusedEdgeIds).toEqual(new Set(["e1", "e2"]));
+    expect(
+      projectLineageNodeIds(
+        focus.focusedNodeIds,
+        new Map(),
+        new Set([pair.id, "in", "out"]),
+        prepared.originalToVisibleId,
+      ),
+    ).toEqual(new Set([pair.id, "in", "out"]));
+  });
+
+  it("rejects invalid containment and keeps same-named resources with unrelated IDs separate", () => {
+    expect(prepareLineageTopology(undefined)).toBeUndefined();
+    const data = {
+      nodes: [
+        { id: "a", class: "Group" },
+        { id: "b", name: "same", class: "Resource" },
+        { id: "c", name: "same", class: "Resource" },
+      ],
+      contains: [
+        { source: "a", target: "b" },
+        { source: "a", target: "c" },
+      ],
+      depends: [],
+    };
+    expect(prepareLineageTopology(data).nodes).toHaveLength(3);
+    expect(
+      prepareLineageTopology({
+        ...data,
+        contains: [...data.contains, { source: "b", target: "a" }],
+      }),
+    ).toBeUndefined();
+    expect(
+      prepareLineageTopology({
+        ...data,
+        depends: [{ source: "b", target: "missing" }],
+      }),
+    ).toBeUndefined();
+  });
+});