Allow Trace to accept a Future as its data source

examples/futures-as-data-source.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env -S npx ts-node --transpileOnly
+
+import { Substrate, Box, sb } from "substrate";
+
+async function main() {
+  const SUBSTRATE_API_KEY = process.env["SUBSTRATE_API_KEY"];
+
+  const substrate = new Substrate({ apiKey: SUBSTRATE_API_KEY });
+
+  const f = sb.jq<"object">({ foo: { bar: "baz" } }, ".", "object");
+
+  const a = new Box({
+    value: {
+      x: f,
+      y: f.get("foo.bar"),
+    },
+  });
+
+  const res = await substrate.run(a);
+  console.log(JSON.stringify(res.json.data, null, 2));
+}
+main();

src/Future.ts

@@ -46,12 +46,12 @@ abstract class Directive {
 
 export class Trace extends Directive {
   items: TraceProp[];
-  originNode: Node;
+  target: Node | Future<any>;
 
-  constructor(items: TraceProp[], originNode: Node) {
+  constructor(items: TraceProp[], target: Node | Future<any>) {
     super();
     this.items = items;
-    this.originNode = originNode;
+    this.target = target;
   }
 
   static Operation = {
@@ -68,12 +68,15 @@ export class Trace extends Directive {
   };
 
   override next(...items: TraceProp[]) {
-    return new Trace([...this.items, ...items], this.originNode);
+    return new Trace([...this.items, ...items], this.target);
   }
 
   override async result(): Promise<any> {
-    // @ts-expect-error (protected result())
-    let result: any = await this.originNode.result();
+    let result: any = await (this.target instanceof Future
+      ? // @ts-expect-error (protected _result())
+        this.target._result()
+      : // @ts-expect-error (protected result())
+        this.target.result());
 
     for (let item of this.items) {
       if (item instanceof Future) {
@@ -85,10 +88,19 @@ export class Trace extends Directive {
     return result;
   }
 
+  override referencedFutures() {
+    if (this.target instanceof Future) {
+      return [...super.referencedFutures(), this.target];
+    }
+    return super.referencedFutures();
+  }
+
   override toJSON() {
     return {
       type: "trace",
-      origin_node_id: this.originNode.id,
+      origin_node_id: this.target instanceof Node ? this.target.id : null,
+      // @ts-ignore (protected _id)
+      origin_future_id: this.target instanceof Node ? null : this.target._id,
       op_stack: this.items.map((item) => {
         if (item instanceof FutureString) {
           // @ts-expect-error (accessing protected prop: _id)
@@ -122,7 +134,7 @@ export class JQ extends Directive {
     rawValue: (val: JQCompatible) => ({ future_id: null, val }),
   };
 
-  override next(...items: TraceProp[]) {
+  override next(..._items: TraceProp[]) {
     return new JQ(this.query, this.target);
   }
 
@@ -300,11 +312,9 @@ export abstract class FutureObject extends Future<Object> {
 
 export class FutureAnyObject extends Future<Object> {
   get(path: string | FutureString) {
-    const d =
-      typeof path === "string"
-        ? this._directive.next(...parsePath(path))
-        : this._directive.next(path);
-    return new FutureAnyObject(d);
+    const traceProps = typeof path === "string" ? parsePath(path) : [path];
+    const trace = new Trace(traceProps, this);
+    return new FutureAnyObject(trace);
   }
 
   at(index: number | FutureNumber) {

src/Node.ts

@@ -182,13 +182,21 @@ export abstract class Node {
       // @ts-ignore protected access
       let directive = future._directive;
       if (directive instanceof Trace) {
-        // @ts-ignore protected access
-        const references = directive.originNode.references();
-        for (let node of references.nodes) {
-          nodes.add(node);
-        }
-        for (let future of references.futures) {
-          futures.add(future);
+        if (directive.target instanceof Node) {
+          // @ts-ignore protected access
+          const references = directive.target.references();
+          for (let node of references.nodes) {
+            nodes.add(node);
+          }
+          for (let future of references.futures) {
+            futures.add(future);
+          }
+        } else if (directive.target instanceof Future) {
+          // @ts-ignore protected access
+          const referencedFutures = directive.target.referencedFutures();
+          for (let future of referencedFutures) {
+            futures.add(future);
+          }
         }
       }
     }

tests/Future.test.ts

@@ -53,58 +53,83 @@
   });
 
   describe("Trace (Directive)", () => {
-    test(".next", () => {
-      const s = new FutureString(new Trace([], node("123")));
-      const n = new FutureNumber(new Trace([], node("456")));
-      const d = new Trace(["a", 1, s, n], node("NodeId"));
-      const d2 = d.next("b", 2);
-
-      expect(d2.items).toEqual(["a", 1, s, n, "b", 2]);
-      expect(d2.originNode.id).toEqual("NodeId");
-    });
-
-    test(".result", async () => {
-      // when the trace is empty, it resovles to the node's output
-      const n0 = staticNode("hello");
-      const t0 = new Trace([], n0);
-      expect(t0.result()).resolves.toEqual("hello");
+    describe("when target is a Node", () => {
+      test(".next", () => {
+        const s = new FutureString(new Trace([], node("123")));
+        const n = new FutureNumber(new Trace([], node("456")));
+        const d = new Trace(["a", 1, s, n], node("NodeId"));
+        const d2 = d.next("b", 2);
+
+        expect(d2.items).toEqual(["a", 1, s, n, "b", 2]);
+        expect((d2.target as Node).id).toEqual("NodeId");
+      });
 
-      // when the trace only includes primitive values
-      const n1 = staticNode({ a: ["result1"] });
-      const t1 = new Trace(["a", 0], n1);
-      expect(t1.result()).resolves.toEqual("result1");
+      test(".result", async () => {
+        // when the trace is empty, it resovles to the node's output
+        const n0 = staticNode("hello");
+        const t0 = new Trace([], n0);
+        expect(t0.result()).resolves.toEqual("hello");
+
+        // when the trace only includes primitive values
+        const n1 = staticNode({ a: ["result1"] });
+        const t1 = new Trace(["a", 0], n1);
+        expect(t1.result()).resolves.toEqual("result1");
+
+        // when the trace contains futures, they get resolved
+        const fs = new FutureString(new Trace([], staticNode("b")));
+        const fn = new FutureNumber(new Trace([], staticNode(1)));
+        const n2 = staticNode({ a: [{ b: [undefined, "result2"] }] });
+        const t2 = new Trace(["a", 0, fs, fn], n2);
+        expect(t2.result()).resolves.toEqual("result2");
+      });
 
-      // when the trace contains futures, they get resolved
-      const fs = new FutureString(new Trace([], staticNode("b")));
-      const fn = new FutureNumber(new Trace([], staticNode(1)));
-      const n2 = staticNode({ a: [{ b: [undefined, "result2"] }] });
-      const t2 = new Trace(["a", 0, fs, fn], n2);
-      expect(t2.result()).resolves.toEqual("result2");
-    });
+      test(".toJSON", () => {
+        const s = new FutureString(new Trace([], node()), "123");
+        const n = new FutureNumber(new Trace([], node()), "456");
+        const d = new Trace(["a", 1, s, n], node("NodeId"));
+
+        expect(d.toJSON()).toEqual({
+          type: "trace",
+          origin_node_id: "NodeId",
+          op_stack: [
+            Trace.Operation.key("attr", "a"),
+            Trace.Operation.key("item", 1),
+            Trace.Operation.future("attr", "123"),
+            Trace.Operation.future("item", "456"),
+          ],
+        });
+      });
 
-    test(".toJSON", () => {
-      const s = new FutureString(new Trace([], node()), "123");
-      const n = new FutureNumber(new Trace([], node()), "456");
-      const d = new Trace(["a", 1, s, n], node("NodeId"));
+      test(".referencedFutures", () => {
+        const s = new FutureString(new Trace([], node()));
+        const n = new FutureNumber(new Trace([], node()));
+        const d = new Trace(["a", 1, s, n], node("NodeId"));
 
-      expect(d.toJSON()).toEqual({
-        type: "trace",
-        origin_node_id: "NodeId",
-        op_stack: [
-          Trace.Operation.key("attr", "a"),
-          Trace.Operation.key("item", 1),
-          Trace.Operation.future("attr", "123"),
-          Trace.Operation.future("item", "456"),
-        ],
+        expect(d.referencedFutures()).toEqual([s, n]);
       });
     });
 
-    test(".referencedFutures", () => {
-      const s = new FutureString(new Trace([], node()));
-      const n = new FutureNumber(new Trace([], node()));
-      const d = new Trace(["a", 1, s, n], node("NodeId"));
+    describe("when target is a Future", () => {
+      test(".toJSON", () => {
+        const n = staticNode({ x: 123 });
+        const f = Future.jq<"object">(n.future, ".", "object"); // => { x: 123 }
+        const t = new Trace(["x"], f);
+
+        expect(t.toJSON()).toEqual({
+          type: "trace",
+          origin_node_id: null,
+          // @ts-ignore
+          origin_future_id: f._id,
+          op_stack: [Trace.Operation.key("attr", "x")],
+        });
+      });
 
-      expect(d.referencedFutures()).toEqual([s, n]);
+      test(".referencedFutures", () => {
+        const n = staticNode({ x: 123 });
+        const f = Future.jq<"object">(n.future, ".", "object"); // => { x: 123 }
+        const t = new Trace(["x"], f);
+        expect(t.referencedFutures()).toEqual([f]);
+      });
     });
   });