blokctl 1.2.0 → 1.4.0

package/dist/scaffold-repo/sdks/go/config_test.go

@@ -0,0 +1,129 @@
+package blok
+
+import (
+	"os"
+	"testing"
+)
+
+func TestDefaultConfig(t *testing.T) {
+	cfg := DefaultConfig()
+
+	if cfg.Port != 9001 {
+		t.Errorf("expected port 9001, got %d", cfg.Port)
+	}
+	if cfg.Host != "0.0.0.0" {
+		t.Errorf("expected host '0.0.0.0', got %q", cfg.Host)
+	}
+	if cfg.Version != "1.0.0" {
+		t.Errorf("expected version '1.0.0', got %q", cfg.Version)
+	}
+	if cfg.GRPCPort != 10001 {
+		t.Errorf("expected gRPC port 10001, got %d", cfg.GRPCPort)
+	}
+	if cfg.Transport != TransportHTTP {
+		t.Errorf("expected default transport http, got %q", cfg.Transport)
+	}
+	if cfg.ReadTimeoutSec != 30 {
+		t.Errorf("expected read timeout 30, got %d", cfg.ReadTimeoutSec)
+	}
+	if cfg.LogLevel != LogLevelInfo {
+		t.Errorf("expected INFO log level, got %v", cfg.LogLevel)
+	}
+	if cfg.EnableCORS {
+		t.Error("expected CORS disabled by default")
+	}
+}
+
+func TestLoadConfigFromEnvGRPCFields(t *testing.T) {
+	os.Setenv("GRPC_PORT", "10500")
+	os.Setenv("BLOK_TRANSPORT", "both")
+	defer func() {
+		os.Unsetenv("GRPC_PORT")
+		os.Unsetenv("BLOK_TRANSPORT")
+	}()
+
+	cfg := LoadConfigFromEnv()
+
+	if cfg.GRPCPort != 10500 {
+		t.Errorf("expected gRPC port 10500, got %d", cfg.GRPCPort)
+	}
+	if cfg.Transport != TransportBoth {
+		t.Errorf("expected transport both, got %q", cfg.Transport)
+	}
+}
+
+func TestLoadConfigFromEnvIgnoresInvalidTransport(t *testing.T) {
+	os.Setenv("BLOK_TRANSPORT", "telepathy")
+	defer os.Unsetenv("BLOK_TRANSPORT")
+
+	cfg := LoadConfigFromEnv()
+	if cfg.Transport != TransportHTTP {
+		t.Errorf("expected fallback to http, got %q", cfg.Transport)
+	}
+}
+
+func TestLoadConfigFromEnv(t *testing.T) {
+	// Set env vars
+	os.Setenv("PORT", "9090")
+	os.Setenv("HOST", "127.0.0.1")
+	os.Setenv("VERSION", "2.0.0")
+	os.Setenv("LOG_LEVEL", "DEBUG")
+	os.Setenv("ENABLE_CORS", "true")
+	os.Setenv("READ_TIMEOUT", "60")
+	defer func() {
+		os.Unsetenv("PORT")
+		os.Unsetenv("HOST")
+		os.Unsetenv("VERSION")
+		os.Unsetenv("LOG_LEVEL")
+		os.Unsetenv("ENABLE_CORS")
+		os.Unsetenv("READ_TIMEOUT")
+	}()
+
+	cfg := LoadConfigFromEnv()
+
+	if cfg.Port != 9090 {
+		t.Errorf("expected port 9090, got %d", cfg.Port)
+	}
+	if cfg.Host != "127.0.0.1" {
+		t.Errorf("expected host '127.0.0.1', got %q", cfg.Host)
+	}
+	if cfg.Version != "2.0.0" {
+		t.Errorf("expected version '2.0.0', got %q", cfg.Version)
+	}
+	if cfg.LogLevel != LogLevelDebug {
+		t.Errorf("expected DEBUG, got %v", cfg.LogLevel)
+	}
+	if !cfg.EnableCORS {
+		t.Error("expected CORS enabled")
+	}
+	if cfg.ReadTimeoutSec != 60 {
+		t.Errorf("expected read timeout 60, got %d", cfg.ReadTimeoutSec)
+	}
+}
+
+func TestLoadConfigFromEnvInvalidValues(t *testing.T) {
+	os.Setenv("PORT", "not-a-number")
+	os.Setenv("READ_TIMEOUT", "-5")
+	defer func() {
+		os.Unsetenv("PORT")
+		os.Unsetenv("READ_TIMEOUT")
+	}()
+
+	cfg := LoadConfigFromEnv()
+
+	// Should fall back to defaults
+	if cfg.Port != 9001 {
+		t.Errorf("expected default port 9001, got %d", cfg.Port)
+	}
+	// Negative timeout should be ignored
+	if cfg.ReadTimeoutSec != 30 {
+		t.Errorf("expected default read timeout 30, got %d", cfg.ReadTimeoutSec)
+	}
+}
+
+func TestServerConfigAddress(t *testing.T) {
+	cfg := ServerConfig{Host: "0.0.0.0", Port: 9001}
+	if cfg.Address() != "0.0.0.0:9001" {
+		t.Errorf("expected '0.0.0.0:9001', got %q", cfg.Address())
+	}
+}

