implement fluent builder pattern

Author: ezynda3

README.md

@@ -100,6 +100,43 @@ func main() {
 }
 ```
 
+### Builder Pattern (New)
+
+Flyt now supports a fluent builder pattern for creating nodes:
+
+```go
+node := flyt.NewNode().
+    WithMaxRetries(3).
+    WithWait(time.Second).
+    WithExecFunc(func(ctx context.Context, prepResult flyt.Result) (flyt.Result, error) {
+        fmt.Println("Hello from builder pattern!")
+        return flyt.R("done"), nil
+    })
+
+// The Build() method is optional since NodeBuilder implements Node
+// node := flyt.NewNode().WithExecFunc(fn).Build()
+```
+
+You can mix traditional and builder patterns:
+
+```go
+// Start with traditional options
+node := flyt.NewNode(
+    flyt.WithMaxRetries(3),
+    flyt.WithWait(time.Second),
+)
+
+// Continue with builder pattern
+node = node.
+    WithExecFunc(func(ctx context.Context, prepResult flyt.Result) (flyt.Result, error) {
+        return flyt.R("processed"), nil
+    }).
+    WithPostFunc(func(ctx context.Context, shared *flyt.SharedStore, prepResult, execResult flyt.Result) (flyt.Action, error) {
+        shared.Set("result", execResult.Value())
+        return flyt.DefaultAction, nil
+    })
+```
+
 ## Core Concepts
 
 ### Nodes
@@ -282,6 +319,31 @@ The type-safe getters handle numeric conversions automatically:
 
 ## Intermediate Patterns
 
+### Creating Nodes with Builder Pattern
+
+The builder pattern provides a fluent interface for creating nodes:
+
+```go
+node := flyt.NewNode().
+    WithMaxRetries(3).
+    WithWait(time.Second).
+    WithPrepFunc(func(ctx context.Context, shared *flyt.SharedStore) (flyt.Result, error) {
+        // Read input data
+        data := shared.Get("input")
+        return flyt.NewResult(data), nil
+    }).
+    WithExecFunc(func(ctx context.Context, prepResult flyt.Result) (flyt.Result, error) {
+        // Process data
+        result := processData(prepResult.Value())
+        return flyt.NewResult(result), nil
+    }).
+    WithPostFunc(func(ctx context.Context, shared *flyt.SharedStore, prepResult, execResult flyt.Result) (flyt.Action, error) {
+        // Store result
+        shared.Set("output", execResult.Value())
+        return flyt.DefaultAction, nil
+    })
+```
+
 ### Configuration via Closures
 
 Pass configuration to nodes using closures:

builder.go

@@ -0,0 +1,129 @@
+package flyt
+
+import (
+	"context"
+	"time"
+)
+
+// NodeBuilder provides a fluent interface for creating and configuring nodes.
+// It implements the Node interface while also providing chainable methods
+// for configuration. This allows both styles:
+//   - Traditional: flyt.NewNode(WithExecFunc(...), WithMaxRetries(3))
+//   - Builder: flyt.NewNode().WithExecFunc(...).WithMaxRetries(3)
+type NodeBuilder struct {
+	*CustomNode
+}
+
+// Prep implements Node.Prep by delegating to the embedded CustomNode
+func (b *NodeBuilder) Prep(ctx context.Context, shared *SharedStore) (any, error) {
+	return b.CustomNode.Prep(ctx, shared)
+}
+
+// Exec implements Node.Exec by delegating to the embedded CustomNode
+func (b *NodeBuilder) Exec(ctx context.Context, prepResult any) (any, error) {
+	return b.CustomNode.Exec(ctx, prepResult)
+}
+
+// Post implements Node.Post by delegating to the embedded CustomNode
+func (b *NodeBuilder) Post(ctx context.Context, shared *SharedStore, prepResult, execResult any) (Action, error) {
+	return b.CustomNode.Post(ctx, shared, prepResult, execResult)
+}
+
+// ExecFallback implements FallbackNode.ExecFallback by delegating to the embedded CustomNode
+func (b *NodeBuilder) ExecFallback(prepResult any, err error) (any, error) {
+	return b.CustomNode.ExecFallback(prepResult, err)
+}
+
+// GetMaxRetries implements RetryableNode.GetMaxRetries by delegating to the embedded BaseNode
+func (b *NodeBuilder) GetMaxRetries() int {
+	return b.CustomNode.BaseNode.GetMaxRetries()
+}
+
+// GetWait implements RetryableNode.GetWait by delegating to the embedded BaseNode
+func (b *NodeBuilder) GetWait() time.Duration {
+	return b.CustomNode.BaseNode.GetWait()
+}
+
+// WithMaxRetries sets the maximum number of retries for the node's Exec phase.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithMaxRetries(retries int) *NodeBuilder {
+	WithMaxRetries(retries)(b.CustomNode.BaseNode)
+	return b
+}
+
+// WithWait sets the wait duration between retries.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithWait(wait time.Duration) *NodeBuilder {
+	WithWait(wait)(b.CustomNode.BaseNode)
+	return b
+}
+
+// WithPrepFunc sets a custom Prep implementation using Result types.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithPrepFunc(fn func(context.Context, *SharedStore) (Result, error)) *NodeBuilder {
+	b.CustomNode.prepFunc = fn
+	return b
+}
+
+// WithExecFunc sets a custom Exec implementation using Result types.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithExecFunc(fn func(context.Context, Result) (Result, error)) *NodeBuilder {
+	b.CustomNode.execFunc = fn
+	return b
+}
+
+// WithPostFunc sets a custom Post implementation using Result types.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithPostFunc(fn func(context.Context, *SharedStore, Result, Result) (Action, error)) *NodeBuilder {
+	b.CustomNode.postFunc = fn
+	return b
+}
+
+// WithExecFallbackFunc sets a custom ExecFallback implementation.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithExecFallbackFunc(fn func(any, error) (any, error)) *NodeBuilder {
+	b.CustomNode.execFallbackFunc = fn
+	return b
+}
+
+// WithPrepFuncAny sets a custom Prep implementation using any types.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithPrepFuncAny(fn func(context.Context, *SharedStore) (any, error)) *NodeBuilder {
+	b.CustomNode.prepFunc = func(ctx context.Context, shared *SharedStore) (Result, error) {
+		val, err := fn(ctx, shared)
+		if err != nil {
+			return Result{}, err
+		}
+		return NewResult(val), nil
+	}
+	return b
+}
+
+// WithExecFuncAny sets a custom Exec implementation using any types.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithExecFuncAny(fn func(context.Context, any) (any, error)) *NodeBuilder {
+	b.CustomNode.execFunc = func(ctx context.Context, prepResult Result) (Result, error) {
+		val, err := fn(ctx, prepResult.Value())
+		if err != nil {
+			return Result{}, err
+		}
+		return NewResult(val), nil
+	}
+	return b
+}
+
+// WithPostFuncAny sets a custom Post implementation using any types.
+// Returns the builder for method chaining.
+func (b *NodeBuilder) WithPostFuncAny(fn func(context.Context, *SharedStore, any, any) (Action, error)) *NodeBuilder {
+	b.CustomNode.postFunc = func(ctx context.Context, shared *SharedStore, prepResult, execResult Result) (Action, error) {
+		return fn(ctx, shared, prepResult.Value(), execResult.Value())
+	}
+	return b
+}
+
+// Build returns the configured Node.
+// This method is optional as NodeBuilder already implements Node,
+// but it provides explicit intent when ending the builder chain.
+func (b *NodeBuilder) Build() Node {
+	return b
+}