@voxgig/sdkgen 4.34.0 → 4.34.1

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

@@ -15,6 +15,11 @@ public static partial class SdkUtility
             {
                 result.Body = response.JsonFunc();
             }
+            if (response is { Unreadable: true })
+            {
+                result.Err = Response.UnreadableBody(ctx, result.Status, result.Headers,
+                    response.Body, ctx.Spec?.Headers, result.Err);
+            }
         }
 
         return result!;

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

@@ -17,7 +17,7 @@ public static partial class SdkUtility
             spec.Step = "reqform";
         }
 
-        var data = OmitKeys(ctx.Reqdata, HeaderArgNames(point));
+        var data = OmitKeys(ctx.Reqdata, RoutedArgNames(ctx));
 
         var transform = Helpers.ToMapAny(StructUtils.GetProp(point, "transform"));
         if (transform == null)
@@ -47,23 +47,31 @@ public static partial class SdkUtility
         return OmitKeys(reqdata, new List<string> { "$action" });
     }
 
-    // A header argument travels as a header, which PrepareHeadersUtil sends,
-    // so the body is built from the request data without it.
-    private static List<string> HeaderArgNames(object? point)
+    // A header, cookie or query argument travels where PrepareHeadersUtil or
+    // PrepareQueryUtil sends it, so the body is built from the request data
+    // without it, unless the entity declares it as a field too.
+    private static List<string> RoutedArgNames(Context ctx)
     {
-        var names = new List<string>();
-        if (point != null &&
-            StructUtils.GetPath(point, StructUtils.Jt("args", "header")) is List<object?> hl)
+        return CallArgs(ctx, "header").Concat(CallArgs(ctx, "cookie")).Concat(CallArgs(ctx, "query"))
+            .Select(arg => arg.Name).Where(name => !FieldArg(ctx, name)).ToList();
+    }
+
+    private static bool FieldArg(Context ctx, string name)
+    {
+        if (ctx.Point == null)
+        {
+            return false;
+        }
+        foreach (var kind in new[] { "header", "cookie", "query" })
         {
-            foreach (var hd in hl)
+            if (StructUtils.GetPath(ctx.Point, StructUtils.Jt("args", kind)) is List<object?> defs &&
+                defs.Any(ad => name == StructUtils.GetProp(ad, "name") as string &&
+                    StructUtils.GetProp(ad, "field") is true))
             {
-                if (StructUtils.GetProp(hd, "name") is string name && name != "")
-                {
-                    names.Add(name);
-                }
+                return true;
             }
         }
-        return names;
+        return false;
     }
 
     private static object? OmitKeys(object? reqdata, List<string> names)

package/project/.sdk/tm/csharp/utility/struct/Struct.cs

@@ -3106,8 +3106,9 @@ namespace Voxgig.Struct
 
             bool cKeyExists = TryGetDataValue(inj.DParent, key, out object? cval);
 
-            // TS: if (!exact && NONE === cval) return — only skip when key is absent, not when value is JSON null.
-            if (!exact && !cKeyExists)
+            // PATCH (scalar defaults, pending upstream fix): null scalar values
+            // keep the default, matching GetProp in the reference validator.
+            if (!exact && (!cKeyExists || (cval == null && !IsNode(pval))))
             {
                 return null;
             }

package/project/.sdk/tm/elixir/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 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/elixir/lib/projectname/context.ex

@@ -135,7 +135,7 @@ defmodule ProjectName.Context do
       true ->
         config = S.getprop(ctx, "config")
         opcfg = S.getpath(config, "entity." <> entname <> ".op." <> opname)
-        inpt = if opname == "update" or opname == "create", do: "data", else: "match"
+        inpt = if opname in ["update", "create", "patch"], do: "data", else: "match"
 
         points =
           if S.ismap(opcfg) do

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

@@ -42,7 +42,10 @@ defmodule ProjectName.Spec do
       "method", d.("method", "GET"),
       "body", S.getprop(m, "body"),
       "url", d.("url", ""),
-      "path", d.("path", "")
+      "path", d.("path", ""),
+      # The query parameters prepare_auth placed: the credential, which the
+      # request sends and the entity's match leaves out.
+      "authquery", d.("authquery", S.jt([]))
     ])
   end
 end
