BitEngine.EazyFlow 1.0.0

NodeWorks

A flexible and modular node-based processing system for .NET 9 applications with enhanced HTTP request capabilities and comprehensive workflow node types inspired by n8n.

?? New: Frequently-Used Workflow Node Types

NodeWorks now includes 5 comprehensive categories of workflow nodes that developers frequently use:

// String processing with validation
var emailValidation = new StringValidationNode();
emailValidation.ValidationPattern = StringValidationNode.ValidationType.Email;
emailValidation.Input = "user@example.com";
var isValid = emailValidation.Execute(); // { IsValid: true, Message: "Valid" }

// Conditional logic for decision making
var ageCheck = new ConditionalNode();
ageCheck.Operator = ConditionalNode.ComparisonOperator.GreaterThan;
ageCheck.CompareValue = 18;
ageCheck.TrueValue = "Adult";
ageCheck.FalseValue = "Minor";
var result = ageCheck.Execute(); // "Adult" or "Minor"

// Date/time processing with arithmetic
var futureDate = new DateTimeArithmeticNode();
futureDate.OperationType = DateTimeArithmeticNode.Operation.Add;
futureDate.Unit = DateTimeArithmeticNode.TimeUnit.Days;
futureDate.Value = 30;
var thirtyDaysLater = (DateTime)futureDate.Execute();

// Collection processing with transformations
var mapNode = new MapNode(person => new { 
    displayName = $"{person.name} ({person.age})",
    isAdult = person.age >= 18 
});
var transformed = (object[])mapNode.Execute();

? New Node Categories

• ?? String Processing: Concatenate, Split, Replace, Format, Validate, Case conversion
• ?? Conditional Logic: If-then-else, Switch-case, Boolean operations, Filtering
• ?? Date/Time Processing: Current time, Formatting, Arithmetic, Extraction, Validation
• ?? File Operations: Read/Write files, CSV handling, Directory operations
• ?? Collection Processing: Map, Reduce, Sort, Group, Filter, Join, Unique

?? Enhanced HTTP Request Node

Advanced HTTP request capabilities with n8n-like features:

// EazyTrax API integration example
var assets = await HttpRequest.Get("https://lab.eazytrax.com/api/inventory/assets/all")
    .WithApiKey("EazyTrax", "api-key")
    .WithResponseFormat(ResponseFormat.Json)
    .ExecuteAsync();

Console.WriteLine($"Status: {assets.StatusCode}");
Console.WriteLine($"Assets: {assets.Body}");

? Enhanced HTTP Features

• 8 Authentication Types: Basic Auth, Bearer Token, API Key, OAuth2, Header Auth, Query Auth, OAuth1, Digest Auth
• SSL/TLS Configuration: Custom certificates, SSL validation control
• Proxy Support: HTTP/HTTPS proxy with authentication
• Response Formats: JSON (auto-parsed), String, Binary, File download
• Builder Pattern API: Fluent interface for easy configuration
• Comprehensive Response Info: Status, headers, duration, content type, etc.
• Advanced Error Handling: Configurable response code handling
• Enterprise Ready: Timeouts, redirects, custom headers, query parameters

Project Structure

NodeWorks/
??? NodeWorks.sln                  # Solution file
??? NodeWorks/                     # Main library project
?   ??? NodeWorks.csproj
?   ??? Core/                      # Core base classes
?   ?   ??? BaseNode.cs           # Base node implementations
?   ??? Nodes/                     # Node implementations
?   ?   ??? Data/                  # Data processing nodes
?   ?   ?   ??? ExtractNode.cs    # Property extraction
?   ?   ?   ??? TransformNode.cs  # Data transformation
?   ?   ??? Http/                  # **Enhanced HTTP nodes**
?   ?   ?   ??? RequestNode.cs    # **Advanced HTTP request handling**
?   ?   ?   ??? HttpRequestBuilder.cs # **Fluent API builder**
?   ?   ?   ??? HttpRequestTypes.cs   # **Type definitions**
?   ?   ??? String/                # **New: String processing nodes**
?   ?   ?   ??? StringProcessingNodes.cs # **Text manipulation**
?   ?   ??? Logic/                 # **New: Conditional logic nodes**
?   ?   ?   ??? ConditionalNodes.cs  # **Decision making**
?   ?   ??? DateTimeProcessing/    # **New: Date/time nodes**
?   ?   ?   ??? DateTimeNodes.cs  # **Date arithmetic & formatting**
?   ?   ??? File/                  # **New: File operation nodes**
?   ?   ?   ??? FileOperationNodes.cs # **File I/O & CSV**
?   ?   ??? Collection/            # **New: Collection processing nodes**
?   ?   ?   ??? CollectionNodes.cs # **Array/list operations**
?   ?   ??? Json/                  # JSON processing nodes
?   ?   ?   ??? JsonDeserializeNode.cs
?   ?   ??? Math/                  # Mathematical operations
?   ?       ??? AggregateNodes.cs      # Sum, Average, Min, Max
?   ?       ??? ArithmeticNodes.cs     # Add, Subtract, Multiply, etc.
?   ?       ??? BaseMathNode.cs        # Base math node classes
?   ?       ??? SingleValueNodes.cs    # Sqrt, Abs, Round, etc.
?   ?       ??? TrigonometricNodes.cs  # Sin, Cos, Tan, Log
??? NodeWorks.Tests/               # Test project with comprehensive examples
    ??? NodeWorks.Tests.csproj
    ??? Program.cs                # Main test examples
    ??? Models/                   # Test model classes
    ?   ??? TestModels.cs
    ??? Examples/                 # **Enhanced with comprehensive examples**
    ?   ??? Example1_OriginalPattern.cs
    ?   ??? Example2_DirectPropertyConfiguration.cs
    ?   ??? Example3_MathOperations.cs
    ?   ??? Example4_DataExtractionChain.cs
    ?   ??? Example5_TransformData.cs
    ?   ??? Example6_ComplexProcessingPipeline.cs
    ?   ??? EnhancedHttpRequestExamples.cs # **HTTP examples**
    ?   ??? EazyTraxApiExamples.cs        # **Real API integration**
    ?   ??? NewNodeTypesExamples.cs       # **New workflow nodes**
    ?   ??? SimpleEazyTraxExample.cs      # **Simple API example**
    ?   ??? PracticalExamples.cs
    ?   ??? ExampleIndex.cs
    ??? EXAMPLES.md              # Comprehensive example documentation
    ??? ENHANCED_HTTP_NODE.md    # **HTTP node documentation**
    ??? NEW_NODE_TYPES.md        # **New workflow nodes documentation**
    ??? EAZYTRAX_INTEGRATION.md  # **Real API integration guide**
    ??? REORGANIZATION_SUMMARY.md

