feat(api): add CalculatorNode to CloudflareNodeRegistry and improve formatting in JavascriptScriptNode

Author: bchapuis

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

@@ -185,6 +185,7 @@ import { ConditionalJoinNode } from "./logic/conditional-join-node";
 import { AbsoluteValueNode } from "./math/absolute-value-node";
 import { AdditionNode } from "./math/addition-node";
 import { AvgNode } from "./math/avg-node";
+import { CalculatorNode } from "./math/calculator-node";
 import { DivisionNode } from "./math/division-node";
 import { ExponentiationNode } from "./math/exponentiation-node";
 import { MaxNode } from "./math/max-node";
@@ -276,6 +277,7 @@ export class CloudflareNodeRegistry extends BaseNodeRegistry {
     this.registerImplementation(ExponentiationNode);
     this.registerImplementation(SquareRootNode);
     this.registerImplementation(AbsoluteValueNode);
+    this.registerImplementation(CalculatorNode);
     this.registerImplementation(SumNode);
     this.registerImplementation(MaxNode);
     this.registerImplementation(MinNode);

apps/api/src/nodes/javascript/javascript-script-node.test.ts

@@ -90,7 +90,9 @@ describe("JavascriptScriptNode", () => {
     const result = await node.execute(context);
     expect(result.status).toBe("completed");
     expect(result.outputs?.result).toEqual(["HELLO", "WORLD", "JAVASCRIPT"]);
-    expect(result.outputs?.stdout).toBe("Processing values: hello, world, javascript");
+    expect(result.outputs?.stdout).toBe(
+      "Processing values: hello, world, javascript"
+    );
     expect(result.outputs?.error).toBeNull();
   });
 

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

@@ -24,7 +24,8 @@ export class JavascriptScriptNode extends ExecutableNode {
       {
         name: "args",
         type: "json",
-        description: "Command line arguments (array of strings) to pass to the script",
+        description:
+          "Command line arguments (array of strings) to pass to the script",
         required: false,
       },
       {
@@ -38,7 +39,8 @@ export class JavascriptScriptNode extends ExecutableNode {
       {
         name: "result",
         type: "json",
-        description: "The result of the script execution (return value or last expression)",
+        description:
+          "The result of the script execution (return value or last expression)",
       },
       {
         name: "stdout",
@@ -81,8 +83,8 @@ export class JavascriptScriptNode extends ExecutableNode {
       const stdout: string[] = [];
       const stderr: string[] = [];
 
-             // Create a bootstrap script that sets up the environment
-       const bootstrapScript = `
+      // Create a bootstrap script that sets up the environment
+      const bootstrapScript = `
          // Set up console object
          globalThis.console = {
            log: function(...args) {
@@ -146,13 +148,15 @@ export class JavascriptScriptNode extends ExecutableNode {
 
         // Execute the original script (either it didn't start with '{' or wrapping failed)
         const evalResult = vm!.evalCode(scriptToExecute);
-        
+
         if (evalResult.error) {
           const errorDump = vm!.dump(evalResult.error);
           evalResult.error.dispose();
-          throw new Error(`Script execution error: ${JSON.stringify(errorDump)}`);
+          throw new Error(
+            `Script execution error: ${JSON.stringify(errorDump)}`
+          );
         }
-        
+
         const resultOutput = vm!.dump(evalResult.value);
         evalResult.value.dispose();
         return resultOutput;
@@ -164,10 +168,14 @@ export class JavascriptScriptNode extends ExecutableNode {
       // Get captured output
       const stdoutResult = vm.evalCode("globalThis.__stdout__.join('\\n')");
       const stderrResult = vm.evalCode("globalThis.__stderr__.join('\\n')");
-      
-      const stdoutOutput = stdoutResult.error ? "" : vm.dump(stdoutResult.value);
-      const stderrOutput = stderrResult.error ? "" : vm.dump(stderrResult.value);
-      
+
+      const stdoutOutput = stdoutResult.error
+        ? ""
+        : vm.dump(stdoutResult.value);
+      const stderrOutput = stderrResult.error
+        ? ""
+        : vm.dump(stderrResult.value);
+
       if (!stdoutResult.error) stdoutResult.value.dispose();
       if (!stderrResult.error) stderrResult.value.dispose();
 
@@ -177,7 +185,6 @@ export class JavascriptScriptNode extends ExecutableNode {
         stderr: stderrOutput,
         error: null,
       });
-
     } catch (err) {
       const error = err as Error;
       return this.createErrorResult(

apps/api/src/nodes/math/calculator-node.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect } from "vitest";
+import { CalculatorNode } from "./calculator-node";
+import { Node } from "@dafthunk/types";
+import { NodeContext } from "../types";
+
+describe("CalculatorNode", () => {
+  const createNode = (): Node => ({
+    id: "test-calculator",
+    type: "calculator",
+    position: { x: 0, y: 0 },
+  } as unknown as Node);
+
+  const createContext = (inputs: Record<string, any>) => ({
+    nodeId: "test-calculator",
+    inputs,
+    workflowId: "test-workflow",
+    executionId: "test-execution",
+    organizationId: "test-org",
+    env: {},
+    nodeRegistry: null,
+    toolRegistry: null,
+  } as unknown as NodeContext);
+
+  describe("nodeType", () => {
+    it("should have correct node type definition", () => {
+      expect(CalculatorNode.nodeType).toEqual({
+        id: "calculator",
+        name: "Calculator",
+        type: "calculator",
+        description:
+          "Evaluates mathematical expressions with comprehensive support for arithmetic operations, mathematical functions, trigonometric functions, constants, and complex formulas. Supports: basic arithmetic (+, -, *, /, ^, %), bitwise operators (&, |, <, >, ~), mathematical functions (sqrt, cbrt, pow, exp, log, log10, abs, floor, ceil, round, min, max, sign, trunc, hypot), trigonometric functions (sin, cos, tan, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh), mathematical constants (PI, E), random numbers, and complex nested expressions with proper order of operations and parentheses. All inputs are validated for security and only mathematical operations are allowed.",
+        tags: ["Math"],
+        icon: "calculator",
+        inlinable: true,
+        asTool: true,
+        inputs: [
+          {
+            name: "expression",
+            type: "string",
+            description:
+              "The mathematical expression to evaluate as a string. Examples: '2 + 3 * 4', 'sqrt(16)', 'sin(PI/2)', 'pow(2, 3)', 'abs(-5)', 'floor(3.7)', 'PI * 2^2', '(10 + 5) * 2 / 4', 'log(100)', 'random * 10', '17 % 5', '15 & 7', '8 | 4', '~10'. Supports all standard mathematical operations, functions, and constants. Use ^ for exponentiation (e.g., 2^3 = 8), % for modulo (e.g., 17 % 5 = 2), & for bitwise AND, | for bitwise OR, ~ for bitwise NOT. All expressions are validated for security.",
+            required: true,
+          },
+        ],
+        outputs: [
+          {
+            name: "result",
+            type: "number",
+            description:
+              "The calculated result of the mathematical expression as a number. Returns the final computed value after evaluating the expression with proper order of operations. Will be NaN or throw an error for invalid expressions.",
+          },
+        ],
+      });
+    });
+  });
+
+  describe("execute", () => {
+    it("should evaluate simple arithmetic expressions", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "2 + 3" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(5);
+    });
+
+    it("should handle multiplication and division", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "10 * 5 / 2" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(25);
+    });
+
+    it("should handle parentheses and order of operations", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "(2 + 3) * 4" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(20);
+    });
+
+    it("should handle exponentiation with ^ symbol", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "2^3" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(8);
+    });
+
+    it("should handle mathematical functions", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "sqrt(16)" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(4);
+    });
+
+    it("should handle trigonometric functions", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "sin(0)" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(0);
+    });
+
+    it("should handle constants", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "PI" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(Math.PI);
+    });
+
+    it("should handle complex expressions", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "sqrt(16) + sin(0) * 5" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(4);
+    });
+
+    it("should return error for empty expression", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("error");
+      expect(result.error).toBe("Missing or empty expression.");
+    });
+
+    it("should return error for invalid characters", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "alert('hello')" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("error");
+      expect(result.error).toContain("Expression contains invalid characters");
+    });
+
+    it("should return error for invalid mathematical expressions", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "2 +" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("error");
+    });
+
+    it("should handle decimal numbers", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "3.14 * 2" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(6.28);
+    });
+
+    it("should handle modulo operator", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "17 % 5" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(2);
+    });
+
+    it("should handle bitwise AND operator", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "15 & 7" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(7);
+    });
+
+    it("should handle bitwise OR operator", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "8 | 4" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(12);
+    });
+
+    it("should handle bitwise NOT operator", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "~10" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(-11);
+    });
+
+    it("should handle additional math functions", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "sign(-5) + trunc(3.7) + hypot(3, 4)" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(-1 + 3 + 5); // -1 + 3 + 5 = 7
+    });
+
+    it("should handle atan2 function", async () => {
+      const node = new CalculatorNode(createNode());
+      const context = createContext({ expression: "atan2(1, 1)" });
+
+      const result = await node.execute(context);
+
+      expect(result.status).toBe("completed");
+      expect(result.outputs?.result).toBe(Math.PI / 4);
+    });
+  });
+});