@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/tm/csharp/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/csharp/core/Context.cs

@@ -1,5 +1,7 @@
 // ProjectName SDK - operation context.
 
+using System.Collections.Concurrent;
+
 using Voxgig.Struct;
 
 namespace ProjectNameSdk;
@@ -17,7 +19,7 @@ public class Context
     public Dictionary<string, object?>? Config;
     public Dictionary<string, object?>? Entopts;
     public Dictionary<string, object?>? Options;
-    public Dictionary<string, Operation> Opmap = new();
+    public ConcurrentDictionary<string, Operation> Opmap = new();
     public Response? Response;
     public Result? Result;
     public Spec? Spec;
@@ -145,7 +147,7 @@ public class Context
         }
 
         // Opmap
-        if (Helpers.GetCtxProp(ctxmap, "opmap") is Dictionary<string, Operation> opm)
+        if (Helpers.GetCtxProp(ctxmap, "opmap") is ConcurrentDictionary<string, Operation> opm)
         {
             Opmap = opm;
         }
@@ -153,7 +155,7 @@ public class Context
         {
             Opmap = basectx.Opmap;
         }
-        Opmap ??= new Dictionary<string, Operation>();
+        Opmap ??= new ConcurrentDictionary<string, Operation>();
 
         // Data maps
         Data = Helpers.ToMapAny(Helpers.GetCtxProp(ctxmap, "data")) ?? new Dictionary<string, object?>();
@@ -226,7 +228,7 @@ public class Context
         var opcfg = StructUtils.GetPath(Config,
             StructUtils.Jt("entity", entname, "op", opname));
 
-        var input = (opname == "update" || opname == "create") ? "data" : "match";
+        var input = (opname == "update" || opname == "create" || opname == "patch") ? "data" : "match";
 
         List<object?>? points = null;
         if (opcfg is Dictionary<string, object?> ocm)
@@ -246,8 +248,9 @@ public class Context
             ["points"] = points,
         });
 
-        Opmap[cacheKey] = op;
-        return op;
+        // Requests on other threads share this cache; every one of them gets
+        // the Operation stored first.
+        return Opmap.GetOrAdd(cacheKey, op);
     }
 
     public ProjectNameError MakeError(string code, string msg)

package/project/.sdk/tm/csharp/core/Helpers.cs

@@ -17,6 +17,23 @@ public static class Helpers
             $"operation '{opname}' not supported by entity '{entityname}'");
     }
 
