REslava.ResultFlow 1.54.0

REslava.ResultFlow

Track B — Library-agnostic source generator for automatic Mermaid pipeline diagrams — works with any fluent Result library.

Add [ResultFlow] to any fluent method → the diagram is injected as a comment by the IDE code action (no build needed), or accessed as a const string after build. Zero runtime overhead. Zero manual maintenance.

Ships with a built-in convention dictionary pre-configured for REslava.Result, ErrorOr, LanguageExt, and FluentResults. Any other library can be supported by adding a resultflow.json file to your project. Generates _Diagram and _TypeFlow constants.

Using REslava.Result? Use Track A — REslava.Result.Flow — for richer diagrams: typed error edges from body scanning, full type travel, and the complete constant set (_LayerView, _Stats, _ErrorSurface, _ErrorPropagation).

Installation

dotnet add package REslava.ResultFlow

No extra using required — the [ResultFlow] attribute is injected into your compilation automatically by the source generator.

Quick Start

[ResultFlow]
public async Task<Result<UserDto>> RegisterAsync(RegisterCommand cmd) =>
    await CreateUser(cmd)
        .EnsureAsync(IsEmailValid, new InvalidEmailError())
        .BindAsync(SaveUser)
        .TapAsync(SendWelcomeEmail)
        .MapAsync(ToDto);

Use the IDE code action to inject the diagram as a comment directly above the method — no build required:

/*
```mermaid
flowchart LR
    N0_EnsureAsync["EnsureAsync"]:::gatekeeper
    ...
```*/
[ResultFlow]
public async Task<Result<UserDto>> RegisterAsync(RegisterCommand cmd) => ...

Or access the generated constant after build and paste it into any Mermaid renderer:

string diagram = Generated.ResultFlow.UserService_Flows.RegisterAsync;
// Paste into mermaid.live, GitHub, Notion, VS Code, or your wiki

Generated Diagram Examples

Pipeline — guard, transforms, side effects, success/failure paths:

Node type legend — all node types with colors and shapes:

Each operation is color-coded by semantic role:

• Lavender — gatekeepers (Ensure) — can fail validation
• Mint — transforms (Bind / Map) — shape the result
• Vanilla — side effects (Tap) — fire-and-forget
• Soft pink — failure paths

Supported Libraries

The built-in convention dictionary covers the most popular Result libraries out of the box — no configuration needed:

Any unrecognized method is rendered as a generic operation node — the diagram is still generated.

Custom Method Classification — resultflow.json

Add a resultflow.json file to your project to classify custom or third-party methods. Config entries override the built-in dictionary.

{
  "mappings": [
    {
      "bind":       ["Chain", "AndThen"],
      "map":        ["Transform"],
      "tap":        ["Log", "Audit"],
      "gatekeeper": ["Require"],
      "terminal":   ["Fold"]
    }
  ]
}

Register it as an AdditionalFile in your .csproj:

<ItemGroup>
  <AdditionalFiles Include="resultflow.json" />
</ItemGroup>

Supported keys: bind, map, tap, tapOnFailure, gatekeeper, terminal.

Diagram Preview — VS Code Extension (v1.1.0)

Install REslava.Result Extensions from the VS Code Marketplace to get a ▶ Open diagram preview CodeLens above every [ResultFlow] method.

One click opens the rendered Mermaid diagram in a dedicated side panel — bundled renderer, works fully offline.

Panel features:

• Click any node to navigate to that line in your source (requires <ResultFlowLinkMode>vscode</ResultFlowLinkMode> in your .csproj)
• Source button — view and copy the raw Mermaid DSL
• Legend button — node colour guide and interaction hints
• SVG / PNG buttons — export the diagram to disk (PNG at 2× for high-DPI screens)

Code Action

The companion analyzer detects [ResultFlow] methods that are missing the diagram as a developer comment. A single-click code fix inserts the generated Mermaid diagram directly above the method body — so the diagram lives next to the code that produced it.

Debug Panel — ▶ Debug CodeLens (v1.53.0)

Make your class partial to unlock the FlowProxy — a generated wrapper that feeds the VS Code Debug panel with zero setup.

// Mark your class partial:
public partial class OrderService
{
    [ResultFlow]
    public Result<Order> Process(int userId, int productId) => ...
}

// Always-on tracing (full ring buffer — many methods, many calls):
var result = svc.Flow.Process(userId, productId);
ringBuffer.Save();   // → reslava-traces.json in bin/ — VSIX auto-loads

// Single-trace debug (one method, one execution):
svc.Flow.Debug.Process(userId, productId);
// → reslava-debug-Process.json saved automatically
// → VSIX file watcher fires → Debug panel opens with the trace

The Debug panel shows a trace list, node stepper, animated replay with diagram node highlight, and a file picker when multiple reslava-*.json files are present.

Advanced: For long-running or remote scenarios, add REslava.Result.Diagnostics to expose traces over HTTP (PipelineTraceHost.Start / MapResultFlowTraces).

Diagnostics

Documentation

Full documentation: reslava.github.io/nuget-package-reslava-result

MIT License | Works with any .NET project (netstandard2.0)