refactor(api): rework the JSON processing nodes and add new ones.

Author: bchapuis

apps/api/src/nodes/cloudflare-node-registry.ts

@@ -153,13 +153,33 @@ import { SvgToPngNode } from "./image/svg-to-png-node";
 import { UformGen2Qwen500mNode } from "./image/uform-gen2-qwen-500m-node";
 import { WebcamNode } from "./image/webcam-node";
 import { JavaScriptEditorNode } from "./javascript/javascript-editor-node";
-import { JsonBooleanExtractorNode } from "./json/json-boolean-extractor-node";
+import { JsonAggNode } from "./json/json-agg-node";
+import { JsonArrayLengthNode } from "./json/json-array-length-node";
+import { JsonContainsNode } from "./json/json-contains-node";
+import { JsonContainsPathNode } from "./json/json-contains-path-node";
 import { JsonEditorNode } from "./json/json-editor-node";
-import { JsonExtractorNode } from "./json/json-extractor-node";
-import { JsonJavascriptProcessorNode } from "./json/json-javascript-processor-node";
-import { JsonNumberExtractorNode } from "./json/json-number-extractor-node";
-import { JsonStringExtractorNode } from "./json/json-string-extractor-node";
+import { JsonExecuteJavascriptNode } from "./json/json-execute-javascript-node";
+import { JsonExtractAllNode } from "./json/json-extract-all-node";
+import { JsonExtractBooleanNode } from "./json/json-extract-boolean-node";
+import { JsonExtractNumberNode } from "./json/json-extract-number-node";
+import { JsonExtractObjectNode } from "./json/json-extract-object-node";
+import { JsonExtractStringNode } from "./json/json-extract-string-node";
+import { JsonFlattenNode } from "./json/json-flatten-node";
+import { JsonInsertNode } from "./json/json-insert-node";
+import { JsonKeysNode } from "./json/json-keys-node";
+import { JsonMergeNode } from "./json/json-merge-node";
+import { JsonObjectAggNode } from "./json/json-object-agg-node";
+import { JsonObjectEntriesNode } from "./json/json-object-entries-node";
+import { JsonObjectKeysNode } from "./json/json-object-keys-node";
+import { JsonObjectValuesNode } from "./json/json-object-values-node";
+import { JsonRemoveNode } from "./json/json-remove-node";
+import { JsonReplaceNode } from "./json/json-replace-node";
+import { JsonSetNode } from "./json/json-set-node";
+import { JsonStripNullsNode } from "./json/json-strip-nulls-node";
 import { JsonTemplateNode } from "./json/json-template-node";
+import { JsonToGeojsonNode } from "./json/json-to-geojson-node";
+import { JsonTypeofNode } from "./json/json-typeof-node";
+import { JsonValidNode } from "./json/json-valid-node";
 import { ConditionalForkNode } from "./logic/conditional-fork-node";
 import { ConditionalJoinNode } from "./logic/conditional-join-node";
 import { AbsoluteValueNode } from "./math/absolute-value-node";