+    // Whether a comma-separated allow option names the item: whole names, any case.
+    public static bool Allowed(object? names, string? item)
+    {
+        if (names is not string list || string.IsNullOrEmpty(item))
+        {
+            return false;
+        }
+        foreach (var name in list.Split(','))
+        {
+            if (string.Equals(name.Trim(), item, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public static Dictionary<string, object?>? ToMapAny(object? v)
     {
         return v as Dictionary<string, object?>;

package/project/.sdk/tm/csharp/core/Response.cs

@@ -1,5 +1,7 @@
 // ProjectName SDK - transport response wrapper.
 
+using System.Text.RegularExpressions;
+
 using Voxgig.Struct;
 
 namespace ProjectNameSdk;
@@ -13,6 +15,11 @@ public class Response
     public object? Body;
     public Exception? Err;
 
+    // Set by a transport that could not read a non-blank body as JSON.
+    public bool Unreadable;
+
+    private const int PreviewLength = 160;
+
     public Response(Dictionary<string, object?>? resmap)
     {
         resmap ??= new Dictionary<string, object?>();
@@ -41,5 +48,73 @@ public class Response
         {
             Err = er;
         }
+
+        Unreadable = StructUtils.GetProp(resmap, "unreadable") is true;
+    }
+
+    // A body that is not JSON. An HTTP failure keeps its own error, with the
+    // response described; otherwise the code tells a wrong content type from
+    // malformed JSON.
+    public static Exception UnreadableBody(Context ctx, int status, object? headers,
+        object? text, object? sent, Exception? failed)
+    {
+        var type = HeaderValue(headers, "content-type");
+        var agent = Clean(ctx, HeaderValue(sent, "user-agent"));
+        var detail = "HTTP " + status + ", content-type " + (type == "" ? "none" : type) +
+            ", user-agent " + (agent == "" ? "transport default" : agent) +
+            (text == null ? "" : ", body: " + Preview(ctx, text));
+
+        if (failed is ProjectNameError sdkErr)
+        {
+            sdkErr.SetMessage(sdkErr.Message + " (" + detail + ")");
+            return sdkErr;
+        }
+        if (failed != null)
+        {
+            return new Exception(failed.Message + " (" + detail + ")", failed);
+        }
+
+        return type == "" || type.Contains("json", StringComparison.OrdinalIgnoreCase)
+            ? ctx.MakeError("response_json_invalid", "response: body is not valid JSON (" + detail + ")")
+            : ctx.MakeError("response_content_type",
+                "response: expected JSON, got " + type + " (" + detail + ")");
+    }
+
+    private static string HeaderValue(object? headers, string name)
+    {
+        if (headers is IDictionary<string, object?> map)
+        {
+            foreach (var kv in map)
+            {
+                if (string.Equals(kv.Key, name, StringComparison.OrdinalIgnoreCase))
+                {
+                    return kv.Value?.ToString() ?? "";
+                }
+            }
+        }
+        return "";
+    }
+
+    private static string Clean(Context ctx, string s)
+    {
+        return ctx.Utility?.Clean(ctx, s)?.ToString() ?? s;
+    }
+
+    // Cleaned whole: a secret the bound would split could leave its prefix.
+    private static string Preview(Context ctx, object text)
+    {
+        var flat = Clean(ctx, Regex.Replace(text.ToString() ?? "", @"\s+", " ").Trim());
+        var count = 0;
+        var end = 0;
+        foreach (var rune in flat.EnumerateRunes())
+        {
+            if (count == PreviewLength)
+            {
+                return flat.Substring(0, end) + "...";
+            }
+            count++;
+            end += rune.Utf16SequenceLength;
+        }
+        return flat;
     }
 }

package/project/.sdk/tm/csharp/core/Spec.cs

@@ -17,6 +17,9 @@ public class Spec
     public object? Body;
     public string Url = "";
     public string Path = "";
+    // The query parameters PrepareAuth placed: the credential, which the
+    // request sends and the entity's match leaves out.
+    public List<string> AuthQuery = new();
 
     public Spec(Dictionary<string, object?>? specmap)
     {

package/project/.sdk/tm/csharp/feature/TestFeature.cs

@@ -58,6 +58,16 @@ public class TestFeature : BaseFeature
             {
                 if (data == null || ctx2.Point == null) { return data; }
                 var tm = StructUtils.GetProp(ctx2.Point, "transform");
+                var key = ItemEnvelopeKey(StructUtils.GetProp(tm, "res"));
+                if (key != null && data is System.Collections.IList items)
+                {
+                    var wrapped = new List<object?>();
+                    foreach (var item in items)
+                    {
+                        wrapped.Add(new Dictionary<string, object?> { [key] = item });
+                    }
+                    return wrapped;
+                }
                 if (StructUtils.GetProp(tm, "res") is not string spec) { return data; }
                 // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
                 // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
@@ -160,7 +170,7 @@ public class TestFeature : BaseFeature
                 var outval = StructUtils.Clone(found);
                 return Respond(200, outval, null);
             }
-            else if (op.Name == "update")
+            else if (op.Name == "update" || op.Name == "patch")
             {
                 // Match the existing entity by id only (or its alias).
                 // Reqdata also contains the new field values, which would
@@ -198,7 +208,7 @@ public class TestFeature : BaseFeature
                 }
                 if (ent is Dictionary<string, object?> && ctx2.Reqdata != null)
                 {
-                    StructUtils.Merge(new List<object?> { ent, ctx2.Reqdata });
+                    StructUtils.Merge(new List<object?> { ent, Record(ctx2.Reqdata) });
                 }
                 StructUtils.DelProp(ent, "$KEY");
                 var outval = StructUtils.Clone(ent);
@@ -226,7 +236,7 @@ public class TestFeature : BaseFeature
                     Random.Shared.Next(0x10000), Random.Shared.Next(0x10000),
                     Random.Shared.Next(0x10000), Random.Shared.Next(0x10000));
 
-                var ent = StructUtils.Clone(ctx2.Reqdata);
+                var ent = StructUtils.Clone(Record(ctx2.Reqdata));
                 if (ent is Dictionary<string, object?> entm)
                 {
                     entm["id"] = id;
@@ -328,6 +338,34 @@ public class TestFeature : BaseFeature
         };
     }
 
+    // The record the mock keeps: the request data without `$body`, which only the
+    // wire carries.
+    private static Dictionary<string, object?>? Record(Dictionary<string, object?>? reqdata)
+    {
+        if (reqdata == null)
+        {
+            return null;
+        }
+        var rec = new Dictionary<string, object?>(reqdata);
+        rec.Remove("$body");
+        return rec;
+    }
+
+    // The key a list's response transform
+    // ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+    private static string? ItemEnvelopeKey(object? restf)
+    {
+        if (restf is not System.Collections.IList spec || spec.Count != 3 ||
+            !"`$EACH`".Equals(spec[0]) || !"body".Equals(spec[1]) ||
+            spec[2] is not System.Collections.IDictionary child ||
+            child["`$MERGE`"] is not string merge)
+        {
+            return null;
+        }
+        var m = System.Text.RegularExpressions.Regex.Match(merge, "^`\\.([^.`$]+)`$");
+        return m.Success ? m.Groups[1].Value : null;
+    }
+
     private static object BuildArgs(Context ctx, Operation op, Dictionary<string, object?>? args)
     {
         var opname = op.Name;

package/project/.sdk/tm/csharp/feature/TimeoutFeature.cs

@@ -49,16 +49,44 @@ public class TimeoutFeature : BaseFeature
             return inner(ctx, url, fetchdef);
         }
 
-        var task = Task.Run(() => inner(ctx, url, fetchdef));
+        // The deadline runs from here, not from the wait below: a caller paused
+        // between the two would otherwise find a late response complete and
+        // take it. The worker notes when it finished, so a response or a
+        // failure after the deadline is a timeout however late the caller looks.
+        var now = FoptNow(_options);
+        var start = now();
+        long arrived = long.MaxValue;
+        var task = Task.Run(() =>
+        {
+            try
+            {
+                return inner(ctx, url, fetchdef);
+            }
+            finally
+            {
+                Interlocked.Exchange(ref arrived, now());
+            }
+        });
 
-        if (task == Task.WhenAny(task, Task.Delay(ms)).GetAwaiter().GetResult())
+        var remaining = Math.Max(0L, ms - (now() - start));
+        if (task == Task.WhenAny(task, Task.Delay(TimeSpan.FromMilliseconds(remaining)))
+            .GetAwaiter().GetResult())
         {
+            if (ms < Interlocked.Read(ref arrived) - start)
+            {
+                throw TimedOut(ctx, ms);
+            }
             // Unwraps any inner exception.
             return task.GetAwaiter().GetResult();
         }
 
+        throw TimedOut(ctx, ms);
+    }
+
+    private Exception TimedOut(Context ctx, int ms)
+    {
         Track(ms);
-        throw ctx.MakeError("timeout", $"Request exceeded timeout of {ms}ms");
+        return ctx.MakeError("timeout", $"Request exceeded timeout of {ms}ms");
     }
 
     private void Track(int ms)

package/project/.sdk/tm/csharp/feature/ValidateFeature.cs

@@ -207,6 +207,8 @@ public class ValidateFeature : BaseFeature
         // custom-action call would be rejected for the one key that made it
         // reachable.
         outmap.Remove("$action");
+        // Nor is `$body`, the raw request body.
+        outmap.Remove("$body");
 
         return outmap;
     }

package/project/.sdk/tm/csharp/test/ConcurrencyTest.cs

@@ -0,0 +1,238 @@
+// Requests in flight at once on one client. Each resolves its operation
+// through the cache the client's root context shares with every request, and
+// registers and cleans secrets through the one registry the client holds.
+
+using System.Collections.Concurrent;
+
+using Xunit;
+
+using ProjectNameSdk;
+
+namespace ProjectNameSdk.Test;
+
+public class ConcurrencyTest
+{
+    private const int Rounds = 200;
+    private const int Width = 8;
+    private const int Ops = 32;
+
+    private static Dictionary<string, object?> Answer(string url, Dictionary<string, object?> fetchdef)
+    {
+        return new Dictionary<string, object?>
+        {
+            ["status"] = 200,
+            ["statusText"] = "OK",
+            ["headers"] = new Dictionary<string, object?>(),
+            ["json"] = (Func<object?>)(() => new Dictionary<string, object?> { ["ok"] = true }),
+        };
+    }
+
+    // A live client whose transport answers at once.
+    private static ProjectNameSDK LiveClient()
+    {
+        return new ProjectNameSDK(new Dictionary<string, object?>
+        {
+            ["base"] = "http://concurrency.test/api",
+            ["allow"] = new Dictionary<string, object?> { ["op"] = "direct" },
+            ["system"] = new Dictionary<string, object?>
+            {
+                ["fetch"] = (Func<string, Dictionary<string, object?>,
+                    Dictionary<string, object?>>)Answer,
+            },
+        });
+    }
+
+    // Runs body on Width threads released together, and returns what they threw.
+    private static List<Exception> AtOnce(Action<int> body)
+    {
+        var start = new Barrier(Width);
+        var thrown = new ConcurrentQueue<Exception>();
+        var threads = new List<Thread>();
+        for (var i = 0; i < Width; i++)
+        {
+            var n = i;
+            var thread = new Thread(() =>
+            {
+                try
+                {
+                    start.SignalAndWait();
+                    body(n);
+                }
+                catch (Exception e)
+                {
+                    thrown.Enqueue(e);
+                }
+            });
+            thread.Start();
+            threads.Add(thread);
+        }
+        threads.ForEach(t => t.Join());
+        return thrown.ToList();
+    }
+
+    [Fact]
+    public void ConcurrentFirstRequestsSucceed()
+    {
+        for (var round = 0; round < Rounds; round++)
+        {
+            // A fresh client each round, so every request in it is a first request.
+            var client = LiveClient();
+            var results = new Dictionary<string, object?>?[Width];
+            var thrown = AtOnce(n =>
+                results[n] = client.Direct(new Dictionary<string, object?> { ["path"] = "p" + n }));
+
+            Assert.True(0 == thrown.Count, "round " + round + " threw:\n" + string.Join("\n", thrown));
+            for (var n = 0; n < Width; n++)
+            {
+                var res = results[n];
+                Assert.True(Equals(true, res?["ok"]), "round " + round + ", request " + n +
+                    " failed: " + (res?.GetValueOrDefault("err") ?? "no result"));
+            }
+        }
+    }
+
+    [Fact]
+    public void ConcurrentResolutionsShareOneCachedOperation()
+    {
+        for (var round = 0; round < Rounds; round++)
+        {
+            var client = LiveClient();
+            var utility = client.GetUtility();
+            var root = client.GetRootCtx();
+            var ops = new Operation?[Width, Ops];
+            var thrown = AtOnce(n =>
+            {
+                for (var k = 0; k < Ops; k++)
+                {
+                    ops[n, k] = utility.MakeContext(
+                        new Dictionary<string, object?> { ["opname"] = "op" + k }, root).Op;
+                }
+            });
+
+            Assert.True(0 == thrown.Count, "round " + round + " threw:\n" + string.Join("\n", thrown));
+            for (var k = 0; k < Ops; k++)
+            {
+                var cached = utility.MakeContext(
+                    new Dictionary<string, object?> { ["opname"] = "op" + k }, root).Op;
+                for (var n = 0; n < Width; n++)
+                {
+                    Assert.True(ReferenceEquals(cached, ops[n, k]),
+                        "round " + round + ": op" + k + " resolved to more than one Operation");
+                }
+            }
+        }
+    }
+
+    private static string AddedSecret(int round, int n, int k)
+    {
+        return "ADDED-SECRET-" + round + "-" + n + "-" + k;
+    }
+
+    // Registers thread n's secrets, then counts the thread out of registering.
+    private static void RegisterSecrets(Utility utility, Context root, int round, int n,
+        CountdownEvent registering)
+    {
+        try
+        {
+            for (var k = 0; k < Ops; k++)
+            {
+                utility.CleanAdd(root, AddedSecret(round, n, k));
+            }
+        }
+        finally
+        {
+            registering.Signal();
+        }
+    }
+
+    private static void AssertEverySecretMasked(Utility utility, Context root, int round)
+    {
+        for (var n = 0; n < Width / 2; n++)
+        {
+            for (var k = 0; k < Ops; k++)
+            {
+                var added = AddedSecret(round, n, k);
+                Assert.True("[redacted]" == utility.Clean(root, added) as string,
+                    "round " + round + ": " + added + " was registered but not masked");
+            }
+        }
+    }
+
+    // Secrets registered on some threads while others clean: every clean
+    // masks what was registered before it, the longer secret whole, and no
+    // registration is lost.
+    [Fact]
+    public void ConcurrentRegistrationKeepsEverySecretMasked()
+    {
+        for (var round = 0; round < Rounds / 4; round++)
+        {
+            var client = LiveClient();
+            var utility = client.GetUtility();
+            var root = client.GetRootCtx();
+            var inner = "INNER-SECRET-" + round;
+            utility.CleanAdd(root, inner);
+            utility.CleanAdd(root, "OUTER-" + inner + "-TAIL");
+            var text = "a " + inner + " b OUTER-" + inner + "-TAIL c";
+            Assert.Equal("a [redacted] b [redacted] c", utility.Clean(root, text));
+
+            var registering = new CountdownEvent(Width / 2);
+            var wrong = new ConcurrentQueue<string>();
+            var thrown = AtOnce(n =>
+            {
+                if (n < Width / 2)
+                {
+                    RegisterSecrets(utility, root, round, n, registering);
+                    return;
+                }
+                while (!registering.IsSet)
+                {
+                    var got = utility.Clean(root, text) as string;
+                    if ("a [redacted] b [redacted] c" != got)
+                    {
+                        wrong.Enqueue(got ?? "null");
+                    }
+                }
+            });
+
+            Assert.True(0 == thrown.Count, "round " + round + " threw:\n" + string.Join("\n", thrown));
+            Assert.True(wrong.IsEmpty, "round " + round + " cleaned to: " + string.Join(" | ", wrong));
+            AssertEverySecretMasked(utility, root, round);
+        }
+    }
+
+    // Requests on one client while secrets register on it: each request
+    // copies the client's options, the registry among them.
+    [Fact]
+    public void ConcurrentRequestsSurviveRegistration()
+    {
+        for (var round = 0; round < Rounds / 4; round++)
+        {
+            var client = LiveClient();
+            var utility = client.GetUtility();
+            var root = client.GetRootCtx();
+            var registering = new CountdownEvent(Width / 2);
+            var failed = new ConcurrentQueue<string>();
+            var thrown = AtOnce(n =>
+            {
+                if (n < Width / 2)
+                {
+                    RegisterSecrets(utility, root, round, n, registering);
+                    return;
+                }
+                while (!registering.IsSet)
+                {
+                    var res = client.Direct(new Dictionary<string, object?> { ["path"] = "p" + n });
+                    if (!Equals(true, res.GetValueOrDefault("ok")))
+                    {
+                        failed.Enqueue(Convert.ToString(res.GetValueOrDefault("err")) ?? "no error");
+                        return;
+                    }
+                }
+            });
+
+            Assert.True(0 == thrown.Count, "round " + round + " threw:\n" + string.Join("\n", thrown));
+            Assert.True(failed.IsEmpty, "round " + round + ", a request failed: " + string.Join(" | ", failed));
+            AssertEverySecretMasked(utility, root, round);
+        }
+    }
+}

package/project/.sdk/tm/csharp/test/FeatureHarness.cs

@@ -111,7 +111,7 @@ internal class FhHarness
         return op switch
         {
             "create" => "POST",
-            "update" => "PATCH",
+            "update" or "patch" => "PATCH",
             "remove" => "DELETE",
             _ => "GET",
         };

package/project/.sdk/tm/csharp/test/FeatureTest.cs

@@ -342,6 +342,41 @@ public class FeatureTimeoutTest
         Assert.Equal(1, f.Count);
     }
 
