feat: improve Ipld types and methods

Author: tchardin

src/graphsync.ts

@@ -20,13 +20,18 @@ import {
   decodeMessage,
   newRequest,
 } from "./messages.js";
+import {
+  BasicNode,
+  walkBlocks,
+  parseContext,
+  unixfsReifier,
+} from "./traversal.js";
 import type {
+  NodeReifier,
+  KnownReifiers,
   SelectorNode,
   Blockstore,
-  KnownReifiers,
-  NodeReifier,
 } from "./traversal.js";
-import {Node, walkBlocks, parseContext, unixfsReifier} from "./traversal.js";
 import {responseBuilder} from "./response-builder.js";
 
 export class GraphSync extends EventEmitter {
@@ -183,7 +188,7 @@ export class Request extends EventEmitter {
   async drain() {
     await drain(
       walkBlocks(
-        new Node(this.root),
+        new BasicNode(this.root),
         parseContext().parseSelector(this.selector),
         this
       )
@@ -194,6 +199,10 @@ export class Request extends EventEmitter {
     return this.reifiers[name];
   }
 
+  addReifier(name: string, reifier: NodeReifier) {
+    this.reifiers[name] = reifier;
+  }
+
   // TODO
   close() {}
 

src/resolver.ts

@@ -5,7 +5,7 @@ import {multiaddr, Multiaddr} from "@multiformats/multiaddr";
 import type {PeerId} from "@libp2p/interface-peer-id";
 import {
   allSelector,
-  Node,
+  BasicNode,
   Kind,
   LinkLoader,
   parseContext,
@@ -82,7 +82,7 @@ export async function* resolve(
   loader: LinkLoader
 ): AsyncIterable<Uint8Array> {
   for await (const blk of walkBlocks(
-    new Node(root),
+    new BasicNode(root),
     parseContext().parseSelector(selector),
     loader
   )) {

src/response-builder.ts

@@ -14,7 +14,7 @@ import {
   walkBlocks,
   LinkSystem,
   unixfsReifier,
-  Node,
+  BasicNode,
   parseContext,
 } from "./traversal.js";
 
@@ -54,7 +54,7 @@ export async function* responseBuilder(
   let meta: GraphSyncMetadata = [];
   let size = 0;
   for await (const block of walkBlocks(
-    new Node(req.root),
+    new BasicNode(req.root),
     parseContext().parseSelector(req.sel),
     ls
   )) {

src/traversal.ts

@@ -138,7 +138,14 @@ export const selToBlock = (function () {
   return encodeSelToBlock;
 })();
 
-export class Node {
+export interface Node {
+  kind: Kind;
+  value: any;
+  lookupBySegment(seg: PathSegment): Node | null;
+  entries(): Generator<{pathSegment: PathSegment; value: Node}, any, any>;
+}
+
+export class BasicNode implements Node {
   kind: Kind;
   value: any;
   constructor(value: any) {
@@ -152,6 +159,15 @@ export class Node {
     }
     return null;
   }
+  entries(): Generator<{pathSegment: PathSegment; value: BasicNode}, any, any> {
+    if (this.kind === Kind.List) {
+      return arrayEntries(this.value);
+    }
+    if (this.kind === Kind.Map) {
+      return mapEntries(this.value);
+    }
+    throw new Error(`Cannot call entries on ${this.kind} kind`);
+  }
 }
 
 export type SelectorNode = {
@@ -235,14 +251,21 @@ export const entriesSelector: SelectorNode = {
   },
 };
 
-class PathSegment {
+export class PathSegment {
   value: string | number;
   constructor(value: string | number) {
     this.value = value;
   }
   toString(): string {
     return this.value + "";
   }
+  toIndex(): number {
+    if (typeof this.value === "number") {
+      return this.value;
+    } else {
+      return parseInt(this.value);
+    }
+  }
 }
 
 export interface Selector {
@@ -521,61 +544,26 @@ function parseLimit(node: LimitNode): RecursionLimit {
   }
 }
 
-type IteratorState = {
-  pathSegment: PathSegment | null;
-  value: any;
-};
-
-function segmentIterator(node: any) {
-  if (Array.isArray(node)) {
-    return arrayIterator(node);
+function* arrayEntries(
+  node: Array<any>
+): Generator<{pathSegment: PathSegment; value: BasicNode}, any, any> {
+  for (let i = 0; i < node.length; i++) {
+    yield {
+      pathSegment: new PathSegment(i),
+      value: new BasicNode(node[i]),
+    };
   }
-  return mapIterator(node);
 }
 
-function arrayIterator(node: Array<any>) {
-  let i = 0;
-  return {
-    next(): IteratorState {
-      if (i === node.length) {
-        return {
-          pathSegment: null,
-          value: null,
-        };
-      }
-      const index = i++;
-      return {
-        pathSegment: new PathSegment(index),
-        value: node[index],
-      };
-    },
-    done(): boolean {
-      return i === node.length;
-    },
-  };
-}
-
-function mapIterator(node: {[key: string]: any}) {
-  const keys = Object.keys(node);
-  let i = 0;
-  return {
-    next(): IteratorState {
-      if (i === keys.length) {
-        return {
-          pathSegment: null,
-          value: null,
-        };
-      }
-      const index = i++;
-      return {
-        pathSegment: new PathSegment(keys[index]),
-        value: node[keys[index]],
-      };
-    },
-    done(): boolean {
-      return i === keys.length;
-    },
-  };
+function* mapEntries(node: {
+  [key: string]: any;
+}): Generator<{pathSegment: PathSegment; value: BasicNode}, any, any> {
+  for (const [k, v] of Object.entries(node)) {
+    yield {
+      pathSegment: new PathSegment(k),
+      value: new BasicNode(v),
+    };
+  }
 }
 
 export type NodeReifier = (node: Node, loader: LinkLoader) => Node;
@@ -593,9 +581,9 @@ export function unixfsReifier(node: Node, loader: LinkLoader): Node {
       if (unixfs.isDirectory()) {
         const dir: {[key: string]: Node} = {};
         for (const link of node.value.Links) {
-          dir[link.Name] = new Node(link.Hash);
+          dir[link.Name] = new BasicNode(link.Hash);
         }
-        return new Node(dir);
+        return new BasicNode(dir);
       }
     } catch (e) {
       return node;
@@ -621,7 +609,7 @@ export async function* walkBlocks(
     const blk = await source.load(nd.value);
     yield blk;
 
-    nd = new Node(blk.value);
+    nd = new BasicNode(blk.value);
   }
 
   if (sel instanceof ExploreInterpretAs) {
@@ -660,14 +648,10 @@ export async function* walkBlocks(
     }
   } else {
     // visit everything
-    for (const itr = segmentIterator(nd.value); !itr.done(); ) {
-      let {pathSegment, value} = itr.next();
-      if (!pathSegment) {
-        continue;
-      }
+    for (const {pathSegment, value} of nd.entries()) {
       const sNext = sel.explore(nd.value, pathSegment);
       if (sNext !== null) {
-        yield* walkBlocks(new Node(value), sNext, source);
+        yield* walkBlocks(value, sNext, source);
       }
     }
   }

test/traversal.spec.ts

@@ -5,7 +5,7 @@ import {MemoryBlockstore} from "blockstore-core/memory";
 import {sha256} from "multiformats/hashes/sha2";
 import {importer} from "ipfs-unixfs-importer";
 import {
-  Node,
+  BasicNode,
   allSelector,
   parseContext,
   LinkSystem,
@@ -70,7 +70,7 @@ describe("traversal", () => {
     let i = 0;
 
     for await (const blk of walkBlocks(
-      new Node(grandparent.cid),
+      new BasicNode(grandparent.cid),
       sel,
       source
     )) {
@@ -162,7 +162,7 @@ describe("traversal", () => {
 
     let i = 0;
 
-    for await (const blk of walkBlocks(new Node(root), sel, source)) {
+    for await (const blk of walkBlocks(new BasicNode(root), sel, source)) {
       expect(blk.cid.toString()).to.equal(expected[i]);
       i++;
     }
@@ -184,7 +184,7 @@ describe("traversal", () => {
 
     i = 0;
 
-    for await (const blk of walkBlocks(new Node(root2), sel, source)) {
+    for await (const blk of walkBlocks(new BasicNode(root2), sel, source)) {
       expect(blk.cid.toString()).to.equal(expected[i]);
       i++;
     }