feat(api): add @cf-wasm/quickjs dependency and register JsonScriptNode in node registry; enhance JSON parsing in parameter mapper

Author: bchapuis

apps/api/package.json

@@ -40,6 +40,7 @@
   "dependencies": {
     "@aws-sdk/client-ses": "^3.812.0",
     "@cf-wasm/photon": "^0.1.30",
+    "@cf-wasm/quickjs": "^0.0.6",
     "@dafthunk/types": "workspace:*",
     "@hono/oauth-providers": "^0.7.1",
     "@hono/zod-validator": "^0.5.0",

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

@@ -0,0 +1,122 @@
+import { NodeExecution, NodeType } from "@dafthunk/types";
+import {
+  getQuickJSWASMModule,
+  QuickJSContext,
+  QuickJSHandle,
+} from "@cf-wasm/quickjs";
+
+import { ExecutableNode, NodeContext } from "../types";
+
+export class JsonScriptNode extends ExecutableNode {
+  public static readonly nodeType: NodeType = {
+    id: "json-script",
+    name: "JSON Script",
+    type: "json-script",
+    description:
+      "Executes a JavaScript script with a JSON object as input. The input JSON is available as a global variable 'inputJson'. The result of the last expression is returned.",
+    category: "JSON",
+    icon: "code", // Using 'code' icon, assuming it exists or is appropriate
+    inputs: [
+      {
+        name: "json",
+        type: "json",
+        description: "The JSON object to process",
+        required: true,
+      },
+      {
+        name: "script",
+        type: "string",
+        description:
+          "JavaScript code to execute. 'inputJson' is available globally. The last expression's result is returned.",
+        required: true,
+      },
+    ],
+    outputs: [
+      {
+        name: "result",
+        type: "json",
+        description: "The result of the script execution, expected to be a JSON object or array",
+      },
+      {
+        name: "error",
+        type: "string",
+        description: "Error message if script execution failed",
+        hidden: true,
+      },
+    ],
+  };
+
+  public async execute(context: NodeContext): Promise<NodeExecution> {
+    const { json, script } = context.inputs;
+
+    if (json === undefined || json === null) {
+      return this.createErrorResult("Missing JSON input object.");
+    }
+
+    if (!script || typeof script !== "string" || script.trim() === "") {
+      return this.createErrorResult("Missing or empty script.");
+    }
+
+    let vm: QuickJSContext | undefined;
+    try {
+      const QuickJSModule = await getQuickJSWASMModule();
+      vm = QuickJSModule.newContext();
+
+      // 1. Convert JSON to string and create a string handle in the VM
+      const jsonStringified = JSON.stringify(json);
+      const jsonStringHandle = vm.newString(jsonStringified);
+
+      // 2. Set this string handle to a temporary global variable in the VM
+      vm.setProp(vm.global, "__tempInputJsonString__", jsonStringHandle);
+      jsonStringHandle.dispose(); // Dispose handle, vm's global has it now
+
+      // 3. Bootstrap script to parse the string and set globalThis.inputJson
+      const bootstrapScript = `
+        try {
+          globalThis.inputJson = JSON.parse(globalThis.__tempInputJsonString__);
+        } finally {
+          delete globalThis.__tempInputJsonString__;
+        }
+      `;
+      const bootstrapResult = vm.evalCode(bootstrapScript);
+
+      if (bootstrapResult.error) {
+        const errorDump = vm.dump(bootstrapResult.error);
+        bootstrapResult.error.dispose();
+        return this.createErrorResult(
+          `Failed to initialize inputJson in VM: ${JSON.stringify(errorDump)}`
+        );
+      }
+      // Result of delete is boolean, or undefined if try/finally completes normally without returning a value from try.
+      // In either case, dispose the handle for the result of the bootstrap script.
+      bootstrapResult.value.dispose();
+
+      // 4. Now, 'inputJson' global variable is ready for the user's script
+      const evalResult = vm.evalCode(script);
+
+      if (evalResult.error) {
+        const errorDump = vm.dump(evalResult.error);
+        evalResult.error.dispose();
+        return this.createErrorResult(
+          `Script execution error: ${JSON.stringify(errorDump)}`
+        );
+      } else {
+        const resultOutput = vm.dump(evalResult.value);
+        evalResult.value.dispose();
+        return this.createSuccessResult({
+          result: resultOutput,
+          error: null, // Explicitly set error to null on success
+        });
+      }
+    } catch (err) {
+      const error = err as Error;
+      return this.createErrorResult(
+        `Error during script execution: ${error.message}`
+      );
+    } finally {
+      if (vm) {
+        vm.dispose();
+      }
+    }
+  }
+} 

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

@@ -56,6 +56,7 @@ import { WebcamNode } from "./image/webcam-node";
 import { JsonBooleanExtractorNode } from "./json/json-boolean-extractor-node";
 import { JsonNumberExtractorNode } from "./json/json-number-extractor-node";
 import { JsonObjectArrayExtractorNode } from "./json/json-object-array-extractor-node";
+import { JsonScriptNode } from "./json/json-script-node";
 import { JsonStringExtractorNode } from "./json/json-string-extractor-node";
 import { JsonTemplateNode } from "./json/json-template-node";
 import { MonacoEditorNode } from "./json/monaco-editor-node";
@@ -177,6 +178,7 @@ export class NodeRegistry {
     this.registerImplementation(JsonBooleanExtractorNode);
     this.registerImplementation(JsonNumberExtractorNode);
     this.registerImplementation(JsonObjectArrayExtractorNode);
+    this.registerImplementation(JsonScriptNode);
     this.registerImplementation(JsonTemplateNode);
     this.registerImplementation(MultiVariableStringTemplateNode);
     this.registerImplementation(SingleVariableStringTemplateNode);

apps/api/src/nodes/parameter-mapper.ts

@@ -205,8 +205,18 @@ const converters = {
   json: {
     nodeToApi: (value: NodeParameterValue) =>
       (isPlainJsonObject(value) ? value : undefined) as ApiParameterValue,
-    apiToNode: (value: ApiParameterValue) =>
-      (isPlainJsonObject(value) ? value : undefined) as NodeParameterValue,
+    apiToNode: (value: ApiParameterValue) => {
+      if (typeof value === "string") {
+        try {
+          const parsed = JSON.parse(value);
+          return (isPlainJsonObject(parsed) ? parsed : undefined) as NodeParameterValue;
+        } catch (e) {
+          // If parsing fails, it's not valid JSON in string form
+          return undefined;
+        }
+      }
+      return (isPlainJsonObject(value) ? value : undefined) as NodeParameterValue;
+    },
   },
   any: {
     nodeToApi: (value: NodeParameterValue) => value as ApiParameterValue,