Features

?? String Processing Nodes (New!)

• ConcatenateNode: Combine strings with separators
• SplitNode: Split strings into arrays
• ReplaceNode: Text replacement with regex support
• FormatNode: Template-based string formatting
• StringManipulationNode: Case conversion, trimming, transformations
• StringValidationNode: Email, URL, phone number validation

?? Conditional Logic Nodes (New!)

• ConditionalNode: If-then-else logic operations
• SwitchNode: Multi-case conditional logic
• BooleanLogicNode: AND, OR, NOT, XOR operations
• FilterNode: Collection filtering based on conditions

?? Date/Time Processing Nodes (New!)

• CurrentDateTimeNode: Current date/time with timezone support
• DateTimeFormatNode: Parse and format date/time strings
• DateTimeArithmeticNode: Add/subtract time periods
• DateTimeExtractNode: Extract parts (year, month, quarter, etc.)
• DateTimeValidationNode: Validate dates and check conditions

?? File Operation Nodes (New!)

• ReadFileNode: Read files as text, binary, base64, or lines
• WriteFileNode: Write content with various modes (overwrite, append)
• FileOperationNode: Copy, move, delete, list files/directories
• CsvNode: Read and write CSV files with header support

?? Collection Processing Nodes (New!)

• MapNode: Transform collections with custom functions
• ReduceNode: Reduce collections to single values
• SortNode: Sort by properties with numeric/string comparison
• GroupByNode: Group collections by specified criteria
• SliceNode: Take/skip elements from collections
• JoinCollectionsNode: Combine multiple collections
• UniqueNode: Find distinct elements in collections

?? Enhanced HTTP Operations

• RequestNode: Advanced HTTP requests with n8n-like capabilities
• HttpRequestBuilder: Fluent API for easy request configuration
• Multiple Authentication: Basic, Bearer, API Key, OAuth2, Header, Query, OAuth1, Digest
• SSL/TLS Support: Custom certificates, validation control
• Proxy Support: HTTP/HTTPS proxy with authentication
• Response Handling: JSON auto-parsing, String, Binary, File formats
• Enterprise Features: Timeouts, redirects, custom headers, error handling

?? Data Processing

• ExtractNode: Extract values from objects using property paths
• TransformNode: Transform data using custom functions

?? JSON Processing

• JsonDeserializeNode: Deserialize JSON strings to objects
• JsonDeserializeNode<T>: Strongly-typed JSON deserialization

?? Mathematical Operations

Basic Arithmetic

• AddNode: Addition
• SubtractNode: Subtraction
• MultiplyNode: Multiplication
• DivideNode: Division (with zero-division protection)
• PowerNode: Exponentiation
• ModuloNode: Modulo operation

Single Value Operations

• SquareRootNode: Square root calculation
• AbsoluteNode: Absolute value
• RoundNode: Rounding with configurable decimal places
• CeilingNode: Ceiling operation
• FloorNode: Floor operation
• ExponentialNode: Exponential (e^x)

Trigonometric Functions

• SinNode: Sine (with degree/radian support)
• CosNode: Cosine (with degree/radian support)
• TanNode: Tangent (with degree/radian support)
• LogarithmNode: Logarithm with configurable base

Aggregate Operations

• SumNode: Sum of collections
• AverageNode: Average of collections
• MinNode: Minimum value in collections
• MaxNode: Maximum value in collections

Quick Start Examples

?? New Workflow Node Types (New!)