+    // The deadline runs from the request's start, not from the wait: a response
+    // that arrives after it is a timeout even when the caller only looks once it
+    // is complete. The clock stands at the start for the caller and 300 ms
+    // later for the worker.
+    [Fact]
+    public void LateResponseTimesOutHoweverLateTheCallerLooks()
+    {
+        if (Fh.SkipWithout("timeout")) return;
+        var f = new TimeoutFeature();
+        var h = Fh.Make(null, (f, new Dictionary<string, object?> { ["ms"] = 20, ["now"] = WorkerClock(300L) }));
+        var res = h.Op(new FhOpSpec { Op = "load" });
+        Assert.Equal("timeout", Fh.ErrCode(res.Err));
+        Assert.Equal(1, f.Count);
+    }
+
+    // A transport failure after the deadline is a timeout too, not the failure.
+    [Fact]
+    public void LateFailureTimesOut()
+    {
+        if (Fh.SkipWithout("timeout")) return;
+        var f = new TimeoutFeature();
+        var h = Fh.Make((ctx, url, fetchdef) => throw new InvalidOperationException("socket closed"),
+            (f, new Dictionary<string, object?> { ["ms"] = 20, ["now"] = WorkerClock(300L) }));
+        var res = h.Op(new FhOpSpec { Op = "load" });
+        Assert.Equal("timeout", Fh.ErrCode(res.Err));
+        Assert.Equal(1, f.Count);
+    }
+
+    // A clock standing at 0 for the calling thread and at later for any other.
+    private static Func<long> WorkerClock(long later)
+    {
+        var caller = Thread.CurrentThread.ManagedThreadId;
+        return () => Thread.CurrentThread.ManagedThreadId == caller ? 0L : later;
+    }
+
     [Fact]
     public void FastRequestPasses()
     {

package/project/.sdk/tm/csharp/test/PipelineTest.cs

@@ -41,6 +41,34 @@ public class PipelineTest
         return utility.MakeContext(ctxmap, client.GetRootCtx());
     }
 