package/dist/scaffold-repo/sdks/go/define_node.go

@@ -0,0 +1,87 @@
+package blok
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/invopop/jsonschema"
+)
+
+// NodeReflector is implemented by typed nodes (see DefineNode) to expose a
+// description + JSON Schema for the node catalog (GET /__blok/nodes) via gRPC
+// ListNodes (SPEC-B P4). Legacy map-based handlers don't implement it.
+type NodeReflector interface {
+	Description() string
+	InputSchemaJSON() []byte
+	OutputSchemaJSON() []byte
+}
+
+// typedNode is the generic, validated node produced by DefineNode.
+type typedNode[I any, O any] struct {
+	name        string
+	description string
+	run         func(ctx *Context, input I) (O, error)
+}
+
+// Execute unmarshals the raw config into the typed Input, runs the node, and
+// returns the typed Output. A decode failure becomes a structured BlokError.
+func (t *typedNode[I, O]) Execute(ctx *Context, config map[string]interface{}) (interface{}, error) {
+	raw, err := json.Marshal(config)
+	if err != nil {
+		return nil, t.validationError(err)
+	}
+	var input I
+	if err := json.Unmarshal(raw, &input); err != nil {
+		return nil, t.validationError(err)
+	}
+	return t.run(ctx, input)
+}
+
+func (t *typedNode[I, O]) validationError(cause error) error {
+	return NewError(CategoryValidation).
+		Code("NODE_INPUT_VALIDATION").
+		Message(fmt.Sprintf("Input validation failed for node '%s': %v", t.name, cause)).
+		HTTPStatus(400).
+		Node(t.name).
+		Build()
+}
+
+func (t *typedNode[I, O]) Description() string      { return t.description }
+func (t *typedNode[I, O]) InputSchemaJSON() []byte  { return reflectSchemaJSON[I]() }
+func (t *typedNode[I, O]) OutputSchemaJSON() []byte { return reflectSchemaJSON[O]() }
+
+// DefineNode builds a typed node (SPEC-B P4) — the Go equivalent of the
+// TypeScript defineNode / Python @node / Rust TypedNode. The raw config is
+// unmarshaled into the typed Input (a failure → structured BlokError, HTTP 400),
+// `run` receives the typed value, and the JSON Schema of Input/Output is
+// reflected (from struct + json/jsonschema tags) for the catalog.
+//
+// Register it like any handler: registry.Register("@acme/search", DefineNode(...)).
+//
+//	type Input struct {
+//	    Query string `json:"query" jsonschema:"minLength=1"`
+//	    Limit int    `json:"limit" jsonschema:"default=10"`
+//	}
+//	type Output struct {
+//	    Results []string `json:"results"`
+//	    Count   int      `json:"count"`
+//	}
+//	registry.Register("@acme/search", blok.DefineNode("@acme/search", "Full-text search",
+//	    func(ctx *blok.Context, in Input) (Output, error) {
+//	        rows := doSearch(in.Query, in.Limit)
+//	        return Output{Results: rows, Count: len(rows)}, nil
+//	    }))
+func DefineNode[I any, O any](name, description string, run func(ctx *Context, input I) (O, error)) NodeHandler {
+	return &typedNode[I, O]{name: name, description: description, run: run}
+}
+
+// reflectSchemaJSON returns the JSON-encoded JSON Schema for T, or nil on error.
+func reflectSchemaJSON[T any]() []byte {
+	r := &jsonschema.Reflector{DoNotReference: true, ExpandedStruct: true}
+	schema := r.Reflect(new(T))
+	b, err := json.Marshal(schema)
+	if err != nil {
+		return nil
+	}
+	return b
+}