// Data validation pipeline
var emailValidation = new StringValidationNode();
emailValidation.ValidationPattern = StringValidationNode.ValidationType.Email;
var isValid = emailValidation.Execute();

// Conditional processing
var ageCheck = new ConditionalNode();
ageCheck.Operator = ConditionalNode.ComparisonOperator.GreaterThan;
ageCheck.CompareValue = 18;
var eligibility = ageCheck.Execute();

// Date arithmetic
var futureDate = new DateTimeArithmeticNode();
futureDate.OperationType = DateTimeArithmeticNode.Operation.Add;
futureDate.Unit = DateTimeArithmeticNode.TimeUnit.Days;
futureDate.Value = 30;
var result = (DateTime)futureDate.Execute();

// File processing
var csvReader = new CsvNode();
csvReader.Operation = CsvNode.CsvOperation.Read;
csvReader.FilePath = "data.csv";
csvReader.HasHeaders = true;
var data = csvReader.Execute();

// Collection transformation
var mapNode = new MapNode(item => new { 
    processed = true, 
    timestamp = DateTime.Now,
    original = item 
});
var transformed = (object[])mapNode.Execute();

?? EazyTrax API Integration

// Fetch inventory assets with comprehensive error handling
var response = await HttpRequest.Get("https://lab.eazytrax.com/api/inventory/assets/all")
    .WithApiKey("EazyTrax", "api-key")
    .WithTimeout(30)
    .WithResponseFormat(ResponseFormat.Json)
    .WithFullResponse(true)
    .ExecuteAsync();

if (response.IsSuccess)
{
    Console.WriteLine($"? Fetched {response.ContentLength} bytes in {response.Duration.TotalMilliseconds}ms");
    ProcessAssetData(response.Body);
}

?? Math Operations

// Basic arithmetic from object properties
var seedData = new { a = 10, b = 3 };

var addNode = new AddNode();
addNode.Input = seedData;
var sum = (double)addNode.Execute(); // 13

// Array operations
var numbers = new { values = new double[] { 1, 2, 3, 4, 5 } };

var sumNode = new SumNode();
sumNode.Input = numbers;
var total = (double)sumNode.Execute(); // 15

?? Data Transformation

var transformNode = new TransformNode<User, UserSummary>(user => new UserSummary
{
    DisplayName = $"{user.Name} ({user.Id})",
    EmailDomain = user.Email.Split('@').LastOrDefault()
});

transformNode.Input = user;
var summary = (UserSummary)transformNode.Execute();

?? Comprehensive Documentation

• EXAMPLES.md - Complete documentation of all test examples
• ENHANCED_HTTP_NODE.md - Detailed HTTP node documentation
• NEW_NODE_TYPES.md - New: Comprehensive workflow nodes documentation
• EAZYTRAX_INTEGRATION.md - Real API integration guide
• Program.cs - Main test examples
• NewNodeTypesExamples.cs - New workflow nodes examples

?? Test Coverage

The test project includes:

• ? All 6 original examples (updated for enhanced HTTP)
• ? Enhanced HTTP request examples
• ? New workflow node type examples (new!)
  • String processing operations (6 node types)
  • Conditional logic operations (4 node types)
  • Date/time processing operations (5 node types)
  • File operations including CSV (4 node types)
  • Collection processing operations (7 node types)
• ? Real API integration examples (EazyTrax)
• ? Error handling demonstrations
• ? Async operation patterns
• ? Statistical analysis examples
• ? Data transformation pipelines
• ? Chained mathematical operations

Requirements

• .NET 9.0
• Newtonsoft.Json 13.0.3

Building

dotnet build

Running Examples

All Examples

dotnet run --project NodeWorks.Tests

Specific Example Sets

# EazyTrax examples only
dotnet run --project NodeWorks.Tests eazytrax

# New workflow node types only  
dotnet run --project NodeWorks.Tests newnodes

This will execute comprehensive examples including 26+ new workflow node types that cover the most frequently used operations in developer workflows.

?? What's New

Enhanced HTTP Request Node

• n8n-inspired comprehensive HTTP capabilities
• 8 authentication types including OAuth2, JWT, API keys
• Enterprise features like SSL control, proxy support
• Fluent builder API for easy configuration
• Rich response information with timing, headers, status
• Multiple response formats with auto-parsing
• Production-ready error handling and timeouts

Frequently-Used Workflow Node Types (New!)

• 26+ new node types covering common workflow operations
• 5 major categories of functionality
• Consistent API patterns across all nodes
• Property path support with dot notation
• Robust error handling and validation
• Comprehensive test coverage with real examples
• Production-ready implementations

Real API Integration Examples

• EazyTrax API integration with working examples
• API key authentication with custom headers
• Comprehensive error handling and retry patterns
• Data processing pipelines using NodeWorks nodes
• Production-ready patterns for real-world usage

NodeWorks now provides enterprise-grade workflow capabilities with over 35+ node types covering HTTP requests, string processing, conditional logic, date/time operations, file handling, and collection processing - making it suitable for complex workflow automation while maintaining the simple, node-based architecture!