+    // A typed collection is a list or a map to a cookie argument, as it is to
+    // the rest of the SDK: a List<string> repeats the name, a
+    // Dictionary<string, string> sends its keys.
+    [Fact]
+    public void PrepareHeadersCookieTypedCollections()
+    {
+        var (client, utility) = PlClient(null);
+        var ctx = PlCtx(client, utility, null);
+        ctx.Point = new Dictionary<string, object?>
+        {
+            ["args"] = new Dictionary<string, object?>
+            {
+                ["cookie"] = new List<object?>
+                {
+                    new Dictionary<string, object?> { ["name"] = "theme", ["orig"] = "theme", ["kind"] = "cookie" },
+                    new Dictionary<string, object?> { ["name"] = "prefs", ["orig"] = "prefs", ["kind"] = "cookie" },
+                },
+            },
+        };
+        ctx.Reqmatch = new Dictionary<string, object?>
+        {
+            ["theme"] = new List<string> { "dark", "x y" },
+            ["prefs"] = new Dictionary<string, string> { ["size"] = "2", ["lang"] = "en gb" },
+        };
+        var headers = utility.PrepareHeaders(ctx);
+        Assert.Equal("theme=dark; theme=x%20y; lang=en%20gb; size=2", headers["cookie"]);
+    }
+
     private static string ErrCode(Action act)
     {
         try