@voxgig/sdkgen 4.31.1 → 4.32.0

package/project/.sdk/tm/c/utility/prepare_headers.c

@@ -2,12 +2,62 @@
 
 #include "sdk.h"
 
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+static bool same_name(const char* a, const char* b) {
+  for (; *a && *b; a++, b++) {
+    if (tolower((unsigned char)*a) != tolower((unsigned char)*b)) return false;
+  }
+  return *a == *b;
+}
+
 voxgig_value* prepare_headers_util(Context* ctx) {
   voxgig_value* options = ctx->client ? sdk_options_map(ctx->client) : ctx->options;
 
   voxgig_value* headers = getp(options, "headers");
-  if (v_is_noval(headers) || v_is_null(headers)) return voxgig_new_map();
+  voxgig_value* out = NULL;
+  if (!v_is_noval(headers) && !v_is_null(headers)) {
+    voxgig_value* cloned = voxgig_clone(headers);
+    if (voxgig_is_map(cloned)) out = cloned;
+  }
+  if (NULL == out) out = voxgig_new_map();
+
+  // A header parameter travels as a header, under the name the definition
+  // gives it, and only from this call's own arguments. It replaces a default
+  // of the same name, whatever its case.
+  voxgig_value* aheader = getpath2(ctx->point, "args", "header");
+  if (voxgig_is_list(aheader)) {
+    voxgig_list* hl = voxgig_as_list(aheader);
+    for (size_t i = 0; i < hl->len; i++) {
+      voxgig_value* name = getp(hl->items[i], "name");
+      if (!voxgig_is_string(name) || voxgig_as_string(name)[0] == '\0') continue;
+      voxgig_value* orig = getp(hl->items[i], "orig");
+      const char* wire = voxgig_is_string(orig) && voxgig_as_string(orig)[0] != '\0'
+        ? voxgig_as_string(orig) : voxgig_as_string(name);
+
+      voxgig_value* val = getp(ctx->reqmatch, voxgig_as_string(name));
+      if (v_is_noval(val) || v_is_null(val)) val = getp(ctx->reqdata, voxgig_as_string(name));
+      if (v_is_noval(val) || v_is_null(val)) continue;
+
+      size_t n = strlen(wire);
+      char* key = (char*)malloc(n + 1);
+      for (size_t k = 0; k < n; k++) key[k] = (char)tolower((unsigned char)wire[k]);
+      key[n] = '\0';
+      voxgig_map* om = voxgig_as_map(out);
+      for (size_t j = om->len; j > 0; j--) {
+        if (same_name(om->entries[j - 1].key, key)) {
+          voxgig_value* dk = voxgig_new_string(om->entries[j - 1].key);
+          voxgig_delprop(out, dk);
+          voxgig_release(dk);
+        }
+      }
+      char* text = voxgig_stringify(val, -1);
+      setp(out, key, voxgig_new_string_take(text, strlen(text)));
+      free(key);
+    }
+  }
 
-  voxgig_value* cloned = voxgig_clone(headers);
-  return voxgig_is_map(cloned) ? cloned : voxgig_new_map();
+  return out;
 }

package/project/.sdk/tm/c/utility/prepare_query.c

