tessl/npm-n8n-workflow

Workflow base code of n8n providing foundational workflow execution engine for automation platform

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Expression System

Name: tessl/npm-n8n-workflow
Author: tessl

Powerful expression evaluation system with mathematical operations, data manipulation, secure code execution in sandboxed environments, and comprehensive data type extensions.

Capabilities

Expression Class

Core expression evaluation engine with parameter resolution and context-aware data access.

/**
 * Expression evaluation engine
 */
class Expression {
  workflow?: Workflow;
  
  constructor(expression: string, workflow?: Workflow);

  /**
   * Resolve a simple parameter value with context
   * @param value - The value/expression to resolve
   * @param siblingParameters - Parameters from the same node
   * @param returnType - Expected return type
   * @returns Resolved value
   */
  resolveSimpleParameterValue(
    value: any,
    siblingParameters: IDataObject,
    returnType: string
  ): any;

  /**
   * Get parameter value with full execution context
   * @param parameterValue - Parameter value to resolve
   * @param runExecutionData - Current execution data
   * @param runIndex - Current run index
   * @param itemIndex - Current item index
   * @param node - Current node
   * @param connectionInputData - Input data from connections
   * @returns Resolved parameter value
   */
  getParameterValue(
    parameterValue: any,
    runExecutionData: IRunExecutionData | null,
    runIndex: number,
    itemIndex: number,
    node: INode,
    connectionInputData: INodeExecutionData[]
  ): any;
}

Expression Functions

Core expression evaluation functions for different contexts and use cases.

/**
 * Resolve expression in execution context
 * @param expression - Expression string to evaluate
 * @param data - Data context for evaluation
 * @param options - Evaluation options
 * @returns Resolved expression result
 */
function resolveExpression(
  expression: string,
  data: IDataObject,
  options?: IExpressionOptions
): any;

/**
 * Check if value contains expressions
 * @param value - Value to check
 * @returns Boolean indicating if value has expressions
 */
function isExpression(value: any): boolean;

/**
 * Execute code in sandboxed environment
 * @param code - JavaScript code to execute
 * @param context - Execution context
 * @param sandbox - Sandbox configuration
 * @returns Execution result
 */
function executeCode(
  code: string, 
  context: IDataObject,
  sandbox?: ISandboxOptions
): any;

Expression Extensions

Data type extensions providing enhanced functionality for arrays, strings, numbers, dates, objects, and booleans.

class ExpressionExtensions {
  static readonly functions: Record<string, Extension>;
  
  /**
   * Add custom extension function
   * @param name - Extension function name
   * @param extension - Extension implementation
   */
  static addExtension(name: string, extension: Extension): void;
}

interface Extension {
  doc: DocMetadata;
  transform: (value: any, ...args: any[]) => any;
}

interface DocMetadata {
  name: string;
  description: string;
  returnType?: string;
  args?: DocMetadataArgument[];
  examples?: DocMetadataExample[];
}

interface DocMetadataArgument {
  name: string;
  type?: string;
  description?: string;
  default?: any;
  optional?: boolean;
}

Expression Parser

Expression syntax parsing and validation utilities.

/**
 * Parse expression syntax and validate
 * @param expression - Expression string to parse
 * @returns Parsed expression AST
 */
function parseExpression(expression: string): ExpressionAST;

/**
 * Extract variables from expression
 * @param expression - Expression string
 * @returns Array of variable names used
 */
function extractVariables(expression: string): string[];

/**
 * Validate expression syntax
 * @param expression - Expression to validate
 * @returns Validation result with errors
 */
function validateExpression(expression: string): ValidationResult;

interface ExpressionAST {
  type: string;
  body: any[];
  sourceType?: string;
}

Sandboxing and Security

Secure expression execution with configurable sandboxing options.

interface ISandboxOptions {
  object?: Record<string, any>;
  timeout?: number;
  allowedBuiltins?: string[];
  blockedBuiltins?: string[];
}

/**
 * Create secure sandbox context
 * @param options - Sandbox configuration
 * @returns Sandbox context object
 */
function createSandbox(options: ISandboxOptions): ISandboxContext;

/**
 * Execute function in sandbox
 * @param fn - Function to execute
 * @param context - Sandbox context
 * @param timeout - Execution timeout
 * @returns Function result
 */
function executeSandboxed<T>(
  fn: () => T,
  context: ISandboxContext,
  timeout?: number
): Promise<T>;

Data Type Extensions

Built-in extensions for different data types with comprehensive functionality.

// Array Extensions
interface ArrayExtensions {
  chunk(size: number): any[][];
  compact(): any[];
  difference(values: any[]): any[];
  first(): any;
  last(): any;
  unique(): any[];
  flatten(): any[];
  isEmpty(): boolean;
  length(): number;
}

// String Extensions  
interface StringExtensions {
  contains(searchString: string): boolean;
  startsWith(searchString: string): boolean;
  endsWith(searchString: string): boolean;
  toTitleCase(): string;
  toSentenceCase(): string;
  stripTags(): string;
  urlEncode(): string;
  urlDecode(): string;
  hash(algorithm?: string): string;
}

// Number Extensions
interface NumberExtensions {
  abs(): number;
  ceil(): number;
  floor(): number;
  round(precision?: number): number;
  isNaN(): boolean;
  isFinite(): boolean;
  format(options?: NumberFormatOptions): string;
}

// Date Extensions
interface DateExtensions {
  format(format: string): string;
  toISOString(): string;
  beginningOf(unit: string): Date;
  endOf(unit: string): Date;
  plus(duration: any): Date;
  minus(duration: any): Date;
  diff(date: Date, unit?: string): number;
}

Usage Examples:

import { Expression, resolveExpression, ExpressionExtensions } from "n8n-workflow";

// Basic expression evaluation
const expression = new Expression("{{ $json.firstName + ' ' + $json.lastName }}");
const result = expression.resolveSimpleParameterValue(
  "{{ $json.firstName + ' ' + $json.lastName }}",
  { firstName: "John", lastName: "Doe" },
  "string"
);
// Result: "John Doe"

// Using data type extensions
const arrayResult = resolveExpression(
  "{{ $json.items.unique().length() }}",
  { items: ["a", "b", "a", "c", "b"] }
);
// Result: 3

// String manipulation
const stringResult = resolveExpression(
  "{{ $json.email.contains('@gmail.com') }}",
  { email: "user@gmail.com" }
);
// Result: true

// Date formatting
const dateResult = resolveExpression(
  "{{ $json.createdAt.format('yyyy-MM-dd') }}",
  { createdAt: new Date("2023-12-25") }
);
// Result: "2023-12-25"

// Mathematical operations
const mathResult = resolveExpression(
  "{{ ($json.price * $json.quantity).round(2) }}",
  { price: 19.99, quantity: 3 }
);
// Result: 59.97

// Complex data transformation
const complexResult = resolveExpression(`
  {{ 
    $json.users
      .filter(user => user.active)
      .map(user => user.name.toTitleCase()) 
      .join(', ')
  }}`,
  {
    users: [
      { name: "john doe", active: true },
      { name: "jane smith", active: false },
      { name: "bob wilson", active: true }
    ]
  }
);
// Result: "John Doe, Bob Wilson"