fix: require an identity function when deserializing a graph whose nodes are objects

Author: JesusTheHun

src/utils/deserializeGraph.spec.ts

@@ -1,34 +1,66 @@
-import { describe, expectTypeOf, it } from 'vitest';
+import { describe, expectTypeOf, it, expect } from 'vitest';
 import { Graph } from '../Graph.js';
 import { checkSerialized } from '../test-utils.js';
+import { Serialized } from '../types.js';
 import { deserializeGraph } from './deserializeGraph.js';
 import { serializeGraph } from './serializeGraph.js';
 
 describe('serializeGraph', () => {
-  it('Should deserialize a graph.', function () {
+  it('should deserialize a graph', () => {
     const g = new Graph<string>().addEdge('a', 'b').addEdge('b', 'c');
     const serialized = serializeGraph(g);
 
     const graph = deserializeGraph(serialized);
     checkSerialized(serializeGraph(graph));
   });
 
-  it('Should deserialize a graph passed to constructor.', function () {
+  it('should deserialize a graph passed to constructor', () => {
     const g = new Graph<string>().addEdge('a', 'b').addEdge('b', 'c');
     const serialized = serializeGraph(g);
     const graph = new Graph(serialized);
     checkSerialized(serializeGraph(graph));
   });
 
-  it.skip('should return a graph with type inferred from the input', function () {
-    const nodeA = { title: 'a' };
-    const nodeB = { title: 'b' };
+  it('should not duplicate nodes when they are objects', () => {
+    const nodeA = { id: 1, title: 'a' };
+    const nodeB = { id: 2, title: 'b' };
+
+    const stringData = JSON.stringify({
+      nodes: [nodeA, nodeB],
+      links: [{ source: nodeA, target: nodeB, props: { type: 'foo' } }],
+    });
+
+    const serializedGraph: Serialized<{ id: number; title: string }, { type: string }> =
+      JSON.parse(stringData);
+
+    const graph = deserializeGraph(serializedGraph, (n) => n.id);
+
+    expect(graph.nodes).toHaveLength(2);
+  });
+
+  it.skip('should return a graph with type inferred from the input', () => {
+    const nodeA = { id: 1, title: 'a' };
+    const nodeB = { id: 2, title: 'b' };
+    const serialized = {
+      nodes: [nodeA, nodeB],
+      links: [{ source: nodeA, target: nodeB, props: { type: 'foo' } }],
+    };
+
+    const graph = deserializeGraph(serialized, (n) => n.id);
+    expectTypeOf(graph).toEqualTypeOf<
+      Graph<{ id: number; title: string }, { type: string }>
+    >();
+  });
+
+  it.skip('should require an identity function when nodes are objects', () => {
+    const nodeA = { id: 1, title: 'a' };
+    const nodeB = { id: 2, title: 'b' };
     const serialized = {
       nodes: [nodeA, nodeB],
       links: [{ source: nodeA, target: nodeB, props: { type: 'foo' } }],
     };
 
+    // @ts-expect-error Missing identity function
     const graph = deserializeGraph(serialized);
-    expectTypeOf(graph).toEqualTypeOf<Graph<{ title: string }, { type: string }>>();
   });
 });

src/utils/deserializeGraph.ts

@@ -1,17 +1,35 @@
 import { Graph } from '../Graph.js';
 import { SerializedInput } from '../types.js';
 
-export function deserializeGraph<Node, LinkProps>(
-  data: SerializedInput<Node, LinkProps>,
+export function deserializeGraph<Node, LinkProps, NodeIdentity>(
+  ...args: Node extends object
+    ? [data: SerializedInput<Node, LinkProps>, identityFn: (node: Node) => NodeIdentity]
+    : [data: SerializedInput<Node, LinkProps>]
 ): Graph<Node, LinkProps> {
+  const [data, identityFn] = args;
+
   const g = new Graph<Node, LinkProps>();
 
+  const nodeIdentityMap = new Map<NodeIdentity, Node>();
+
   data.nodes.forEach((node) => {
     g.addNode(node);
+
+    if (identityFn) {
+      nodeIdentityMap.set(identityFn(node), node);
+    }
   });
 
   data.links.forEach((link) => {
-    g.addEdge.apply(g, [link.source, link.target, link.weight, link.props] as never);
+    if (!identityFn) {
+      g.addEdge.apply(g, [link.source, link.target, link.weight, link.props] as never);
+      return;
+    }
+
+    const source = nodeIdentityMap.get(identityFn(link.source)) ?? link.source;
+    const target = nodeIdentityMap.get(identityFn(link.source)) ?? link.target;
+
+    g.addEdge.apply(g, [source, target, link.weight, link.props] as never);
   });
 
   return g;