@@ -287,13 +307,33 @@ export class CloudflareNodeRegistry extends BaseNodeRegistry {
     this.registerImplementation(StableDiffusionXLLightningNode);
     this.registerImplementation(StableDiffusionV15Img2ImgNode);
     this.registerImplementation(StableDiffusionV15InpaintingNode);
-    this.registerImplementation(JsonStringExtractorNode);
-    this.registerImplementation(JsonBooleanExtractorNode);
-    this.registerImplementation(JsonNumberExtractorNode);
-    this.registerImplementation(JsonExtractorNode);
-    this.registerImplementation(JsonJavascriptProcessorNode);
+    this.registerImplementation(JsonAggNode);
+    this.registerImplementation(JsonExtractStringNode);
+    this.registerImplementation(JsonExtractBooleanNode);
+    this.registerImplementation(JsonExtractNumberNode);
+    this.registerImplementation(JsonExtractObjectNode);
+    this.registerImplementation(JsonExtractAllNode);
+    this.registerImplementation(JsonExecuteJavascriptNode);
     this.registerImplementation(JsonTemplateNode);
     this.registerImplementation(JsonEditorNode);
+    this.registerImplementation(JsonArrayLengthNode);
+    this.registerImplementation(JsonContainsNode);
+    this.registerImplementation(JsonContainsPathNode);
+    this.registerImplementation(JsonFlattenNode);
+    this.registerImplementation(JsonInsertNode);
+    this.registerImplementation(JsonKeysNode);
+    this.registerImplementation(JsonMergeNode);
+    this.registerImplementation(JsonObjectAggNode);
+    this.registerImplementation(JsonObjectEntriesNode);
+    this.registerImplementation(JsonObjectKeysNode);
+    this.registerImplementation(JsonObjectValuesNode);
+    this.registerImplementation(JsonRemoveNode);
+    this.registerImplementation(JsonReplaceNode);
+    this.registerImplementation(JsonSetNode);
+    this.registerImplementation(JsonStripNullsNode);
+    this.registerImplementation(JsonToGeojsonNode);
+    this.registerImplementation(JsonTypeofNode);
+    this.registerImplementation(JsonValidNode);
     this.registerImplementation(MultiVariableStringTemplateNode);
     this.registerImplementation(SingleVariableStringTemplateNode);
     this.registerImplementation(JavaScriptEditorNode);

apps/api/src/nodes/json/json-agg-node.test.ts

@@ -0,0 +1,138 @@
+import { Node } from "@dafthunk/types";
+import { describe, expect, it } from "vitest";
+
+import { NodeContext } from "../types";
+import { JsonAggNode } from "./json-agg-node";
+
+describe("JsonAggNode", () => {
+  it("should aggregate single value into array", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: "test",
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual(["test"]);
+  });
+
+  it("should aggregate multiple values into array", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: ["a", "b", "c"],
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual(["a", "b", "c"]);
+  });
+
+  it("should handle mixed data types", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: ["string", 42, true, { key: "value" }],
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual([
+      "string",
+      42,
+      true,
+      { key: "value" },
+    ]);
+  });
+
+  it("should filter out null and undefined values", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: ["a", null, "b", undefined, "c"],
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual(["a", "b", "c"]);
+  });
+
+  it("should return empty array for null input", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: null,
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual([]);
+  });
+
+  it("should return empty array for undefined input", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: undefined,
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual([]);
+  });
+
+  it("should handle empty array input", async () => {
+    const nodeId = "json-agg";
+    const node = new JsonAggNode({
+      nodeId,
+    } as unknown as Node);
+
+    const context = {
+      nodeId,
+      inputs: {
+        values: [],
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.result).toEqual([]);
+  });
+});

apps/api/src/nodes/json/json-agg-node.ts

@@ -0,0 +1,78 @@
+import { NodeExecution, NodeType } from "@dafthunk/types";
+
+import { ExecutableNode } from "../types";
+import { NodeContext } from "../types";
+
+/**
+ * JSON Aggregation node implementation that aggregates values into a JSON array
+ * Inspired by SQLite/PostgreSQL's json_agg function
+ */
+export class JsonAggNode extends ExecutableNode {
+  public static readonly nodeType: NodeType = {
+    id: "json-agg",
+    name: "JSON Aggregate",
+    type: "json-agg",
+    description: "Aggregates multiple values into a JSON array",
+    tags: ["JSON"],
+    icon: "list",
+    inlinable: true,
+    asTool: true,
+    inputs: [
+      {
+        name: "values",
+        type: "any",
+        description:
+          "Values to aggregate into a JSON array (supports multiple connections)",
+        required: true,
+        repeated: true,
+      },
+    ],
+    outputs: [
+      {
+        name: "result",
+        type: "json",
+        description: "The aggregated JSON array",
+      },
+    ],
+  };
+
+  async execute(context: NodeContext): Promise<NodeExecution> {
+    try {
+      const { values } = context.inputs;
+
+      // Handle missing input
+      if (values === null || values === undefined) {
+        return this.createSuccessResult({
+          result: [],
+        });
+      }
+
+      // Handle single value input
+      if (!Array.isArray(values)) {
+        return this.createSuccessResult({
+          result: [values],
+        });
+      }
+
+      // Handle array of values (multiple connections)
+      if (Array.isArray(values)) {
+        // Filter out null/undefined values and create the result array
+        const result = values.filter(
+          (value) => value !== null && value !== undefined
+        );
+
+        return this.createSuccessResult({
+          result,
+        });
+      }
+
+      return this.createErrorResult(
+        "Invalid input type: expected any value or array of values"
+      );
+    } catch (error) {
+      return this.createErrorResult(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+}