@voxgig/sdkgen 4.22.0 → 4.24.0

package/project/.sdk/tm/cpp/feature/test.hpp

@@ -68,16 +68,27 @@ private:
     Value restf = getp(tm, "res");
     if (!restf.is_string()) return data;
     std::string spec = restf.as_string();
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (spec.size() < 8) return data;
     if (0 != spec.compare(0, 6, "`body.")) return data;
     if ('`' != spec[spec.size() - 1]) return data;
     std::string inner = spec.substr(6, spec.size() - 7);
-    if (inner.empty() || std::string::npos != inner.find('.')) return data;
-    Value wrapped = vmap();
-    map_put(wrapped, inner, data);
-    return wrapped;
+    if (inner.empty()) return data;
+    std::vector<std::string> segs;
+    for (size_t at = 0;;) {
+      size_t dot = inner.find('.', at);
+      if (std::string::npos == dot) { segs.push_back(inner.substr(at)); break; }
+      segs.push_back(inner.substr(at, dot - at));
+      at = dot + 1;
+    }
+    Value out = data;
+    for (size_t i = segs.size(); i > 0; i--) {
+      Value wrapped = vmap();
+      map_put(wrapped, segs[i - 1], out);
+      out = wrapped;
+    }
+    return out;
   }
 
   Value respond(CtxPtr ctx, int status, const Value& data, const Value& extra) {
@@ -159,14 +170,10 @@ private:
       Value args = buildArgs(ctx, op, updateMatch);
       std::vector<Value> found = Struct::select(entmap, args);
       Value ent = found.empty() ? Value::undef() : found[0];
-      if (is_nullish(ent) && entmap.is_map()) {
-        for (const auto& kv : *entmap.as_map()) {
-          if (kv.second.is_map()) { ent = kv.second; break; }
-        }
-      }
+      // update miss: 404, never another record
       if (is_nullish(ent)) return respond(ctx, 404, Value(nullptr), extra1("statusText", Value("Not found")));
       if (ent.is_map() && ctx->reqdata.is_map()) {
-        for (const auto& kv : *ctx->reqdata.as_map()) map_put(ent, kv.first, kv.second);
+        Struct::merge(vlist({ent, ctx->reqdata}));
       }
       Struct::delprop(ent, Value("$KEY"));
       Value out = Struct::clone(ent);
@@ -261,19 +268,51 @@ private:
     fopt::foptSleep(net)(ms);
   }
 
