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

Data Proxy System

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

Advanced data proxy system for accessing workflow data, resolving parameters, and handling complex data transformations with full context awareness and parameter resolution.

Capabilities

WorkflowDataProxy Class

Core data proxy providing context-aware access to workflow execution data.

/**
 * Workflow data proxy for context-aware data access
 */
class WorkflowDataProxy {
  /**
   * Create data proxy for workflow execution context
   * @param workflow - Current workflow instance
   * @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
   * @param siblingParameters - Sibling node parameters
   * @param mode - Execution mode
   * @returns Data proxy object with context access
   */
  static getDataProxy(
    workflow: Workflow,
    runExecutionData: IRunExecutionData,
    runIndex: number,
    itemIndex: number,
    node: INode,
    connectionInputData: INodeExecutionData[],
    siblingParameters?: INodeParameters,
    mode?: WorkflowExecuteMode
  ): IDataObject;
}

Data Access Context Objects

Context objects providing access to different types of workflow data.

/**
 * JSON data access context
 */
interface IJsonDataContext {
  [key: string]: any;
}

/**
 * Binary data access context
 */
interface IBinaryDataContext {
  [key: string]: IBinaryData;
}

/**
 * Node parameter access context
 */
interface IParameterDataContext {
  [key: string]: NodeParameterValue | INodeParameters;
}

/**
 * Execution environment context
 */
interface IEnvironmentDataContext {
  [key: string]: string | undefined;
}

/**
 * Input data access context
 */
interface IInputDataContext {
  all: INodeExecutionData[];
  first: INodeExecutionData;
  last: INodeExecutionData;
  item: INodeExecutionData;
}

Environment Data Provider

Environment variable provider for secure access to system environment variables.

/**
 * Environment data provider for workflow execution
 */
interface IWorkflowDataProxyEnvProvider {
  /**
   * Get environment variable value
   * @param name - Environment variable name
   * @returns Environment variable value or undefined
   */
  getEnv(name: string): string | undefined;

  /**
   * Check if environment variable exists
   * @param name - Environment variable name
   * @returns Boolean indicating if variable exists
   */
  hasEnv(name: string): boolean;
}

interface EnvProviderState {
  isEnvAccessBlocked: boolean;
  allowedEnvVars: Set<string>;
}

/**
 * Create environment provider with access controls
 * @param state - Environment provider state
 * @returns Environment provider instance
 */
function createEnvProvider(state: EnvProviderState): IWorkflowDataProxyEnvProvider;

Data Resolution Functions

Functions for resolving different types of data in workflow context.

/**
 * Resolve node parameters with expression evaluation
 * @param workflow - Current workflow
 * @param runExecutionData - Execution data
 * @param runIndex - Run index
 * @param node - Current node
 * @param nodeParameters - Parameters to resolve
 * @param connectionInputData - Input data
 * @param mode - Execution mode
 * @returns Resolved parameters
 */
function resolveNodeParameters(
  workflow: Workflow,
  runExecutionData: IRunExecutionData,
  runIndex: number,
  node: INode,
  nodeParameters: INodeParameters,
  connectionInputData: INodeExecutionData[],
  mode: WorkflowExecuteMode
): INodeParameters;

/**
 * Get execution data for specific node
 * @param workflow - Current workflow
 * @param runExecutionData - Execution data
 * @param runIndex - Run index
 * @param nodeName - Node name to get data for
 * @returns Node execution data
 */
function getNodeExecutionData(
  workflow: Workflow,
  runExecutionData: IRunExecutionData,
  runIndex: number,
  nodeName: string
): ITaskData[] | undefined;

/**
 * Get workflow static data with context
 * @param workflow - Current workflow
 * @param type - Static data type
 * @returns Static data object
 */
function getWorkflowStaticData(
  workflow: Workflow,
  type: string
): IDataObject;

Data Proxy Helpers

Helper functions for common data proxy operations and transformations.

/**
 * Create item data context for expressions
 * @param item - Current item data
 * @param itemIndex - Item index
 * @returns Item context object
 */
function createItemContext(
  item: INodeExecutionData,
  itemIndex: number
): IDataObject;

/**
 * Create input data context
 * @param inputData - Input data array
 * @param itemIndex - Current item index
 * @returns Input data context
 */
function createInputDataContext(
  inputData: INodeExecutionData[],
  itemIndex: number
): IInputDataContext;