package/dist/scaffold-repo/sdks/go/define_node_test.go

@@ -0,0 +1,75 @@
+package blok
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+type tdInput struct {
+	Query string `json:"query" jsonschema:"minLength=1"`
+	Limit int    `json:"limit"`
+}
+
+type tdOutput struct {
+	Results []string `json:"results"`
+	Count   int      `json:"count"`
+}
+
+func TestDefineNodeValidatesAndRuns(t *testing.T) {
+	h := DefineNode("@acme/search", "Full-text search", func(ctx *Context, in tdInput) (tdOutput, error) {
+		return tdOutput{Results: []string{in.Query, in.Query}, Count: in.Limit}, nil
+	})
+	out, err := h.Execute(&Context{}, map[string]interface{}{"query": "ada", "limit": 2})
+	if err != nil {
+		t.Fatal(err)
+	}
+	o, ok := out.(tdOutput)
+	if !ok {
+		t.Fatalf("expected tdOutput, got %T", out)
+	}
+	if o.Count != 2 || len(o.Results) != 2 || o.Results[0] != "ada" {
+		t.Fatalf("unexpected output: %+v", o)
+	}
+}
+
+func TestDefineNodeInvalidInputYieldsBlokError(t *testing.T) {
+	h := DefineNode("@acme/n", "", func(ctx *Context, in tdInput) (tdOutput, error) {
+		return tdOutput{}, nil
+	})
+	// `limit` is an int; a string can't unmarshal into it → structured error.
+	_, err := h.Execute(&Context{}, map[string]interface{}{"query": "x", "limit": "not-a-number"})
+	if err == nil {
+		t.Fatal("expected a validation error")
+	}
+	be, ok := err.(*BlokError)
+	if !ok {
+		t.Fatalf("expected *BlokError, got %T", err)
+	}
+	if be.HTTPStatus != 400 || be.Code != "NODE_INPUT_VALIDATION" {
+		t.Fatalf("unexpected error: status=%d code=%s", be.HTTPStatus, be.Code)
+	}
+}
+
+func TestDefineNodeReflection(t *testing.T) {
+	h := DefineNode("@acme/r", "desc", func(ctx *Context, in tdInput) (tdOutput, error) {
+		return tdOutput{}, nil
+	})
+	r, ok := h.(NodeReflector)
+	if !ok {
+		t.Fatal("DefineNode result must implement NodeReflector")
+	}
+	if r.Description() != "desc" {
+		t.Fatalf("description: %q", r.Description())
+	}
+	var inSchema map[string]interface{}
+	if err := json.Unmarshal(r.InputSchemaJSON(), &inSchema); err != nil {
+		t.Fatalf("input schema not valid JSON: %v", err)
+	}
+	props, _ := inSchema["properties"].(map[string]interface{})
+	if _, has := props["query"]; !has {
+		t.Fatalf("input schema missing 'query' property: %v", inSchema)
+	}
+	if len(r.OutputSchemaJSON()) == 0 {
+		t.Fatal("empty output schema")
+	}
+}

package/dist/scaffold-repo/sdks/go/errors.go

