JavaScript Function

This node executes custom JavaScript code with dynamic inputs and outputs.

The JavaScript Function node provides full JavaScript programming capabilities within visual workflows.

The JavaScript Function node (displayed as "Function") enables custom JavaScript code execution with dynamic input/output creation. It supports modern JavaScript features, external library integration, and flexible data processing.

Inputs

Code

Data	Description
Script	JavaScript code to execute

Dynamic Inputs

Additional inputs are created automatically based on your script usage

Actions

Signal	Description
Run	Executes the JavaScript code

Outputs

Dynamic Outputs

Outputs are created automatically when your script sets values

Events

Signal	Description
Success	Triggered when script executes successfully
Error	Triggered when script encounters an error

Usage

The JavaScript Function node provides complete programming flexibility within visual workflows:

Script Structure

// Access inputs via Inputs object
const userInput = Inputs.MyValue;
const dataArray = Inputs.DataList;

// Perform your logic
const result = userInput * 2;
const processedData = dataArray.map(item => item.toUpperCase());

// Set outputs via Outputs object
Outputs.Result = result;
Outputs.ProcessedData = processedData;

// Send signals
Signals.CustomEvent();

Dynamic Port Creation

Inputs: Reference Inputs.PropertyName to auto-create input ports Outputs: Assign to Outputs.PropertyName to auto-create output ports
Signals: Call Signals.EventName() to auto-create signal outputs

Available APIs

Standard JavaScript: All native JavaScript features (ES2020+) Node.js APIs: File system, HTTP, crypto (in Node.js environments) Browser APIs: DOM, fetch, localStorage (in browser environments) External Libraries: Import and use external npm packages

Example Use Cases

1. Data Processing: Transform, filter, and manipulate data arrays

   const filtered = Inputs.Data.filter(item => item.active);
   const transformed = filtered.map(item => ({
     id: item.id,
     name: item.name.toUpperCase(),
     value: item.value * 1.2
   }));
   Outputs.ProcessedData = transformed;

2. API Integration: Make HTTP requests and process responses

   const response = await fetch(`/api/users/${Inputs.UserId}`);
   const userData = await response.json();
   Outputs.UserData = userData;
   Outputs.Status = response.status;

3. Mathematical Calculations: Complex computations and algorithms

   const numbers = Inputs.Numbers;
   const mean = numbers.reduce((a, b) => a + b, 0) / numbers.length;
   const variance = numbers.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / numbers.length;
   
   Outputs.Mean = mean;
   Outputs.StandardDeviation = Math.sqrt(variance);

4. String Manipulation: Text processing and formatting

   const text = Inputs.RawText;
   const cleaned = text.trim().toLowerCase().replace(/[^a-z0-9\s]/g, '');
   const words = cleaned.split(/\s+/).filter(word => word.length > 0);
   
   Outputs.CleanedText = cleaned;
   Outputs.WordCount = words.length;
   Outputs.Words = words;

Error Handling

try {
  // Your code here
  const result = riskyOperation(Inputs.Data);
  Outputs.Result = result;
  Signals.Success();
} catch (error) {
  Outputs.ErrorMessage = error.message;
  Signals.Error();
}

Asynchronous Operations

// Using async/await
const data = await fetchDataFromAPI(Inputs.Url);
Outputs.Data = data;

// Using Promises
fetchDataFromAPI(Inputs.Url)
  .then(data => {
    Outputs.Data = data;
    Signals.DataLoaded();
  })
  .catch(error => {
    Outputs.Error = error.message;
    Signals.Error();
  });

Best Practices

1. Error Handling: Always wrap risky operations in try-catch blocks
2. Input Validation: Check input types and values before processing
3. Performance: Avoid expensive operations in frequently called functions
4. Memory Management: Clean up large objects and clear references when done
5. Debugging: Use console.log() for development debugging

Advanced Features

Module Imports: Import external libraries and modules Persistent State: Use this object to maintain state between executions Context Access: Access node context and runtime information Integration: Seamlessly integrate with other visual nodes

Security Considerations

• Code executes in the application's JavaScript context
• Has access to all available APIs and data
• Implement proper input validation for user-provided data
• Be cautious with external API calls and data handling