@@ -99,7 +102,9 @@ defmodule ProjectName.Response do
       "headers", S.getprop(m, "headers"),
       "json_func", if(S.isfunc(jf), do: jf, else: nil),
       "body", S.getprop(m, "body"),
-      "err", S.getprop(m, "err")
+      "err", S.getprop(m, "err"),
+      # Set by a transport that could not read a non-blank body as JSON.
+      "unreadable", S.getprop(m, "unreadable") == true
     ])
   end
 end

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

@@ -116,7 +116,10 @@ defmodule ProjectName.EntityBase do
   #   - signal: an optional 0-arity fn; when it returns true iteration stops.
   def stream(ent, action, args \\ nil, callopts \\ nil) do
     callopts = if S.ismap(callopts), do: callopts, else: S.jm([])
-    ctrl = H.or_(H.to_map(S.getprop(callopts, "ctrl")), S.jm([]))
+    # A copy: the caller's ctrl gains no key, and explain stays its own record.
+    ctrl = S.jm([])
+    given = H.to_map(S.getprop(callopts, "ctrl"))
+    if given != nil, do: Enum.each(H.entries(given), fn {k, v} -> S.setprop(ctrl, k, v) end)
     S.setprop(ctrl, "stream", callopts)
 
     ctxmap =
@@ -153,7 +156,7 @@ defmodule ProjectName.EntityBase do
     # materialised items so stream always yields.
     items =
       if S.isfunc(stream_fn) do
-        cleaned(ctx, stream_fn)
+        source(ctx, stream_fn)
       else
         rd = if result != nil, do: S.getprop(result, "resdata"), else: nil
 
@@ -170,26 +173,54 @@ defmodule ProjectName.EntityBase do
     |> guarded(ctx)
   end
 
-  # The caller iterates after run_op has returned, so what the stream raises
-  # is cleaned here, as run_op's rescue would clean it. The caller's own
-  # reducer runs inside the reduce, so what it raises is cleaned too.
-  defp cleaned(ctx, step) do
-    step.()
+  # The streaming feature's items. What its function raises leaves through
+  # run_op's catch path; under throw: false the stream is empty.
+  defp source(ctx, stream_fn) do
+    stream_fn.()
   rescue
-    e -> reraise(Utility.clean_exception(ctx, e), __STACKTRACE__)
+    e -> Pipeline.unexpected(ctx, e, __STACKTRACE__) || []
   end
 
+  # A reducer's own exception, told apart from the stream's.
+  defmodule CallerRaised do
+    defexception [:error, :stack]
+
+    @impl true
+    def message(%{error: e}), do: Exception.message(e)
+  end
+
+  # The caller iterates after run_op has returned, so what the stream raises
+  # leaves as an operation's failure would: PreUnexpected fires, and under
+  # throw: false the stream ends. The caller's own reducer runs inside the
+  # same reduce; what it raises is only cleaned, as run_op's rescue would.
   defp guarded(enum, ctx) do
-    fn acc, fun -> reduce_step(ctx, fn -> Enumerable.reduce(enum, acc, fun) end) end
+    fn acc, fun -> reduce_step(ctx, acc, fn -> Enumerable.reduce(enum, acc, callers(fun)) end) end
+  end
+
+  defp callers(fun) do
+    fn item, acc ->
+      try do
+        fun.(item, acc)
+      rescue
+        e -> reraise(%CallerRaised{error: e, stack: __STACKTRACE__}, __STACKTRACE__)
+      end
+    end
   end
 
-  defp reduce_step(ctx, step) do
-    case cleaned(ctx, step) do
-      {:suspended, acc, cont} -> {:suspended, acc, fn a -> reduce_step(ctx, fn -> cont.(a) end) end}
+  defp reduce_step(ctx, acc, step) do
+    case stream_step(ctx, acc, step) do
+      {:suspended, acc2, cont} -> {:suspended, acc2, fn a -> reduce_step(ctx, a, fn -> cont.(a) end) end}
       done -> done
     end
   end
 
+  defp stream_step(ctx, {_, value}, step) do
+    step.()
+  rescue
+    e in CallerRaised -> reraise(Utility.clean_exception(ctx, e.error), e.stack)
+    e -> Pipeline.unexpected(ctx, e, __STACKTRACE__) || {:done, value}
+  end
+
   # Unwrap an entity node to its bare record; recurse into chunk lists.
   defp stream_unwrap(item) do
     cond do

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