@@ -0,0 +1,104 @@
+package blok
+
+import "fmt"
+
+// ErrorCategory classifies the type of error that occurred.
+type ErrorCategory string
+
+const (
+	// ErrorCategoryValidation indicates a schema or input validation failure.
+	ErrorCategoryValidation ErrorCategory = "VALIDATION"
+	// ErrorCategoryExecution indicates an error during node execution.
+	ErrorCategoryExecution ErrorCategory = "EXECUTION"
+	// ErrorCategoryConfiguration indicates a misconfiguration.
+	ErrorCategoryConfiguration ErrorCategory = "CONFIGURATION"
+	// ErrorCategoryNetwork indicates a network or connectivity issue.
+	ErrorCategoryNetwork ErrorCategory = "NETWORK"
+	// ErrorCategoryNotFound indicates a requested resource was not found.
+	ErrorCategoryNotFound ErrorCategory = "NOT_FOUND"
+)
+
+// NodeError represents a structured error from node execution.
+type NodeError struct {
+	Message  string                 `json:"message"`
+	Code     int                    `json:"code"`
+	Category ErrorCategory          `json:"category"`
+	Details  map[string]interface{} `json:"details,omitempty"`
+	Cause    error                  `json:"-"`
+}
+
+// Error implements the error interface.
+func (e *NodeError) Error() string {
+	if e.Cause != nil {
+		return fmt.Sprintf("[%s] %s: %v", e.Category, e.Message, e.Cause)
+	}
+	return fmt.Sprintf("[%s] %s", e.Category, e.Message)
+}
+
+// Unwrap returns the underlying cause.
+func (e *NodeError) Unwrap() error {
+	return e.Cause
+}
+
+// ToMap converts the error to a map for serialization in ExecutionResult.
+func (e *NodeError) ToMap() map[string]interface{} {
+	m := map[string]interface{}{
+		"message":  e.Message,
+		"code":     e.Code,
+		"category": string(e.Category),
+	}
+	if e.Details != nil {
+		m["details"] = e.Details
+	}
+	if e.Cause != nil {
+		m["cause"] = e.Cause.Error()
+	}
+	return m
+}
+
+// NewValidationError creates a validation error.
+func NewValidationError(message string) *NodeError {
+	return &NodeError{
+		Message:  message,
+		Code:     400,
+		Category: ErrorCategoryValidation,
+	}
+}
+
+// NewExecutionError creates an execution error.
+func NewExecutionError(message string, cause error) *NodeError {
+	return &NodeError{
+		Message:  message,
+		Code:     500,
+		Category: ErrorCategoryExecution,
+		Cause:    cause,
+	}
+}
+
+// NewConfigurationError creates a configuration error.
+func NewConfigurationError(message string) *NodeError {
+	return &NodeError{
+		Message:  message,
+		Code:     500,
+		Category: ErrorCategoryConfiguration,
+	}
+}
+
+// NewNetworkError creates a network error.
+func NewNetworkError(message string, cause error) *NodeError {
+	return &NodeError{
+		Message:  message,
+		Code:     502,
+		Category: ErrorCategoryNetwork,
+		Cause:    cause,
+	}
+}
+
+// NewNotFoundError creates a not-found error.
+func NewNotFoundError(message string) *NodeError {
+	return &NodeError{
+		Message:  message,
+		Code:     404,
+		Category: ErrorCategoryNotFound,
+	}
+}

package/dist/scaffold-repo/sdks/go/errors_test.go