@@ -52,6 +52,8 @@ voxgig_value* prepare_query_util(Context* ctx) {
   voxgig_value* params = getp(point, "params");
   if (!voxgig_is_list(params)) params = voxgig_new_list();
   voxgig_value* aparams = getpath2(point, "args", "params");
+  // A header parameter travels in the headers, which prepare_headers fills.
+  voxgig_value* aheader = getpath2(point, "args", "header");
   voxgig_value* aquery = getpath2(point, "args", "query");
 
   voxgig_value* out = voxgig_new_map();
@@ -61,7 +63,8 @@ voxgig_value* prepare_query_util(Context* ctx) {
       const char* key = rm->entries[i].key;
       voxgig_value* val = rm->entries[i].value;
       if (!v_is_noval(val) && !v_is_null(val) && strcmp(key, "$action") != 0 &&
-          !params_contains(params, key) && !args_params_contains(aparams, key)) {
+          !params_contains(params, key) && !args_params_contains(aparams, key) &&
+          !args_params_contains(aheader, key)) {
         setp(out, query_wire_name(aquery, key), v_share(val));
       }
     }

package/project/.sdk/tm/c/utility/transform_request.c

@@ -4,39 +4,62 @@
 
 #include <string.h>
 
+/* A header argument travels as a header, which prepare_headers_util sends,
+   so the body is built from the request data without it. */
+static bool header_arg(voxgig_value* point, const char* key) {
+  voxgig_value* aheader = getpath2(point, "args", "header");
+  if (!voxgig_is_list(aheader)) return false;
+  voxgig_list* hl = voxgig_as_list(aheader);
+  for (size_t i = 0; i < hl->len; i++) {
+    voxgig_value* name = getp(hl->items[i], "name");
+    if (voxgig_is_string(name) && strcmp(voxgig_as_string(name), key) == 0) return true;
+  }
+  return false;
+}
+
 /* `$action` selects the point (see make_point_util); it is never an API
-   field, so the body is a copy without it. The caller's map is left
-   untouched. */
-static voxgig_value* strip_action(voxgig_value* reqdata) {
+   field, so the body is a copy without it, or, given a point, without its
+   header arguments. The caller's map is left untouched. */
+static bool dropped(const char* key, voxgig_value* point) {
+  return NULL == point ? strcmp(key, "$action") == 0 : header_arg(point, key);
+}
+
+static voxgig_value* omit_keys(voxgig_value* reqdata, voxgig_value* point) {
   if (!voxgig_is_map(reqdata)) return reqdata;
   voxgig_map* rm = voxgig_as_map(reqdata);
   bool has = false;
   for (size_t i = 0; i < rm->len; i++) {
-    if (strcmp(rm->entries[i].key, "$action") == 0) { has = true; break; }
+    if (dropped(rm->entries[i].key, point)) { has = true; break; }
   }
   if (!has) return reqdata;
   voxgig_value* body = voxgig_new_map();
   for (size_t i = 0; i < rm->len; i++) {
-    if (strcmp(rm->entries[i].key, "$action") != 0) {
+    if (!dropped(rm->entries[i].key, point)) {
       setp(body, rm->entries[i].key, v_share(rm->entries[i].value));
     }
   }
   return body;
 }
 
+static voxgig_value* strip_action(voxgig_value* reqdata) {
+  return omit_keys(reqdata, NULL);
+}
+
 voxgig_value* transform_request_util(Context* ctx) {
   Spec* spec = ctx->spec;
   voxgig_value* point = ctx->point;
 
   if (spec) spec_set_step(spec, "reqform");
 
+  voxgig_value* data = NULL == point ? ctx->reqdata : omit_keys(ctx->reqdata, point);
+
   voxgig_value* transform = to_map(getp(point, "transform"));
-  if (v_is_noval(transform)) return strip_action(ctx->reqdata);
+  if (v_is_noval(transform)) return strip_action(data);
 
   voxgig_value* reqform = getp(transform, "req");
-  if (v_is_noval(reqform) || v_is_null(reqform)) return strip_action(ctx->reqdata);
+  if (v_is_noval(reqform) || v_is_null(reqform)) return strip_action(data);
 
-  voxgig_value* store = cmap(1, "reqdata", v_share(ctx->reqdata));
+  voxgig_value* store = cmap(1, "reqdata", v_share(data));
   /* Return the transform result verbatim, as the ts reference does. Falling
      back to ctx->reqdata meant a reqform naming a path that does not resolve
      sent the WHOLE request data instead of nothing. */

package/project/.sdk/tm/clojure/src/sdk/core.clj

@@ -450,9 +450,30 @@
 
 (defn u-prepare-headers [ctx]
   (let [options (client-options-map (oget ctx :client))
-        headers (vs/getprop options "headers")]
-    (if (nil? headers) (vs/jm)
-        (let [o (vs/clone headers)] (if (vs/ismap o) o (vs/jm))))))
+        headers (vs/getprop options "headers")
+        out (if (nil? headers) (vs/jm)
+                (let [o (vs/clone headers)] (if (vs/ismap o) o (vs/jm))))
+        point (oget ctx :point)
+        args (when point (vs/getprop point "args"))
+        aheader (let [h (when (vs/ismap args) (vs/getprop args "header"))]
+                  (if (vs/islist h) h (vs/jt)))]
+    ;; A header parameter travels as a header, under the name the definition
+    ;; gives it, and only from this call's own arguments. It replaces a default
+    ;; of the same name, whatever its case.
+    (doseq [hd (vec aheader)]
+      (let [name (when (vs/ismap hd) (vs/getprop hd "name"))]
+        (when (and (string? name) (seq name))
+          (let [orig (vs/getprop hd "orig")
+                wire (if (and (string? orig) (seq orig)) orig name)
+                v (vs/getprop (oget ctx :reqmatch) name)
+                v (if (nil? v) (vs/getprop (oget ctx :reqdata) name) v)]
+            (when (some? v)
+              (let [key (str/lower-case wire)]
+                (doseq [k (vec (.keySet ^java.util.Map out))]
+                  (when (and (string? k) (= key (str/lower-case k)))
+                    (.remove ^java.util.Map out k)))
+                (.put ^java.util.Map out key (vs/stringify v))))))))
+    out))
 
 (defn u-param [ctx paramdef]
   (let [point (oget ctx :point)
@@ -506,8 +527,14 @@
         aparams (let [args (when point (vs/getprop point "args"))
                       p (when (vs/ismap args) (vs/getprop args "params"))]
                   (if (vs/islist p) p (vs/jt)))
-        pset (into (into #{} (vec params))
-                   (keep (fn [pd] (when (vs/ismap pd) (vs/getprop pd "name"))) (vec aparams)))
+        ;; A header parameter travels in the headers, which u-prepare-headers
+        ;; fills.
+        aheader (let [args (when point (vs/getprop point "args"))
+                      h (when (vs/ismap args) (vs/getprop args "header"))]
+                  (if (vs/islist h) h (vs/jt)))
+        pset (into (into (into #{} (vec params))
+                         (keep (fn [pd] (when (vs/ismap pd) (vs/getprop pd "name"))) (vec aparams)))
+                   (keep (fn [hd] (when (vs/ismap hd) (vs/getprop hd "name"))) (vec aheader)))
         ;; A query parameter travels under the name the definition gives it,
         ;; its orig, which the model may have renamed for the caller.
         aquery (let [args (when point (vs/getprop point "args"))
@@ -526,26 +553,39 @@
           (.put ^java.util.Map out (get wire k k) v))))
     out))
 
-;; `$action` selects the point (see u-make-point); it is never an API field,
-;; so the body is a copy without it. The caller's map is left untouched.
-(defn- strip-action [reqdata]
-  (if (and (vs/ismap reqdata) (.containsKey ^java.util.Map reqdata "$action"))
+(defn- omit-keys [reqdata names]
+  (if (and (vs/ismap reqdata) (some #(.containsKey ^java.util.Map reqdata %) names))
     (let [body (vs/jm)]
       (doseq [item (or (vs/items reqdata) [])]
         (let [k (vs/getprop item 0) v (vs/getprop item 1)]
-          (when (not= "$action" k) (.put ^java.util.Map body k v))))
+          (when-not (some #(= k %) names) (.put ^java.util.Map body k v))))
       body)
     reqdata))
 
+;; `$action` selects the point (see u-make-point); it is never an API field,
+;; so the body is a copy without it. The caller's map is left untouched.
+(defn- strip-action [reqdata] (omit-keys reqdata ["$action"]))
+
+;; A header argument travels as a header, which u-prepare-headers sends, so the
+;; body is built from the request data without it.
+(defn- header-arg-names [point]
+  (let [args (when point (vs/getprop point "args"))
+        h (when (vs/ismap args) (vs/getprop args "header"))]
+    (if (vs/islist h)
+      (filterv #(and (string? %) (seq %))
+               (map #(when (vs/ismap %) (vs/getprop % "name")) (vec h)))
+      [])))
+
 (defn u-transform-request [ctx]
-  (let [spec (oget ctx :spec) point (oget ctx :point)]
+  (let [spec (oget ctx :spec) point (oget ctx :point)
+        data (omit-keys (oget ctx :reqdata) (header-arg-names point))]
     (when spec (oset! spec :step "reqform"))
     (let [transform (to-map (vs/getprop point "transform"))]
       (strip-action
-       (if (nil? transform) (oget ctx :reqdata)
+       (if (nil? transform) data
            (let [reqform (vs/getprop transform "req")]
-             (if (nil? reqform) (oget ctx :reqdata)
-                 (vs/transform (vs/jm "reqdata" (oget ctx :reqdata)) reqform))))))))
+             (if (nil? reqform) data
+                 (vs/transform (vs/jm "reqdata" data) reqform))))))))
 
 (defn u-prepare-body [ctx]
   (if (= "data" (op-input (oget ctx :op))) (ucall ctx :transform-request) nil))
@@ -817,7 +857,14 @@
       (nil? result) ["" (ctx-error ctx "url_no_result" "Expected context result property to be defined.")]
       :else
       (let [url (atom (vs/join (vs/jt (oget spec :base) (oget spec :prefix) (oget spec :path) (oget spec :suffix)) "/" true))
-            resmatch (vs/jm)]
+            resmatch (vs/jm)
+            point (oget ctx :point)
+            orig (when point (vs/getprop point "orig"))]
+        ;; A route the definition ends with a slash keeps it: a server such as a
+        ;; Django REST one redirects or refuses the route without it.
+        (when (and (string? orig) (str/ends-with? orig "/") (empty? (str (oget spec :suffix)))
+                   (not (str/ends-with? @url "/")))
+          (swap! url str "/"))
         (doseq [item (or (vs/items (oget spec :params)) [])]
           (let [k (vs/getprop item 0) v (vs/getprop item 1)]
             (when (and (some? v) (string? k))

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

@@ -281,6 +281,14 @@ inline std::string makeUrl(CtxPtr ctx) {
   Value joinParts = vlist({Value(spec->base), Value(spec->prefix), Value(spec->path), Value(spec->suffix)});
   std::string url = Struct::join(joinParts, "/", true);
 
+  // A route the definition ends with a slash keeps it: a server such as a
+  // Django REST one redirects or refuses the route without it.
+  Value orig = ctx->point.is_map() ? getp(ctx->point, "orig") : Value::undef();
+  if (orig.is_string() && !orig.as_string().empty() && '/' == orig.as_string().back() &&
+      spec->suffix.empty() && (url.empty() || '/' != url.back())) {
+    url += "/";
+  }
+
   Value resmatch = vmap();
 
   for (const auto& item : Struct::items(spec->params)) {
@@ -921,9 +929,35 @@ inline Value prepareBody(CtxPtr ctx) {
 inline Value prepareHeaders(CtxPtr ctx) {
   Value options = ctx->client->optionsMap();
   Value headers = getp(options, "headers");
-  if (is_nullish(headers)) return vmap();
-  Value out = Helpers::toMapAny(Struct::clone(headers));
-  return out.is_map() ? out : vmap();
+  Value out = is_nullish(headers) ? vmap() : Helpers::toMapAny(Struct::clone(headers));
+  if (!out.is_map()) out = vmap();
+
+  // A header parameter travels as a header, under the name the definition
+  // gives it, and only from this call's own arguments. It replaces a default
+  // of the same name, whatever its case.
+  auto lower = [](std::string s) {
+    for (auto& ch : s) ch = (char)std::tolower((unsigned char)ch);
+    return s;
+  };
+  Value aheader = ctx->point.is_map() ? getp(getp(ctx->point, "args"), "header") : Value::undef();
+  if (aheader.is_list()) {
+    for (const auto& hd : *aheader.as_list()) {
+      Value name = getp(hd, "name");
+      if (!name.is_string() || name.as_string().empty()) continue;
+      Value orig = getp(hd, "orig");
+      std::string wire = lower(orig.is_string() && !orig.as_string().empty() ?
+        orig.as_string() : name.as_string());
+      Value val = getp(ctx->reqmatch, name.as_string(), Value(nullptr));
+      if (val.is_null()) val = getp(ctx->reqdata, name.as_string(), Value(nullptr));
+      if (is_nullish(val)) continue;
+      for (const auto& item : Struct::items(out)) {
+        std::string key = as_str(pair_key(item));
+        if (lower(key) == wire) out.as_map()->erase(key);
+      }
+      map_put(out, wire, Value(Struct::stringify(val)));
+    }
+  }
+  return out;
 }
 
 // ---- param ------------------------------------------------------------
@@ -1024,10 +1058,12 @@ inline Value prepareQuery(CtxPtr ctx) {
 
   // A path parameter travels in the path. The generated config lists them as
   // args.params, which prepareParams reads; params is the older list of names.
+  // A header parameter travels in the headers, which prepareHeaders fills.
   Value aparams = point.is_map() ? getp(getp(point, "args"), "params") : Value::undef();
-  auto in_args = [&](const std::string& s) {
-    if (!aparams.is_list()) return false;
-    for (const auto& pd : *aparams.as_list()) {
+  Value aheader = point.is_map() ? getp(getp(point, "args"), "header") : Value::undef();
+  auto named = [&](const Value& defs, const std::string& s) {
+    if (!defs.is_list()) return false;
+    for (const auto& pd : *defs.as_list()) {
       Value name = getp(pd, "name");
       if (name.is_string() && name.as_string() == s) return true;
     }
@@ -1055,7 +1091,8 @@ 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) && "$action" != key && !contains_str(params, key) && !in_args(key)) {
+    if (!is_nullish(val) && "$action" != key && !contains_str(params, key) &&
+        !named(aparams, key) && !named(aheader, key)) {
       map_put(out, wire_name(key), val);
     }
   }
@@ -1079,29 +1116,49 @@ 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;
+inline Value omitKeys(const Value& reqdata, const std::vector<std::string>& names) {
+  bool has = false;
+  for (const auto& name : names) has = has || map_contains(reqdata, name);
+  if (!has) 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));
+    if (std::find(names.begin(), names.end(), key) == names.end()) map_put(body, key, pair_val(item));
   }
   return body;
 }
 
+// `$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) { return omitKeys(reqdata, {"$action"}); }
+
+// A header argument travels as a header, which prepareHeaders sends, so the
+// body is built from the request data without it.
+inline std::vector<std::string> headerArgNames(CtxPtr ctx) {
+  std::vector<std::string> names;
+  Value aheader = ctx->point.is_map() ? getp(getp(ctx->point, "args"), "header") : Value::undef();
+  if (aheader.is_list()) {
+    for (const auto& hd : *aheader.as_list()) {
+      Value name = getp(hd, "name");
+      if (name.is_string() && !name.as_string().empty()) names.push_back(name.as_string());
+    }
+  }
+  return names;
+}
+
 inline Value transformRequest(CtxPtr ctx) {
   if (ctx->spec) ctx->spec->step = "reqform";
 
+  Value reqdata = omitKeys(ctx->reqdata, headerArgNames(ctx));
+
   Value transform = Helpers::toMapAny(getp(ctx->point, "transform"));
-  if (!transform.is_map()) return stripAction(ctx->reqdata);
+  if (!transform.is_map()) return stripAction(reqdata);
 
   Value reqform = getp(transform, "req");
-  if (is_nullish(reqform)) return stripAction(ctx->reqdata);
+  if (is_nullish(reqform)) return stripAction(reqdata);
 
   Value data = vmap();
-  map_put(data, "reqdata", ctx->reqdata);
+  map_put(data, "reqdata", reqdata);
   return stripAction(Struct::transform(data, reqform));
 }
 

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

@@ -20,6 +20,14 @@ public static partial class SdkUtility
             StructUtils.Jt(spec.Base, spec.Prefix, spec.Path, spec.Suffix), "/", true);
         var resmatch = new Dictionary<string, object?>();
 
+        // A route the definition ends with a slash keeps it: a server such as
+        // a Django REST one redirects or refuses the route without it.
+        if (ctx.Point != null && StructUtils.GetProp(ctx.Point, "orig") is string orig &&
+            orig.EndsWith("/") && string.IsNullOrEmpty(spec.Suffix) && !url.EndsWith("/"))
+        {
+            url += "/";
+        }
+
         foreach (var item in StructUtils.Items(spec.Params))
         {
             var key = item[0] as string ?? "";

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

@@ -11,12 +11,42 @@ public static partial class SdkUtility
         var options = ctx.Client!.OptionsMap();
 
         var headers = StructUtils.GetProp(options, "headers");
-        if (headers == null)
+        var result = (headers == null ? null : StructUtils.Clone(headers) as Dictionary<string, object?>)
+            ?? new Dictionary<string, object?>();
+
+        // A header parameter travels as a header, under the name the
+        // definition gives it, and only from this call's own arguments. It
+        // replaces a default of the same name, whatever its case.
+        if (ctx.Point != null &&
+            StructUtils.GetPath(ctx.Point, StructUtils.Jt("args", "header")) is List<object?> hl)
         {
-            return new Dictionary<string, object?>();
+            foreach (var hd in hl)
+            {
+                if (StructUtils.GetProp(hd, "name") is not string name || name == "")
+                {
+                    continue;
+                }
+                var wire = StructUtils.GetProp(hd, "orig") is string orig && orig != "" ? orig : name;
+                var val = ctx.Reqmatch == null ? null : StructUtils.GetProp(ctx.Reqmatch, name);
+                if (val == null && ctx.Reqdata != null)
+                {
+                    val = StructUtils.GetProp(ctx.Reqdata, name);
+                }
+                if (val != null)
+                {
+                    var key = wire.ToLowerInvariant();
+                    foreach (var k in new List<string>(result.Keys))
+                    {
+                        if (k.ToLowerInvariant() == key)
+                        {
+                            result.Remove(k);
+                        }
+                    }
+                    result[key] = StructUtils.Stringify(val);
+                }
+            }
         }
 
-        return StructUtils.Clone(headers) as Dictionary<string, object?>
-            ?? new Dictionary<string, object?>();
+        return result;
     }
 }

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

@@ -31,6 +31,20 @@ public static partial class SdkUtility
             }
         }
 
+        // A header parameter travels in the headers, which PrepareHeaders
+        // fills.
+        if (point != null &&
+            StructUtils.GetPath(point, StructUtils.Jt("args", "header")) is List<object?> ahl)
+        {
+            foreach (var hd in ahl)
+            {
+                if (StructUtils.GetProp(hd, "name") is string hname)
+                {
+                    paramnames.Add(hname);
+                }
+            }
+        }
+
         // A query parameter travels under the name the definition gives it,
         // its orig, which the model may have renamed for the caller.
         var wire = new Dictionary<string, string>();

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

@@ -17,21 +17,23 @@ public static partial class SdkUtility
             spec.Step = "reqform";
         }
 
+        var data = OmitKeys(ctx.Reqdata, HeaderArgNames(point));
+
         var transform = Helpers.ToMapAny(StructUtils.GetProp(point, "transform"));
         if (transform == null)
         {
-            return StripAction(ctx.Reqdata);
+            return StripAction(data);
         }
 
         var reqform = StructUtils.GetProp(transform, "req");
         if (reqform == null)
         {
-            return StripAction(ctx.Reqdata);
+            return StripAction(data);
         }
 
         var reqdata = StructUtils.Transform(new Dictionary<string, object?>
         {
-            ["reqdata"] = ctx.Reqdata,
+            ["reqdata"] = data,
         }, reqform);
 
         return StripAction(reqdata);
@@ -42,14 +44,38 @@ public static partial class SdkUtility
     // untouched.
     private static object? StripAction(object? reqdata)
     {
-        if (reqdata is not IDictionary<string, object?> src || !src.ContainsKey("$action"))
+        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)
+    {
+        var names = new List<string>();
+        if (point != null &&
+            StructUtils.GetPath(point, StructUtils.Jt("args", "header")) is List<object?> hl)
+        {
+            foreach (var hd in hl)
+            {
+                if (StructUtils.GetProp(hd, "name") is string name && name != "")
+                {
+                    names.Add(name);
+                }
+            }
+        }
+        return names;
+    }
+
+    private static object? OmitKeys(object? reqdata, List<string> names)
+    {
+        if (reqdata is not IDictionary<string, object?> src || !names.Exists(src.ContainsKey))
         {
             return reqdata;
         }
         var body = new Dictionary<string, object?>();
         foreach (var kv in src)
         {
-            if ("$action" != kv.Key)
+            if (!names.Contains(kv.Key))
             {
                 body[kv.Key] = kv.Value;
             }