@@ -47,6 +47,21 @@ defmodule ProjectName.Feature.Test do
     nil
   end
 
+  # The key a list's response transform
+  # ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+  defp item_envelope_key(spec) do
+    with true <- S.islist(spec),
+         3 <- S.size(spec),
+         "`$EACH`" <- S.getelem(spec, 0),
+         "body" <- S.getelem(spec, 1),
+         merge when is_binary(merge) <- S.getprop(S.getelem(spec, 2), "`$MERGE`"),
+         [_, key] <- Regex.run(~r/^`\.([^.`$]+)`$/, merge) do
+      key
+    else
+      _ -> nil
+    end
+  end
+
   # THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
   # `transform.res: `body.item`` describes an API that answers {"item": {...}}
   # and the response transform unwraps that key on the way back. Returning the
@@ -54,27 +69,32 @@ defmodule ProjectName.Feature.Test do
   # the caller gets nothing. Mirrors the go/ts/lua/php mocks.
   defp envelope(fctx, data) do
     spec = S.getprop(S.getprop(S.getprop(fctx, "point"), "transform"), "res")
+    key = item_envelope_key(spec)
 
-    # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
-    # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
-    case {data, spec} do
-      {nil, _} ->
-        data
-
-      {_, s} when is_binary(s) ->
-        case Regex.run(~r/^`body\.(.+)`$/, s) do
-          [_, inner] ->
-            inner
-            |> String.split(".")
-            |> Enum.reverse()
-            |> Enum.reduce(data, fn seg, out -> S.jm([seg, out]) end)
-
-          _ ->
-            data
-        end
+    if key != nil and S.islist(data) do
+      S.jt(for i <- 0..(S.size(data) - 1)//1, do: S.jm([key, S.getelem(data, i)]))
+    else
+      # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+      # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
+      case {data, spec} do
+        {nil, _} ->
+          data
+
+        {_, s} when is_binary(s) ->
+          case Regex.run(~r/^`body\.(.+)`$/, s) do
+            [_, inner] ->
+              inner
+              |> String.split(".")
+              |> Enum.reverse()
+              |> Enum.reduce(data, fn seg, out -> S.jm([seg, out]) end)
+
+            _ ->
+              data
+          end
 
-      _ ->
-        data
+        _ ->
+          data
+      end
     end
   end
 
@@ -140,7 +160,7 @@ defmodule ProjectName.Feature.Test do
           respond(fctx, 200, S.clone(found))
         end
 
-      "update" ->
+      opn when opn in ["update", "patch"] ->
         reqdata = S.getprop(fctx, "reqdata")
 
         update_match =
@@ -171,7 +191,12 @@ defmodule ProjectName.Feature.Test do
           # update miss: 404, never another record
           respond(fctx, 404, nil, S.jm(["statusText", "Not found"]))
         else
-          if S.ismap(ent) and S.ismap(reqdata), do: S.merge(S.jt([ent, reqdata]))
+          # `$body` travels on the wire alone; the record is the rest.
+          if S.ismap(ent) and S.ismap(reqdata) do
+            rec = S.clone(reqdata)
+            S.delprop(rec, "$body")
+            S.merge(S.jt([ent, rec]))
+          end
 
           S.delprop(ent, "$KEY")
           respond(fctx, 200, S.clone(ent))
@@ -196,6 +221,7 @@ defmodule ProjectName.Feature.Test do
         ent = S.clone(S.getprop(fctx, "reqdata"))
 
         if S.ismap(ent) do
+          S.delprop(ent, "$body")
           S.setprop(ent, "id", eid)
           if is_binary(eid), do: S.setprop(entmap, eid, ent)
           S.delprop(ent, "$KEY")

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

@@ -197,6 +197,8 @@ defmodule ProjectName.Feature.Validate do
     # fields will never name it - and under `strict` every custom-action call
     # would be rejected for the one key that made it reachable.
     S.delprop(out, "$action")
+    # Nor is `$body`, the raw request body.
+    S.delprop(out, "$body")
 
     out
   end