@@ -0,0 +1,95 @@
+package blok
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNodeErrorError(t *testing.T) {
+	err := NewExecutionError("something broke", errors.New("underlying cause"))
+
+	s := err.Error()
+	if s != "[EXECUTION] something broke: underlying cause" {
+		t.Errorf("unexpected error string: %q", s)
+	}
+}
+
+func TestNodeErrorWithoutCause(t *testing.T) {
+	err := NewValidationError("bad input")
+
+	s := err.Error()
+	if s != "[VALIDATION] bad input" {
+		t.Errorf("unexpected error string: %q", s)
+	}
+}
+
+func TestNodeErrorUnwrap(t *testing.T) {
+	cause := errors.New("root cause")
+	err := NewExecutionError("wrapper", cause)
+
+	unwrapped := errors.Unwrap(err)
+	if unwrapped != cause {
+		t.Errorf("expected unwrapped to be root cause, got %v", unwrapped)
+	}
+}
+
+func TestNodeErrorToMap(t *testing.T) {
+	err := &NodeError{
+		Message:  "test error",
+		Code:     400,
+		Category: ErrorCategoryValidation,
+		Details:  map[string]interface{}{"field": "name"},
+		Cause:    errors.New("cause"),
+	}
+
+	m := err.ToMap()
+
+	if m["message"] != "test error" {
+		t.Errorf("expected 'test error', got %v", m["message"])
+	}
+	if m["code"] != 400 {
+		t.Errorf("expected 400, got %v", m["code"])
+	}
+	if m["category"] != "VALIDATION" {
+		t.Errorf("expected 'VALIDATION', got %v", m["category"])
+	}
+	if m["details"] == nil {
+		t.Error("expected details to be present")
+	}
+	if m["cause"] != "cause" {
+		t.Errorf("expected 'cause', got %v", m["cause"])
+	}
+}
+
+func TestErrorFactories(t *testing.T) {
+	tests := []struct {
+		name     string
+		err      *NodeError
+		category ErrorCategory
+		code     int
+	}{
+		{"validation", NewValidationError("bad"), ErrorCategoryValidation, 400},
+		{"execution", NewExecutionError("fail", nil), ErrorCategoryExecution, 500},
+		{"configuration", NewConfigurationError("bad config"), ErrorCategoryConfiguration, 500},
+		{"network", NewNetworkError("timeout", nil), ErrorCategoryNetwork, 502},
+		{"not found", NewNotFoundError("missing"), ErrorCategoryNotFound, 404},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.err.Category != tt.category {
+				t.Errorf("expected category %v, got %v", tt.category, tt.err.Category)
+			}
+			if tt.err.Code != tt.code {
+				t.Errorf("expected code %d, got %d", tt.code, tt.err.Code)
+			}
+		})
+	}
+}
+
+func TestNodeErrorIsError(t *testing.T) {
+	var err error = NewValidationError("test")
+	if err == nil {
+		t.Error("NodeError should implement error interface")
+	}
+}

package/dist/scaffold-repo/sdks/go/examples/nodes/apicall.go

@@ -0,0 +1,117 @@
+package nodes
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	blok "github.com/nickincloud/blok-go"
+)
+
+// ApiCallNode makes HTTP requests to external APIs.
+//
+// Config:
+//   - url (string, required): The URL to call
+//   - method (string, optional): HTTP method (default: GET)
+//   - headers (map[string]string, optional): Additional headers
+//   - timeout (number, optional): Timeout in seconds (default: 10)
+//
+// Input (request body):
+//   - body (any, optional): Request body for POST/PUT/PATCH
+//
+// Output:
+//   - status (number): HTTP status code
+//   - data (any): Parsed response body
+//   - headers (map[string]string): Response headers
+type ApiCallNode struct{}
+
+// Execute performs the HTTP request.
+func (n *ApiCallNode) Execute(ctx *blok.Context, config map[string]interface{}) (interface{}, error) {
+	// Get URL from config (required)
+	url, ok := config["url"].(string)
+	if !ok || url == "" {
+		return nil, blok.NewConfigurationError("'url' is required in node config")
+	}
+
+	// Get method from config, default to GET
+	method := "GET"
+	if v, ok := config["method"].(string); ok && v != "" {
+		method = strings.ToUpper(v)
+	}
+
+	// Get timeout from config, default to 10 seconds
+	timeout := 10
+	if v, ok := config["timeout"].(float64); ok && v > 0 {
+		timeout = int(v)
+	}
+
+	// Prepare request body
+	var reqBody io.Reader
+	if body := ctx.Request.BodyMap(); body != nil {
+		if bodyData, exists := body["body"]; exists && bodyData != nil {
+			jsonData, err := json.Marshal(bodyData)
+			if err != nil {
+				return nil, blok.NewExecutionError("failed to marshal request body", err)
+			}
+			reqBody = bytes.NewBuffer(jsonData)
+		}
+	}
+
+	// Create HTTP request
+	req, err := http.NewRequest(method, url, reqBody)
+	if err != nil {
+		return nil, blok.NewNetworkError(fmt.Sprintf("failed to create request to %s", url), err)
+	}
+
+	// Set headers from config
+	if headers, ok := config["headers"].(map[string]interface{}); ok {
+		for k, v := range headers {
+			if s, ok := v.(string); ok {
+				req.Header.Set(k, s)
+			}
+		}
+	}
+
+	if reqBody != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	// Execute request
+	client := &http.Client{
+		Timeout: time.Duration(timeout) * time.Second,
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, blok.NewNetworkError(fmt.Sprintf("request to %s failed", url), err)
+	}
+	defer resp.Body.Close()
+
+	// Read response body
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, blok.NewNetworkError("failed to read response body", err)
+	}
+
+	// Try to parse as JSON, fall back to string
+	var responseData interface{}
+	if err := json.Unmarshal(respBody, &responseData); err != nil {
+		responseData = string(respBody)
+	}
+
+	// Collect response headers
+	respHeaders := make(map[string]string)
+	for k := range resp.Header {
+		respHeaders[k] = resp.Header.Get(k)
+	}
+
+	return map[string]interface{}{
+		"status":  resp.StatusCode,
+		"data":    responseData,
+		"headers": respHeaders,
+	}, nil
+}