+  static bool pointTerminal(const Value& p) {
+    Value parts = getp(p, "parts");
+    if (!parts.is_list() || parts.as_list()->empty()) return false;
+    const Value& last = parts.as_list()->back();
+    return last.is_string() && 0 == last.as_string().rfind("{", 0);
+  }
+
+  static size_t pointDepth(const Value& p) {
+    Value parts = getp(p, "parts");
+    return parts.is_list() ? parts.as_list()->size() : 0;
+  }
+
+  // The entity's own endpoint: a terminal `{param}` marks a record route, and
+  // among equals the shallower path wins (the same rule as makePoint).
+  static Value pickPoint(const Value& points) {
+    if (!points.is_list() || points.as_list()->empty()) return Value::undef();
+    Value point = (*points.as_list())[0];
+    for (const Value& cand : *points.as_list()) {
+      if (pointTerminal(cand) != pointTerminal(point)) {
+        if (pointTerminal(cand)) point = cand;
+      } else if (pointDepth(cand) < pointDepth(point)) {
+        point = cand;
+      }
+    }
+    return point;
+  }
+
   Value buildArgs(CtxPtr ctx, OperationPtr op, const Value& args) {
     std::string opname = op->name;
 
     Value points = Struct::getpath(ctx->config,
         {"entity", ctx->entity == nullptr ? std::string("") : ctx->entity->getName(),
          "op", opname, "points"});
-    Value point = Struct::getelem(points, -1);
-
-    Value paramsPath = Struct::getpath(point, {"args", "params"});
-    std::vector<Value> reqdParamsSel = Struct::select(paramsPath, vmap({{"reqd", Value(true)}}));
-    Value reqdParams = vlist();
-    for (auto& p : reqdParamsSel) reqdParams.as_list()->push_back(p);
-    Value reqd = Struct::transform(reqdParams, vlist({Value("`$EACH`"), Value(""), Value("`$KEY.name`")}));
+    Value point = pickPoint(points);
+
+    // Path AND query: a path-only read misses a query-addressed record
+    // (e.g. GET /result?trace_id=), which has no path param at all.
+    Value reqdArgs = vlist();
+    for (const char* kind : {"params", "query"}) {
+      Value argsPath = Struct::getpath(point, {"args", kind});
+      for (auto& p : Struct::select(argsPath, vmap({{"reqd", Value(true)}}))) {
+        reqdArgs.as_list()->push_back(p);
+      }
+    }
+    Value reqd = Struct::transform(reqdArgs, vlist({Value("`$EACH`"), Value(""), Value("`$KEY.name`")}));
 
     Value qand = vlist();
     Value q = vmap({{"`$AND`", qand}});

package/project/.sdk/tm/cpp/utility/pipeline.hpp

@@ -1026,7 +1026,7 @@ inline Value prepareQuery(CtxPtr ctx) {
   for (const auto& item : Struct::items(reqmatch)) {
     std::string key = as_str(pair_key(item));
     Value val = pair_val(item);
-    if (!is_nullish(val) && !contains_str(params, key)) {
+    if (!is_nullish(val) && "$action" != key && !contains_str(params, key)) {
       map_put(out, key, val);
     }
   }
@@ -1050,18 +1050,30 @@ inline std::string preparePath(CtxPtr ctx) {
 
 // ---- transformRequest -------------------------------------------------
 
+// `$action` selects the point (see makePoint); it is never an API field, so
+// the body is a copy without it. The caller's map is left untouched.
+inline Value stripAction(const Value& reqdata) {
+  if (!map_contains(reqdata, "$action")) return reqdata;
+  Value body = vmap();
+  for (const auto& item : Struct::items(reqdata)) {
+    std::string key = as_str(pair_key(item));
+    if ("$action" != key) map_put(body, key, pair_val(item));
+  }
+  return body;
+}
+
 inline Value transformRequest(CtxPtr ctx) {
   if (ctx->spec) ctx->spec->step = "reqform";
 
   Value transform = Helpers::toMapAny(getp(ctx->point, "transform"));
-  if (!transform.is_map()) return ctx->reqdata;
+  if (!transform.is_map()) return stripAction(ctx->reqdata);
 
   Value reqform = getp(transform, "req");
-  if (is_nullish(reqform)) return ctx->reqdata;
+  if (is_nullish(reqform)) return stripAction(ctx->reqdata);
 
   Value data = vmap();
   map_put(data, "reqdata", ctx->reqdata);
-  return Struct::transform(data, reqform);
+  return stripAction(Struct::transform(data, reqform));
 }
 
 // ---- makeOptions ------------------------------------------------------

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

@@ -78,7 +78,7 @@ public class Context
         {
             Ctrl = ctrl;
         }
-        else if (basectx?.Ctrl != null)
+        else if (basectx?.Ctrl != null && Helpers.GetCtxProp(ctxmap, "opname") == null)
         {
             Ctrl = basectx.Ctrl;
         }

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

@@ -2,8 +2,8 @@
 // stamps page/limit (or a cursor) into the request query; on the way back
 // (PreResult) it reads the server's pagination signals - a `Link:
 // rel="next"` header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body - and records
-// them on `ctx.Result.Paging`. A per-call cursor/page from ctrl takes
+// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case
+// forms too) - and records them on `ctx.Result.Paging` and `Ctrl.Paging`. A per-call cursor/page from ctrl takes
 // priority (used by auto-iteration). Parameter names (`pageParam`,
 // `limitParam`, `cursorParam`), the page size (`limit`) and the start page
 // (`startPage`, default 1) are configurable.
@@ -79,8 +79,12 @@ public class PagingFeature : BaseFeature
         }
         else if (!spec.Query.TryGetValue(pageParam, out var existing) || existing == null)
         {
+            // A record written back by PreResult holds the page just fetched
+            // as "page" and the one to fetch as "nextPage", so nextPage wins.
             object? page = null;
-            var hasPage = paging != null && paging.TryGetValue("page", out page) && page != null;
+            var hasPage = paging != null &&
+                ((paging.TryGetValue("nextPage", out page) && page != null) ||
+                 (paging.TryGetValue("page", out page) && page != null));
             spec.Query[pageParam] = hasPage ? page : FoptInt(_options, "startPage", 1);
         }
 
@@ -224,7 +228,7 @@ public class PagingFeature : BaseFeature
             }
         }
 
-        // Body-level cursors.
+        // Body-level signals; snake_case forms are read first so camelCase wins.
         if (body is Dictionary<string, object?> bm)
         {
             if (bm.TryGetValue("next", out var next) && next != null &&
@@ -232,6 +236,10 @@ public class PagingFeature : BaseFeature
             {
                 paging["next"] = next;
             }
+            if (bm.TryGetValue("next_cursor", out var snakeCursor) && snakeCursor != null)
+            {
+                paging["cursor"] = snakeCursor;
+            }
             if (bm.TryGetValue("cursor", out var cursor) && cursor != null)
             {
                 paging["cursor"] = cursor;
@@ -240,6 +248,34 @@ public class PagingFeature : BaseFeature
             {
                 paging["cursor"] = nextCursor;
             }
+            if (!paging.TryGetValue("nextPage", out var np0) || np0 == null)
+            {
+                bm.TryGetValue("nextPage", out var np);
+                if (np == null)
+                {
+                    bm.TryGetValue("next_page", out np);
+                }
+                switch (np)
+                {
+                    case int n:
+                        paging["nextPage"] = n;
+                        break;
+                    case long n:
+                        paging["nextPage"] = (int)n;
+                        break;
+                    case double n:
+                        paging["nextPage"] = (int)n;
+                        break;
+                    case string s:
+                        paging["nextPage"] = s;
+                        break;
+                }
+            }
+            if (bm.TryGetValue("has_more", out var snakeMore) && snakeMore is bool smb)
+            {
+                paging["hasMore"] = smb;
+                explicitMore = true;
+            }
             if (bm.TryGetValue("hasMore", out var hasMore) && hasMore is bool hmb)
             {
                 paging["hasMore"] = hmb;
@@ -262,6 +298,24 @@ public class PagingFeature : BaseFeature
 
         result.Paging = paging;
         Last = paging;
+
+        if (ctx.Ctrl != null)
+        {
+            // The Context shares the caller's paging map by reference, so
+            // refill it in place; a fresh map on Ctrl never reaches the caller.
+            if (ctx.Ctrl.Paging != null)
+            {
+                ctx.Ctrl.Paging.Clear();
+                foreach (var kv in paging)
+                {
+                    ctx.Ctrl.Paging[kv.Key] = kv.Value;
+                }
+            }
+            else
+            {
+                ctx.Ctrl.Paging = paging;
+            }
+        }
     }
 
     private bool IsList(Context ctx)

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

@@ -59,15 +59,21 @@ public class TestFeature : BaseFeature
                 if (data == null || ctx2.Point == null) { return data; }
                 var tm = StructUtils.GetProp(ctx2.Point, "transform");
                 if (StructUtils.GetProp(tm, "res") is not string spec) { return data; }
-                // Exactly `body.<key>`; a deeper path is not an envelope this
-                // mock can synthesise, so it is left alone.
+                // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+                // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
                 if (!spec.StartsWith("`body.") || !spec.EndsWith("`") || spec.Length < 8)
                 {
                     return data;
                 }
                 var inner = spec.Substring(6, spec.Length - 7);
-                if (inner.Length == 0 || inner.Contains('.')) { return data; }
-                return new Dictionary<string, object?> { [inner] = data };
+                if (inner.Length == 0) { return data; }
+                var segs = inner.Split('.');
+                object? built = data;
+                for (var i = segs.Length - 1; 0 <= i; i--)
+                {
+                    built = new Dictionary<string, object?> { [segs[i]] = built };
+                }
+                return built;
             }
 
             Dictionary<string, object?> Respond(int status, object? data,
@@ -182,30 +188,17 @@ public class TestFeature : BaseFeature
                 var args = BuildArgs(ctx2, op, updateMatch);
                 var found = StructUtils.Select(entmap, args);
                 var ent = StructUtils.GetElem(found, 0);
-                if (ent == null && entmap != null)
-                {
-                    foreach (var e in entmap.Values)
-                    {
-                        if (e is Dictionary<string, object?>)
-                        {
-                            ent = e;
-                            break;
-                        }
-                    }
-                }
                 if (ent == null)
                 {
+                    // update miss: 404, never another record
                     return Respond(404, null, new Dictionary<string, object?>
                     {
                         ["statusText"] = "Not found",
                     });
                 }
-                if (ent is Dictionary<string, object?> entm && ctx2.Reqdata != null)
+                if (ent is Dictionary<string, object?> && ctx2.Reqdata != null)
                 {
-                    foreach (var kv in ctx2.Reqdata)
-                    {
-                        entm[kv.Key] = kv.Value;
-                    }
+                    StructUtils.Merge(new List<object?> { ent, ctx2.Reqdata });
                 }
                 StructUtils.DelProp(ent, "$KEY");
                 var outval = StructUtils.Clone(ent);
@@ -378,11 +371,16 @@ public class TestFeature : BaseFeature
             }
         }
 
-        // Get required params.
-        var paramsPath = StructUtils.GetPath(point, StructUtils.Jt("args", "params"));
-        var reqdParams = StructUtils.Select(paramsPath,
-            new Dictionary<string, object?> { ["reqd"] = true });
-        var reqd = StructUtils.Transform(reqdParams,
+        // Path AND query: a path-only read misses a query-addressed record
+        // (e.g. GET /result?trace_id=), which has no path param at all.
+        var reqdArgs = new List<object?>();
+        foreach (var kind in new[] { "params", "query" })
+        {
+            var argsPath = StructUtils.GetPath(point, StructUtils.Jt("args", kind));
+            reqdArgs.AddRange(StructUtils.Select(argsPath,
+                new Dictionary<string, object?> { ["reqd"] = true }));
+        }
+        var reqd = StructUtils.Transform(reqdArgs,
             StructUtils.Jt("`$EACH`", "", "`$KEY.name`"));
 
         var qand = new List<object?>();

package/project/.sdk/tm/csharp/utility/Fetcher.cs

@@ -11,7 +11,19 @@ namespace ProjectNameSdk.Util;
 
 public static partial class SdkUtility
 {
-    private static readonly HttpClient DefaultHttpClient = new();
+    // Cookies OFF on every handler. The clients are process-wide, so a
+    // CookieContainer would send one call's Set-Cookie on the next, under a
+    // different credential — and .NET ADDS container cookies to a request
+    // that already carries a Cookie header, which an `apiKey in: cookie`
+    // scheme does. Pooling is the handler's own and is unaffected.
+    private static HttpClientHandler CookielessHandler(bool allowRedirect) =>
+        new HttpClientHandler
+        {
+            AllowAutoRedirect = allowRedirect,
+            UseCookies = false,
+        };
+
+    private static readonly HttpClient DefaultHttpClient = new(CookielessHandler(true));
 
     // Non-following twin of DefaultHttpClient. The station feature's
     // middleware sets `redirect: manual` on the fetch definition under a
@@ -20,11 +32,8 @@ public static partial class SdkUtility
     // to a Location no policy approved (the ts donor's fetch honours the
     // same key natively; redirect policy is per-handler in .NET, hence a
     // second client).
-    private static readonly HttpClient ManualRedirectHttpClient = new(
-        new HttpClientHandler
-        {
-            AllowAutoRedirect = false,
-        });
+    private static readonly HttpClient ManualRedirectHttpClient =
+        new(CookielessHandler(false));
 
     // Proxy-routed clients, cached per proxy URL and redirect policy (see
     // the proxy feature's fetchdef annotation).
@@ -43,12 +52,10 @@ public static partial class SdkUtility
                 var key = (manual ? "manual|" : "auto|") + proxy;
                 if (!ProxyClients.TryGetValue(key, out var client))
                 {
-                    client = new HttpClient(new HttpClientHandler
-                    {
-                        Proxy = new System.Net.WebProxy(proxy),
-                        UseProxy = true,
-                        AllowAutoRedirect = !manual,
-                    });
+                    var handler = CookielessHandler(!manual);
+                    handler.Proxy = new System.Net.WebProxy(proxy);
+                    handler.UseProxy = true;
+                    client = new HttpClient(handler);
                     ProxyClients[key] = client;
                 }
                 return client;

package/project/.sdk/tm/csharp/utility/PrepareQuery.cs

@@ -24,7 +24,7 @@ public static partial class SdkUtility
         {
             var key = item[0] as string ?? "";
             var val = item[1];
-            if (val != null && !ContainsStr(paramnames, key))
+            if (val != null && "$action" != key && !ContainsStr(paramnames, key))
             {
                 query[key] = val;
             }

package/project/.sdk/tm/csharp/utility/TransformRequest.cs

@@ -20,13 +20,13 @@ public static partial class SdkUtility
         var transform = Helpers.ToMapAny(StructUtils.GetProp(point, "transform"));
         if (transform == null)
         {
-            return ctx.Reqdata;
+            return StripAction(ctx.Reqdata);
         }
 
         var reqform = StructUtils.GetProp(transform, "req");
         if (reqform == null)
         {
-            return ctx.Reqdata;
+            return StripAction(ctx.Reqdata);
         }
 
         var reqdata = StructUtils.Transform(new Dictionary<string, object?>
@@ -34,6 +34,26 @@ public static partial class SdkUtility
             ["reqdata"] = ctx.Reqdata,
         }, reqform);
 
-        return reqdata;
+        return StripAction(reqdata);
+    }
+
+    // `$action` selects the point (see MakePointUtil); it is never an API
+    // field, so the body is a copy without it. The caller's map is left
+    // untouched.
+    private static object? StripAction(object? reqdata)
+    {
+        if (reqdata is not IDictionary<string, object?> src || !src.ContainsKey("$action"))
+        {
+            return reqdata;
+        }
+        var body = new Dictionary<string, object?>();
+        foreach (var kv in src)
+        {
+            if ("$action" != kv.Key)
+            {
+                body[kv.Key] = kv.Value;
+            }
+        }
+        return body;
     }
 }

package/project/.sdk/tm/elixir/lib/projectname/context.ex

@@ -57,7 +57,7 @@ defmodule ProjectName.Context do
         if S.ismap(pg), do: S.setprop(ctrl, "paging", pg)
         S.setprop(ctx, "ctrl", ctrl)
 
-      basectx != nil and bp.("ctrl") != nil ->
+      basectx != nil and bp.("ctrl") != nil and gp.("opname") == nil ->
         S.setprop(ctx, "ctrl", bp.("ctrl"))
 
       true ->

package/project/.sdk/tm/elixir/lib/projectname/feature/paging.ex

@@ -4,8 +4,8 @@
 # stamps page/limit (or a cursor) into the request query; on the way back
 # (PreResult) it reads the server's pagination signals — a `Link: rel="next"`
 # header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-# `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records them
-# on `ctx.result.paging`. A per-call cursor/page supplied via ctrl paging
+# `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case forms
+# too) — and records them on `ctx.result.paging` and the caller's ctrl paging. A per-call cursor/page supplied via ctrl paging
 # takes priority (used by auto-iteration). Parameter names
 # (`pageParam`/`limitParam`/`cursorParam`), `startPage` and page size
 # (`limit`) are configurable.
@@ -67,7 +67,10 @@ defmodule ProjectName.Feature.Paging do
               S.setprop(query, cursor_param, S.getprop(paging, "cursor"))
 
             S.getprop(query, page_param) == nil ->
-              page = S.getprop(paging, "page")
+              # A record written back by pre_result holds the page just fetched
+              # as "page" and the one to fetch as "nextPage", so nextPage wins.
+              page = S.getprop(paging, "nextPage")
+              page = if page == nil, do: S.getprop(paging, "page"), else: page
               page = if page == nil, do: por(S.getprop(opts, "startPage"), 1), else: page
               S.setprop(query, page_param, page)
 
@@ -182,18 +185,16 @@ defmodule ProjectName.Feature.Paging do
                 bnext -> por(next_from_link, bnext)
               end
 
+            # snake_case forms rank below the camelCase ones.
             c =
               cond do
                 S.getprop(body, "nextCursor") != nil -> S.getprop(body, "nextCursor")
                 S.getprop(body, "cursor") != nil -> S.getprop(body, "cursor")
+                S.getprop(body, "next_cursor") != nil -> S.getprop(body, "next_cursor")
                 true -> nil
               end
 
-            hm =
-              case S.getprop(body, "hasMore") do
-                v when is_boolean(v) -> v
-                _ -> false
-              end
+            {hm, _} = body_more(body)
 
             {n, c, hm}
           else
@@ -239,10 +240,19 @@ defmodule ProjectName.Feature.Paging do
                 # No usable relay `more` path, but a top-level body hasMore is
                 # still an outright statement — keep it explicit, or cursor
                 # inference below would flip an explicit false to true.
-                {c, has_more, is_boolean(S.getprop(body, "hasMore"))}
+                {c, has_more, elem(body_more(body), 1)}
             end
           else
-            {cursor_val, has_more, is_boolean(S.getprop(body, "hasMore"))}
+            {cursor_val, has_more, elem(body_more(body), 1)}
+          end
+
+        next_page =
+          if next_page == nil and S.ismap(body) do
+            np = S.getprop(body, "nextPage")
+            np = if np == nil, do: S.getprop(body, "next_page"), else: np
+            if is_number(np) or is_binary(np), do: np, else: nil
+          else
+            next_page
           end
 
         # Cursor presence only INFERS another page. When the server stated the
@@ -268,6 +278,7 @@ defmodule ProjectName.Feature.Paging do
           ])
 
         S.setprop(result, "paging", paging)
