blokctl 1.2.0 → 1.4.0

package/dist/scaffold-repo/sdks/csharp/tests/Blok.Core.Tests/Node/NodeRegistryTests.cs

@@ -0,0 +1,145 @@
+using System.Text.Json;
+using FluentAssertions;
+using Blok.Core.Node;
+using Blok.Core.Testing;
+using Blok.Core.Types;
+using Xunit;
+
+namespace Blok.Core.Tests.Node;
+
+public class NodeRegistryTests
+{
+    private class EchoNode : INodeHandler
+    {
+        private readonly string _message;
+
+        public EchoNode(string message = "echo")
+        {
+            _message = message;
+        }
+
+        public Task<JsonElement> ExecuteAsync(Context ctx, Dictionary<string, JsonElement> config)
+        {
+            var json = JsonSerializer.Serialize(new { message = _message });
+            var element = JsonDocument.Parse(json).RootElement.Clone();
+            return Task.FromResult(element);
+        }
+    }
+
+    private class FailingNode : INodeHandler
+    {
+        public Task<JsonElement> ExecuteAsync(Context ctx, Dictionary<string, JsonElement> config)
+        {
+            throw new InvalidOperationException("intentional failure");
+        }
+    }
+
+    [Fact]
+    public void Register_ShouldAddNode()
+    {
+        var registry = new NodeRegistry();
+        registry.Register("echo", new EchoNode());
+
+        registry.Count.Should().Be(1);
+        registry.Get("echo").Should().NotBeNull();
+    }
+
+    [Fact]
+    public void Get_ShouldReturnNullForMissing()
+    {
+        var registry = new NodeRegistry();
+        registry.Get("missing").Should().BeNull();
+    }
+
+    [Fact]
+    public void NodeNames_ShouldReturnAllRegistered()
+    {
+        var registry = new NodeRegistry();
+        registry.Register("a", new EchoNode());
+        registry.Register("b", new EchoNode());
+
+        var names = registry.NodeNames();
+        names.Should().HaveCount(2);
+        names.Should().Contain("a");
+        names.Should().Contain("b");
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_ShouldReturnSuccessResult()
+    {
+        var registry = new NodeRegistry();
+        registry.Register("echo", new EchoNode("hello"));
+
+        var ctx = new MockContextBuilder().Build();
+        var request = new ExecutionRequest
+        {
+            Node = new NodeConfig { Name = "echo", Config = new Dictionary<string, JsonElement>() },
+            Context = ctx
+        };
+
+        var result = await registry.ExecuteAsync(request);
+
+        result.Success.Should().BeTrue();
+        result.Metrics.Should().NotBeNull();
+        result.Metrics!.DurationMs.Should().BeGreaterOrEqualTo(0);
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_ShouldReturnErrorForMissingNode()
+    {
+        var registry = new NodeRegistry();
+        var ctx = new MockContextBuilder().Build();
+        var request = new ExecutionRequest
+        {
+            Node = new NodeConfig { Name = "missing", Config = new Dictionary<string, JsonElement>() },
+            Context = ctx
+        };
+
+        var result = await registry.ExecuteAsync(request);
+
+        result.Success.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_ShouldCatchExceptions()
+    {
+        var registry = new NodeRegistry();
+        registry.Register("fail", new FailingNode());
+
+        var ctx = new MockContextBuilder().Build();
+        var request = new ExecutionRequest
+        {
+            Node = new NodeConfig { Name = "fail", Config = new Dictionary<string, JsonElement>() },
+            Context = ctx
+        };
+
+        var result = await registry.ExecuteAsync(request);
+
+        result.Success.Should().BeFalse();
+        result.Metrics.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void GetHealth_ShouldReturnHealthStatus()
+    {
+        var registry = new NodeRegistry("2.0.0");
+        registry.Register("a", new EchoNode());
+        registry.Register("b", new EchoNode());
+
+        var health = registry.GetHealth();
+
+        health.Status.Should().Be("healthy");
+        health.Version.Should().Be("2.0.0");
+        health.NodesLoaded.Should().HaveCount(2);
+    }
+
+    [Fact]
+    public void Register_ShouldOverwriteExisting()
+    {
+        var registry = new NodeRegistry();
+        registry.Register("echo", new EchoNode("first"));
+        registry.Register("echo", new EchoNode("second"));
+
+        registry.Count.Should().Be(1);
+    }
+}

package/dist/scaffold-repo/sdks/csharp/tests/Blok.Core.Tests/Testing/MockContextTests.cs

@@ -0,0 +1,153 @@
+using System.Text.Json;
+using FluentAssertions;
+using Blok.Core.Testing;
+using Xunit;
+
+namespace Blok.Core.Tests.Testing;
+
+public class MockContextTests
+{
+    [Fact]
+    public void DefaultContext_ShouldHaveDefaults()
+    {
+        var ctx = new MockContextBuilder().Build();
+
+        ctx.Id.Should().NotBeNullOrEmpty();
+        ctx.WorkflowName.Should().Be("test-workflow");
+        ctx.WorkflowPath.Should().Be("/workflows/test");
+        ctx.Request.Method.Should().Be("POST");
+        ctx.Request.Url.Should().Be("/test");
+        ctx.Request.BaseUrl.Should().Be("http://localhost:8080");
+    }
+
+    [Fact]
+    public void WithId_ShouldOverrideId()
+    {
+        var ctx = new MockContextBuilder()
+            .WithId("custom-id")
+            .Build();
+
+        ctx.Id.Should().Be("custom-id");
+    }
+
+    [Fact]
+    public void WithWorkflow_ShouldOverrideWorkflowNameAndPath()
+    {
+        var ctx = new MockContextBuilder()
+            .WithWorkflow("my-workflow", "/workflows/my")
+            .Build();
+
+        ctx.WorkflowName.Should().Be("my-workflow");
+        ctx.WorkflowPath.Should().Be("/workflows/my");
+    }
+
+    [Fact]
+    public void WithBody_FromString_ShouldSetBody()
+    {
+        var ctx = new MockContextBuilder()
+            .WithBody("{\"name\": \"test\"}")
+            .Build();
+
+        ctx.Request.Body.ValueKind.Should().Be(JsonValueKind.Object);
+        ctx.Request.Body.GetProperty("name").GetString().Should().Be("test");
+    }
+
+    [Fact]
+    public void WithBody_FromObject_ShouldSetBody()
+    {
+        var ctx = new MockContextBuilder()
+            .WithBody(new { name = "test", age = 30 })
+            .Build();
+
+        ctx.Request.Body.ValueKind.Should().Be(JsonValueKind.Object);
+        ctx.Request.Body.GetProperty("name").GetString().Should().Be("test");
+        ctx.Request.Body.GetProperty("age").GetInt32().Should().Be(30);
+    }
+
+    [Fact]
+    public void WithHeaders_ShouldSetHeaders()
+    {
+        var headers = new Dictionary<string, string>
+        {
+            { "Authorization", "Bearer token" },
+            { "Content-Type", "application/json" }
+        };
+        var ctx = new MockContextBuilder()
+            .WithHeaders(headers)
+            .Build();
+
+        ctx.Request.Headers.Should().HaveCount(2);
+        ctx.Request.Headers["Authorization"].Should().Be("Bearer token");
+    }
+
+    [Fact]
+    public void WithVar_ShouldSetContextVariable()
+    {
+        var ctx = new MockContextBuilder()
+            .WithVar("key", "value")
+            .WithVar("count", 42)
+            .Build();
+
+        ctx.Vars.Should().HaveCount(2);
+        ctx.GetVarString("key").Should().Be("value");
+        ctx.GetVar("count").Should().Be(42);
+    }
+
+    [Fact]
+    public void WithEnv_ShouldSetEnvironmentVariable()
+    {
+        var ctx = new MockContextBuilder()
+            .WithEnv("API_KEY", "secret")
+            .Build();
+
+        ctx.Env.Should().ContainKey("API_KEY");
+        ctx.Env["API_KEY"].Should().Be("secret");
+    }
+
+    [Fact]
+    public void WithMethod_ShouldSetMethod()
+    {
+        var ctx = new MockContextBuilder()
+            .WithMethod("GET")
+            .Build();
+
+        ctx.Request.Method.Should().Be("GET");
+    }
+
+    [Fact]
+    public void FluentChaining_ShouldWork()
+    {
+        var ctx = new MockContextBuilder()
+            .WithId("test-1")
+            .WithWorkflow("wf", "/wf")
+            .WithBody("{\"x\": 1}")
+            .WithMethod("PUT")
+            .WithVar("a", "b")
+            .WithEnv("K", "V")
+            .Build();
+
+        ctx.Id.Should().Be("test-1");
+        ctx.WorkflowName.Should().Be("wf");
+        ctx.Request.Method.Should().Be("PUT");
+        ctx.Vars.Should().ContainKey("a");
+        ctx.Env.Should().ContainKey("K");
+    }
+
+    [Fact]
+    public void Context_SetVar_ShouldWork()
+    {
+        var ctx = new MockContextBuilder().Build();
+        ctx.SetVar("runtime", "csharp");
+
+        ctx.GetVar("runtime").Should().Be("csharp");
+        ctx.GetVarString("runtime").Should().Be("csharp");
+    }
+
+    [Fact]
+    public void Context_GetVar_ShouldReturnNullForMissing()
+    {
+        var ctx = new MockContextBuilder().Build();
+        ctx.GetVar("missing").Should().BeNull();
+        ctx.GetVarString("missing").Should().BeNull();
+    }
+}

package/dist/scaffold-repo/sdks/csharp/tests/Blok.Core.Tests/TypedNodeTests.cs

@@ -0,0 +1,69 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text;
+using System.Text.Json;
+using Blok.Core.Errors;
+using Blok.Core.Node;
+using Blok.Core.Types;
+using FluentAssertions;
+using Xunit;
+
+namespace Blok.Core.Tests;
+
+public sealed record SearchInput([property: Required, MinLength(1)] string Query, int Limit = 10);
+
+public sealed record SearchOutput(IReadOnlyList<string> Results, int Count);
+
+public sealed class SearchNode : TypedNode<SearchInput, SearchOutput>
+{
+    public override string Name => "@acme/search";
+    public override string Description => "Full-text search";
+
+    public override Task<SearchOutput> RunAsync(Context ctx, SearchInput input)
+    {
+        var rows = Enumerable.Repeat(input.Query, input.Limit).ToList();
+        return Task.FromResult(new SearchOutput(rows, rows.Count));
+    }
+}
+
+public class TypedNodeTests
+{
+    private static readonly JsonSerializerOptions Web = new(JsonSerializerDefaults.Web);
+
+    private static Dictionary<string, JsonElement> Cfg(object o)
+    {
+        var json = JsonSerializer.Serialize(o, Web);
+        return JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json, Web)!;
+    }
+
+    [Fact]
+    public async Task ValidatesInputAndSerializesOutput()
+    {
+        var node = new SearchNode();
+        var result = await node.ExecuteAsync(new Context(), Cfg(new { query = "ada", limit = 2 }));
+        var output = result.Deserialize<SearchOutput>(Web)!;
+        output.Count.Should().Be(2);
+        output.Results[0].Should().Be("ada");
+    }
+
+    [Fact]
+    public async Task InvalidInputThrowsStructuredBlokError()
+    {
+        var node = new SearchNode();
+        // Query is [Required, MinLength(1)] → empty string fails DataAnnotations.
+        var act = async () => await node.ExecuteAsync(new Context(), Cfg(new { query = "" }));
+        var ex = await act.Should().ThrowAsync<BlokError>();
+        ex.Which.HttpStatus.Should().Be(400);
+        ex.Which.Code.Should().Be("NODE_INPUT_VALIDATION");
+    }
+
+    [Fact]
+    public void ReflectsSchemasAndDescription()
+    {
+        INodeReflector node = new SearchNode();
+        node.Description.Should().Be("Full-text search");
+
+        var inputSchema = Encoding.UTF8.GetString(node.InputSchemaJson());
+        inputSchema.Should().Contain("properties");
+        node.OutputSchemaJson().Length.Should().BeGreaterThan(0);
+    }
+}

package/dist/scaffold-repo/sdks/csharp/tests/Blok.Core.Tests/Types/ExecutionResultTests.cs

@@ -0,0 +1,110 @@
+using System.Text.Json;
+using FluentAssertions;
+using Blok.Core.Types;
+using Xunit;
+
+namespace Blok.Core.Tests.Types;
+
+public class ExecutionResultTests
+{
+    [Fact]
+    public void Ok_ShouldCreateSuccessResult()
+    {
+        var data = new { message = "hello" };
+        var result = ExecutionResult.Ok(data);
+
+        result.Success.Should().BeTrue();
+        result.Data.Should().NotBeNull();
+        result.Errors.Should().BeNull();
+        result.Logs.Should().BeNull();
+        result.Metrics.Should().BeNull();
+    }
+
+    [Fact]
+    public void Fail_ShouldCreateErrorResult()
+    {
+        var result = ExecutionResult.Fail("something broke");
+
+        result.Success.Should().BeFalse();
+        result.Data.Should().BeNull();
+        result.Errors.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void FailWithDetails_ShouldIncludeDetails()
+    {
+        var details = new { field = "name", reason = "required" };
+        var result = ExecutionResult.FailWithDetails("validation failed", details);
+
+        result.Success.Should().BeFalse();
+        result.Errors.Should().NotBeNull();
+
+        var json = JsonSerializer.Serialize(result.Errors);
+        json.Should().Contain("validation failed");
+        json.Should().Contain("name");
+    }
+
+    [Fact]
+    public void WithLogs_ShouldAttachLogs()
+    {
+        var logs = new List<string> { "step 1", "step 2" };
+        var result = ExecutionResult.Ok(new { done = true }).WithLogs(logs);
+
+        result.Logs.Should().NotBeNull();
+        result.Logs.Should().HaveCount(2);
+        result.Logs![0].Should().Be("step 1");
+    }
+
+    [Fact]
+    public void WithMetrics_ShouldAttachMetrics()
+    {
+        var metrics = new ExecutionMetrics
+        {
+            DurationMs = 12.5,
+            MemoryBytes = 1024
+        };
+        var result = ExecutionResult.Ok(new { done = true }).WithMetrics(metrics);
+
+        result.Metrics.Should().NotBeNull();
+        result.Metrics!.DurationMs.Should().Be(12.5);
+        result.Metrics.MemoryBytes.Should().Be(1024);
+        result.Metrics.CpuMs.Should().BeNull();
+    }
+
+    [Fact]
+    public void FluentChaining_ShouldWork()
+    {
+        var result = ExecutionResult.Ok(new { value = 42 })
+            .WithLogs(new List<string> { "log1" })
+            .WithMetrics(new ExecutionMetrics { DurationMs = 5.0 });
+
+        result.Success.Should().BeTrue();
+        result.Logs.Should().HaveCount(1);
+        result.Metrics!.DurationMs.Should().Be(5.0);
+    }
+
+    [Fact]
+    public void JsonSerialization_ShouldOmitNulls()
+    {
+        var result = ExecutionResult.Ok(new { msg = "hi" });
+        var json = JsonSerializer.Serialize(result);
+
+        json.Should().NotContain("logs");
+        json.Should().NotContain("metrics");
+        json.Should().NotContain("errors");
+        json.Should().Contain("success");
+        json.Should().Contain("data");
+    }
+
+    [Fact]
+    public void JsonSerialization_ShouldIncludeMetricsWhenPresent()
+    {
+        var result = ExecutionResult.Ok(new { msg = "hi" })
+            .WithMetrics(new ExecutionMetrics { DurationMs = 10.0 });
+
+        var json = JsonSerializer.Serialize(result);
+        json.Should().Contain("duration_ms");
+        json.Should().NotContain("cpu_ms");
+        json.Should().NotContain("memory_bytes");
+    }
+}

package/dist/scaffold-repo/sdks/csharp/tests/Blok.Core.Tests/Validation/SchemaValidatorTests.cs

@@ -0,0 +1,233 @@
+using System.Text.Json;
+using FluentAssertions;
+using Blok.Core.Validation;
+using Xunit;
+
+namespace Blok.Core.Tests.Validation;
+
+public class SchemaValidatorTests
+{
+    private readonly SchemaValidator _validator = new();
+
+    private static JsonElement Parse(string json) => JsonDocument.Parse(json).RootElement;
+
+    [Fact]
+    public void TypeValidation_StringShouldPass()
+    {
+        var errors = _validator.Validate(
+            Parse("\"hello\""),
+            Parse("{\"type\": \"string\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void TypeValidation_NumberShouldFail_WhenStringExpected()
+    {
+        var errors = _validator.Validate(
+            Parse("42"),
+            Parse("{\"type\": \"string\"}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("expected type \"string\"");
+    }
+
+    [Fact]
+    public void TypeValidation_NumberShouldPass()
+    {
+        var errors = _validator.Validate(
+            Parse("42"),
+            Parse("{\"type\": \"number\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void TypeValidation_BooleanShouldPass()
+    {
+        var errors = _validator.Validate(
+            Parse("true"),
+            Parse("{\"type\": \"boolean\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void TypeValidation_ObjectShouldPass()
+    {
+        var errors = _validator.Validate(
+            Parse("{}"),
+            Parse("{\"type\": \"object\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void TypeValidation_ArrayShouldPass()
+    {
+        var errors = _validator.Validate(
+            Parse("[]"),
+            Parse("{\"type\": \"array\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void TypeValidation_NullShouldPass()
+    {
+        var errors = _validator.Validate(
+            Parse("null"),
+            Parse("{\"type\": \"null\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void RequiredFields_ShouldPass_WhenAllPresent()
+    {
+        var errors = _validator.Validate(
+            Parse("{\"name\": \"John\", \"email\": \"john@example.com\"}"),
+            Parse("{\"type\": \"object\", \"required\": [\"name\", \"email\"]}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void RequiredFields_ShouldFail_WhenMissing()
+    {
+        var errors = _validator.Validate(
+            Parse("{\"name\": \"John\"}"),
+            Parse("{\"type\": \"object\", \"required\": [\"name\", \"email\"]}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("email");
+    }
+
+    [Fact]
+    public void StringConstraints_ShouldPass_WhenInRange()
+    {
+        var errors = _validator.Validate(
+            Parse("\"hello\""),
+            Parse("{\"type\": \"string\", \"minLength\": 2, \"maxLength\": 10}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void StringConstraints_ShouldFail_WhenTooShort()
+    {
+        var errors = _validator.Validate(
+            Parse("\"x\""),
+            Parse("{\"type\": \"string\", \"minLength\": 2, \"maxLength\": 10}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("less than minimum");
+    }
+
+    [Fact]
+    public void StringConstraints_ShouldFail_WhenTooLong()
+    {
+        var errors = _validator.Validate(
+            Parse("\"this is way too long\""),
+            Parse("{\"type\": \"string\", \"minLength\": 2, \"maxLength\": 10}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("exceeds maximum");
+    }
+
+    [Fact]
+    public void NumericConstraints_ShouldPass_WhenInRange()
+    {
+        var errors = _validator.Validate(
+            Parse("50"),
+            Parse("{\"type\": \"number\", \"minimum\": 0, \"maximum\": 100}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void NumericConstraints_ShouldFail_WhenBelowMinimum()
+    {
+        var errors = _validator.Validate(
+            Parse("-1"),
+            Parse("{\"type\": \"number\", \"minimum\": 0, \"maximum\": 100}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("less than minimum");
+    }
+
+    [Fact]
+    public void NumericConstraints_ShouldFail_WhenAboveMaximum()
+    {
+        var errors = _validator.Validate(
+            Parse("101"),
+            Parse("{\"type\": \"number\", \"minimum\": 0, \"maximum\": 100}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("exceeds maximum");
+    }
+
+    [Fact]
+    public void EnumValidation_ShouldPass_WhenValueInEnum()
+    {
+        var errors = _validator.Validate(
+            Parse("\"red\""),
+            Parse("{\"type\": \"string\", \"enum\": [\"red\", \"green\", \"blue\"]}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void EnumValidation_ShouldFail_WhenValueNotInEnum()
+    {
+        var errors = _validator.Validate(
+            Parse("\"yellow\""),
+            Parse("{\"type\": \"string\", \"enum\": [\"red\", \"green\", \"blue\"]}")
+        );
+        errors.Should().HaveCount(1);
+        errors[0].Should().Contain("enum");
+    }
+
+    [Fact]
+    public void NestedProperties_ShouldValidateRecursively()
+    {
+        var schema = Parse(@"{
+            ""type"": ""object"",
+            ""properties"": {
+                ""user"": {
+                    ""type"": ""object"",
+                    ""required"": [""name""],
+                    ""properties"": {
+                        ""name"": { ""type"": ""string"" }
+                    }
+                }
+            }
+        }");
+
+        var valid = Parse("{\"user\": {\"name\": \"John\"}}");
+        _validator.Validate(valid, schema).Should().BeEmpty();
+
+        var invalid = Parse("{\"user\": {}}");
+        _validator.Validate(invalid, schema).Should().HaveCount(1);
+    }
+
+    [Fact]
+    public void IntegerType_ShouldValidate()
+    {
+        var errors = _validator.Validate(
+            Parse("42"),
+            Parse("{\"type\": \"integer\"}")
+        );
+        errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void IntegerType_ShouldFail_ForFloat()
+    {
+        var errors = _validator.Validate(
+            Parse("3.14"),
+            Parse("{\"type\": \"integer\"}")
+        );
+        errors.Should().HaveCount(1);
+    }
+}