package/dist/scaffold-repo/sdks/go/examples/nodes/blokerrordemo.go

@@ -0,0 +1,80 @@
+package nodes
+
+import (
+	"errors"
+	"fmt"
+
+	blok "github.com/nickincloud/blok-go"
+)
+
+// BlokErrorDemoNode demonstrates the structured BlokError API per master
+// plan §17. Used by the cross-language E2E test (`go-grpc.integration.test.ts`)
+// to verify that a Go-side structured error flows through the gRPC wire to
+// the runner with every field preserved.
+//
+// Triggered via the `mode` config:
+//
+//   - mode="dependency" (default) — returns BlokError.dependency with a cause
+//     chain rooted in a vanilla Go error.
+//   - mode="rate-limit" — returns BlokError.rate_limit with retry_after_ms.
+//   - mode="validation" — returns BlokError.validation with details.issues.
+//   - mode="ok" — returns success.
+type BlokErrorDemoNode struct{}
+
+// Execute matches the blok.NodeHandler signature.
+func (n *BlokErrorDemoNode) Execute(ctx *blok.Context, config map[string]interface{}) (interface{}, error) {
+	mode, _ := config["mode"].(string)
+	if mode == "" {
+		mode = "dependency"
+	}
+
+	if mode == "ok" {
+		return map[string]interface{}{"ok": true, "language": "go"}, nil
+	}
+
+	snapshot := blok.BuildContextSnapshot(config, ctx.Vars)
+
+	if mode == "rate-limit" {
+		return nil, blok.NewError(blok.CategoryRateLimit).
+			Code("UPSTREAM_RATE_LIMITED").
+			Message("Upstream API returned 429").
+			Description("GitHub API rate limit hit (5000 req/hr).").
+			Remediation("Wait until the X-RateLimit-Reset header timestamp.").
+			RetryAfterMs(60_000).
+			DocURL("https://docs.example.com/errors/rate-limit").
+			Details(map[string]interface{}{"limit": 5000, "remaining": 0}).
+			ContextSnapshot(snapshot).
+			Build()
+	}
+
+	if mode == "validation" {
+		return nil, blok.NewError(blok.CategoryValidation).
+			Code("VALIDATION_FAILED").
+			Message("2 validation issues").
+			Description("Inputs didn't match the node's schema.").
+			Remediation("Provide both `email` and `name`.").
+			Details(map[string]interface{}{
+				"issues": []map[string]interface{}{
+					{"path": []string{"email"}, "message": "Required"},
+					{"path": []string{"name"}, "message": "Required"},
+				},
+			}).
+			ContextSnapshot(snapshot).
+			Build()
+	}
+
+	// default: dependency with a cause chain
+	cause := errors.New("[Errno 61] Connection refused")
+	return nil, blok.NewError(blok.CategoryDependency).
+		Code("POSTGRES_CONNECT_TIMEOUT").
+		Message("Could not connect to Postgres within 5s").
+		Description(fmt.Sprintf("Tried host=%s port=%d; timeout=%dms", "db.internal", 5432, 5000)).
+		Remediation("Check DATABASE_URL env var and network reachability").
+		Cause(cause).
+		Retryable(true).
+		RetryAfterMs(5_000).
+		DocURL("https://docs.example.com/errors/POSTGRES_CONNECT_TIMEOUT").
+		Details(map[string]interface{}{"host": "db.internal", "port": 5432, "timeout_ms": 5000}).
+		ContextSnapshot(snapshot).
+		Build()
+}