+        write_back(S.getprop(ctx, "ctrl"), paging)
         S.setprop(S.getprop(f, "client"), "_paging", S.jm(["last", paging]))
       end
     end
@@ -275,6 +286,37 @@ defmodule ProjectName.Feature.Paging do
     nil
   end
 
+  # The Context shares the caller's paging map by reference, so refill it in
+  # place; a fresh map on ctrl never reaches the caller.
+  defp write_back(ctrl, paging) do
+    shared = if ctrl == nil, do: nil, else: S.getprop(ctrl, "paging")
+
+    cond do
+      ctrl == nil ->
+        nil
+
+      S.ismap(shared) ->
+        Enum.each(S.keysof(shared), fn k -> S.delprop(shared, k) end)
+        Enum.each(S.keysof(paging), fn k -> S.setprop(shared, k, S.getprop(paging, k)) end)
+
+      true ->
+        S.setprop(ctrl, "paging", paging)
+    end
+
+    nil
+  end
+
+  # Body `hasMore`, or `has_more` when the camelCase form is absent: {value,
+  # stated outright}.
+  defp body_more(body) do
+    cond do
+      not S.ismap(body) -> {false, false}
+      is_boolean(S.getprop(body, "hasMore")) -> {S.getprop(body, "hasMore"), true}
+      is_boolean(S.getprop(body, "has_more")) -> {S.getprop(body, "has_more"), true}
+      true -> {false, false}
+    end
+  end
+
   defp is_list_op(f, ctx) do
     ops = opt_list(S.getprop(F.opts(f), "ops"), ["list"])
     op = S.getprop(ctx, "op")