/**
 * Create previous node data context
 * @param workflow - Current workflow
 * @param runExecutionData - Execution data
 * @param node - Current node
 * @param itemIndex - Item index
 * @returns Previous node data context
 */
function createPreviousNodeContext(
  workflow: Workflow,
  runExecutionData: IRunExecutionData,
  node: INode,
  itemIndex: number
): IDataObject;

/**
 * Augment data object with proxy methods
 * @param data - Data object to augment
 * @param context - Augmentation context
 * @returns Augmented data object
 */
function augmentObject<T extends object>(
  data: T,
  context: IAugmentObjectContext
): T;

interface IAugmentObjectContext {
  allowedKeys?: string[];
  blockedKeys?: string[];
  includeHidden?: boolean;
}

Parameter Resolution

Advanced parameter resolution with type coercion and validation.

/**
 * Resolve parameter value with type conversion
 * @param parameterValue - Parameter value to resolve
 * @param type - Expected parameter type
 * @param context - Resolution context
 * @returns Resolved and typed parameter value
 */
function resolveParameterValue(
  parameterValue: NodeParameterValue,
  type: NodeParameterType,
  context: IParameterResolutionContext
): any;

interface IParameterResolutionContext {
  workflow: Workflow;
  runExecutionData: IRunExecutionData;
  runIndex: number;
  itemIndex: number;
  node: INode;
  connectionInputData: INodeExecutionData[];
  mode: WorkflowExecuteMode;
}

/**
 * Convert parameter to specified type
 * @param value - Value to convert
 * @param toType - Target type
 * @returns Converted value
 */
function convertParameterType(
  value: any,
  toType: NodeParameterType
): any;

type NodeParameterType = 
  | 'string'
  | 'number' 
  | 'boolean'
  | 'object'
  | 'array'
  | 'dateTime'
  | 'json'
  | 'notice'
  | 'collection'
  | 'fixedCollection'
  | 'multiOptions'
  | 'options'
  | 'color'
  | 'hidden'
  | 'resourceLocator'
  | 'resourceMapper'
  | 'filter'
  | 'assignmentCollection';

Usage Examples:

import { 
  WorkflowDataProxy, 
  resolveNodeParameters, 
  createInputDataContext 
} from "n8n-workflow";

// Create data proxy for expression resolution
const dataProxy = WorkflowDataProxy.getDataProxy(
  workflow,
  runExecutionData,
  0, // runIndex
  0, // itemIndex  
  currentNode,
  connectionInputData
);

// Access different data contexts
console.log('Current item JSON:', dataProxy.$json);
console.log('Input data:', dataProxy.$input);
console.log('Node parameters:', dataProxy.$parameter);
console.log('Environment variables:', dataProxy.$env);

// Resolve node parameters with expressions
const resolvedParameters = resolveNodeParameters(
  workflow,
  runExecutionData,
  0, // runIndex
  currentNode,
  {
    apiUrl: "{{ $env.API_BASE_URL }}/users/{{ $json.userId }}",
    timeout: "{{ $parameter.requestTimeout || 30000 }}",
    headers: {
      'Authorization': "Bearer {{ $credentials.accessToken }}",
      'Content-Type': 'application/json'
    }
  },
  connectionInputData,
  'manual'
);

// Create input data context for expressions
const inputContext = createInputDataContext(connectionInputData, 0);
console.log('First input item:', inputContext.first);
console.log('All input items:', inputContext.all);
console.log('Current input item:', inputContext.item);

// Access previous node data
const previousNodeData = dataProxy.$node["HTTP Request"];
console.log('Previous node output:', previousNodeData.json);
console.log('Previous node binary:', previousNodeData.binary);

// Environment variable access (with security controls)
const envProvider = createEnvProvider({
  isEnvAccessBlocked: false,
  allowedEnvVars: new Set(['API_BASE_URL', 'DATABASE_URL'])
});

const apiUrl = envProvider.getEnv('API_BASE_URL');
if (apiUrl) {
  console.log('API URL from environment:', apiUrl);
}

// Complex expression resolution
const expressionResult = dataProxy.$evaluateExpression(`
  {{
    $input.all
      .filter(item => item.json.status === 'active')
      .map(item => ({
        id: item.json.id,
        name: item.json.name,
        createdAt: item.json.createdAt.format('yyyy-MM-dd')
      }))
  }}
`);