@voxgig/sdkgen 4.31.1 → 4.32.0

package/project/.sdk/tm/js/test/definition-runner.js

@@ -32,6 +32,7 @@ async function runDefinitionPoint(SDK, point) {
 
   const input = { ...point.select }
   for (const arg of point.args) input[arg.name] = arg.value
+  for (const h of point.headers || []) input[h.name] = h.value
   if (null != point.action) input.$action = point.action
 
   let result
@@ -53,7 +54,9 @@ async function runDefinitionPoint(SDK, point) {
     const arg = point.args.find((a) => a.wire === name)
     return null == arg ? '{' + name + '}' : encodeURIComponent(String(arg.value))
   })
-  assert.equal(url.pathname, route, 'route')
+  // Read as the request was, so a backslash in the definition's path, as in
+  // GitLab's `Packages\(\)`, is the slash the URL parser makes it.
+  assert.equal(url.pathname, new URL(BASE + route).pathname, 'route')
 
   // Only what the definition declares, so never a path parameter again.
   const credentialQuery = (point.auth || []).flat()
@@ -70,6 +73,18 @@ async function runDefinitionPoint(SDK, point) {
       'credential not sent as the definition declares it: ' + JSON.stringify(point.auth))
   }
 
+  // A header parameter goes out as a header. The credential check above owns
+  // any header the security scheme names, and the SDK sets the content type
+  // from the body it sends.
+  const credentialHeaders = (point.auth || []).flat()
+    .filter((c) => 'header' === c.in).map((c) => c.name.toLowerCase())
+  for (const h of point.headers || []) {
+    const wire = h.wire.toLowerCase()
+    if (credentialHeaders.includes(wire) || 'content-type' === wire) continue
+    assert.equal(new Headers(init.headers).get(wire), String(h.value),
+      'header parameter not sent as a header: ' + h.wire)
+  }
+
   if (null != error) {
     throw error
   }
@@ -88,7 +103,7 @@ async function runDefinitionPoint(SDK, point) {
     }
   }
   else if ('load' === point.op || 'create' === point.op || 'update' === point.op) {
-    const record = recordOf(point.sample, point.idField)
+    const record = recordOf(point.sample, point.idField, point.entity)
     if (null != record) {
       assert.equal(result?.data?.()?.[point.idField], record[point.idField],
         'the entity does not hold the record the definition example returns')
@@ -128,33 +143,79 @@ function placed(cred, headers, url) {
 }
 
 
-// The records a list response holds: the body itself, or its one property
-// that is a non-empty list of objects. Anything else proves nothing.
+// What an envelope may hold beside what it carries, compared without case,
+// `_` or `-`: status, paging and the page's own metadata, each by its whole
+// name, so a record's homepage or preview is data of its own.
+const ENVELOPE_KEYS = new Set([
+  'success', 'status', 'ok', 'message', 'code', 'error', 'errorcode', 'errormessage',
+  'requestid', 'timestamp', 'took', 'version', 'apiversion', 'object', 'url',
+  'count', 'total', 'totalcount', 'totalhits', 'totalitems', 'totalpages', 'totalresults',
+  'totalrecords', 'totalrowcount', 'totalentries', 'itemcount', 'resultcount', 'rowcount',
+  'page', 'pages', 'pagecount', 'pagenumber', 'pageindex', 'pagesize', 'perpage',
+  'currentpage', 'lastpage', 'limit', 'offset', 'cursor', 'nextcursor', 'prevcursor',
+  'previouscursor', 'next', 'nextpage', 'nexturl', 'nextlink', 'nextpagetoken', 'nexttoken',
+  'pagetoken', 'continuationtoken', 'prev', 'previous', 'prevpage', 'previouspage',
+  'prevurl', 'previousurl', 'prevlink', 'hasmore', 'hasnext', 'hasnextpage', 'hasprevious',
+  'haspreviouspage', 'more', 'meta', 'metadata', 'pagination', 'paging', 'pageinfo', 'links',
+])
+
+
+function envelopeKey(key) {
+  return ENVELOPE_KEYS.has(squash(key))
+}
+
+
+function ownData(sample) {
+  return Object.entries(sample).some(([key, value]) =>
+    null != value && 'object' !== typeof value && !envelopeKey(key))
+}
+
+
+function isRecord(value) {
+  return null != value && 'object' === typeof value && !Array.isArray(value)
+}
+
+
+// The records a list response holds: the body itself, or the one non-empty
+// list of objects in a page. Anything else, such as a record that happens to
+// hold a list, proves nothing.
 function recordsOf(sample) {
   if (Array.isArray(sample)) {
     return sample
   }
-  if (null == sample || 'object' !== typeof sample) {
+  if (!isRecord(sample) || ownData(sample)) {
     return null
   }
   const lists = Object.values(sample).filter((v) => Array.isArray(v) && 0 < v.length &&
-    v.every((x) => null != x && 'object' === typeof x && !Array.isArray(x)))
+    v.every(isRecord))
   return 1 === lists.length ? lists[0] : null
 }
 
 
-// The record a single-item response returns: the body, or its one property
-// holding an object with the identity field.
-function recordOf(sample, idField) {
-  if (null == sample || 'object' !== typeof sample || Array.isArray(sample)) {
+// The record a single-item response returns: the body, or the one object
+// with the identity field that an envelope carries, under the entity's name
+// or beside envelope keys alone. Otherwise the body is the record itself,
+// such as GitHub's check suite preferences beside their repository.
+function recordOf(sample, idField, entity) {
+  if (!isRecord(sample)) {
     return null
   }
   if (null != sample[idField]) {
     return sample
   }
-  const inner = Object.values(sample).filter((v) => null != v && 'object' === typeof v &&
-    !Array.isArray(v) && null != v[idField])
-  return 1 === inner.length ? inner[0] : null
+  const keys = Object.keys(sample)
+  const inner = keys.filter((key) => isRecord(sample[key]) && null != sample[key][idField])
+  if (1 !== inner.length) {
+    return null
+  }
+  const named = null != entity && squash(inner[0]) === squash(entity) && !ownData(sample)
+  const alone = keys.every((key) => key === inner[0] || envelopeKey(key))
+  return named || alone ? sample[inner[0]] : null
+}
+
+
+function squash(name) {
+  return name.toLowerCase().replace(/[_-]/g, '')
 }
 
 

package/project/.sdk/tm/kotlin/utility/MakeSpecUrl.kt

@@ -104,6 +104,14 @@ fun makeUrl(ctx: Context): String {
   joinParts.add(spec.suffix)
   var 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.
+  val point = ctx.point
+  val orig = if (point == null) null else Struct.getprop(point, "orig", null)
+  if (orig is String && orig.endsWith("/") && spec.suffix.isEmpty() && !url.endsWith("/")) {
+    url += "/"
+  }
+
   val resmatch = linkedMapOf<String, Any?>()
 
   val params = spec.params

package/project/.sdk/tm/kotlin/utility/Prepare.kt

@@ -100,12 +100,32 @@ fun prepareHeaders(ctx: Context): MutableMap<String, Any?> {
   val options = ctx.client!!.optionsMap()
 
   val headers = Struct.getprop(options, "headers", null)
-  if (headers == null) {
-    return linkedMapOf()
+  val out: MutableMap<String, Any?> =
+    (if (headers == null) null else Helpers.toMapAny(Struct.clone(headers))) ?: linkedMapOf()
+
+  // 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.
+  val point = ctx.point
+  val hl = if (point == null) null else Struct.getpath(point, listOf("args", "header"))
+  if (hl is List<*>) {
+    for (hd in hl) {
+      val name = Struct.getprop(hd, "name")
+      if (name !is String || name.isEmpty()) {
+        continue
+      }
+      val orig = Struct.getprop(hd, "orig")
+      val wire = if (orig is String && orig.isNotEmpty()) orig else name
+      val v = Struct.getprop(ctx.reqmatch, name, null) ?: Struct.getprop(ctx.reqdata, name, null)
+      if (v != null) {
+        val key = wire.lowercase()
+        out.keys.removeAll { it.lowercase() == key }
+        out[key] = Struct.stringify(v)
+      }
+    }
   }
 
-  val out = Helpers.toMapAny(Struct.clone(headers))
-  return out ?: linkedMapOf()
+  return out
 }
 
 fun prepareMethod(ctx: Context): String? {
@@ -196,6 +216,16 @@ fun prepareQuery(ctx: Context): MutableMap<String, Any?> {
         }
       }
     }
+    // A header parameter travels in the headers, which prepareHeaders fills.
+    val hl = Struct.getpath(point, listOf("args", "header"))
+    if (hl is List<*>) {
+      for (hd in hl) {
+        val name = Struct.getprop(hd, "name")
+        if (name is String) {
+          params.add(name)
+        }
+      }
+    }
   }
 
   // A query parameter travels under the name the definition gives it, its

package/project/.sdk/tm/kotlin/utility/ResultTransform.kt

@@ -60,13 +60,23 @@ fun resultHeaders(ctx: Context): KOTLINPACKAGE.core.Result {
 
 // `$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.
-private fun stripAction(reqdata: Any?): Any? {
-  if (reqdata !is Map<*, *> || !reqdata.containsKey("\$action")) {
+private fun stripAction(reqdata: Any?): Any? = omitKeys(reqdata, listOf("\$action"))
+
+// A header argument travels as a header, which prepareHeaders sends, so the
+// body is built from the request data without it.
+private fun headerArgNames(ctx: Context): List<String> {
+  val point = ctx.point ?: return emptyList()
+  val hl = Struct.getpath(point, listOf("args", "header")) as? List<*> ?: return emptyList()
+  return hl.mapNotNull { hd -> (Struct.getprop(hd, "name", null) as? String)?.takeIf { it.isNotEmpty() } }
+}
+
+private fun omitKeys(reqdata: Any?, names: List<String>): Any? {
+  if (reqdata !is Map<*, *> || names.none { reqdata.containsKey(it) }) {
     return reqdata
   }
   val body = linkedMapOf<String, Any?>()
   for ((k, v) in reqdata) {
-    if ("\$action" != k) {
+    if (k.toString() !in names) {
       body[k.toString()] = v
     }
   }
@@ -78,14 +88,16 @@ fun transformRequest(ctx: Context): Any? {
     ctx.spec!!.step = "reqform"
   }
 
+  val reqdata = omitKeys(ctx.reqdata, headerArgNames(ctx))
+
   val transform = Helpers.toMapAny(Struct.getprop(ctx.point, "transform"))
-    ?: return stripAction(ctx.reqdata)
+    ?: return stripAction(reqdata)
 
   val reqform = Struct.getprop(transform, "req", null)
-    ?: return stripAction(ctx.reqdata)
+    ?: return stripAction(reqdata)
 
   val data = linkedMapOf<String, Any?>()
-  data["reqdata"] = ctx.reqdata
+  data["reqdata"] = reqdata
 
   return stripAction(Struct.transform(data, reqform))
 }

package/project/.sdk/tm/lua/utility/make_url.lua

@@ -18,6 +18,14 @@ local function make_url_util(ctx)
   local url = vs.join({ spec.base, spec.prefix, spec.path, spec.suffix }, "/", true)
   local resmatch = {}
 
+  -- 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.
+  local orig = ctx.point ~= nil and vs.getprop(ctx.point, "orig") or nil
+  if type(orig) == "string" and orig:sub(-1) == "/" and (spec.suffix == nil or spec.suffix == "")
+      and url:sub(-1) ~= "/" then
+    url = url .. "/"
+  end
+
   local param_items = vs.items(spec.params)
   if param_items ~= nil then
     for _, item in ipairs(param_items) do

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

@@ -6,15 +6,44 @@ local function prepare_headers_util(ctx)
   local options = ctx.client:options_map()
   local headers = vs.getprop(options, "headers")
 
-  if headers == nil then
-    return {}
+  local out = {}
+  if headers ~= nil then
+    local cloned = vs.clone(headers)
+    if type(cloned) == "table" then
+      out = cloned
+    end
   end
 
-  local out = vs.clone(headers)
-  if type(out) == "table" then
-    return out
+  -- 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.
+  local hl = ctx.point ~= nil and vs.getpath(ctx.point, "args.header") or nil
+  if type(hl) == "table" then
+    for _, hd in ipairs(hl) do
+      local name = vs.getprop(hd, "name")
+      if type(name) == "string" and name ~= "" then
+        local orig = vs.getprop(hd, "orig")
+        if type(orig) ~= "string" or orig == "" then
+          orig = name
+        end
+        local val = vs.getprop(ctx.reqmatch or {}, name)
+        if val == nil then
+          val = vs.getprop(ctx.reqdata or {}, name)
+        end
+        if val ~= nil then
+          local wire = string.lower(orig)
+          for key in pairs(out) do
+            if type(key) == "string" and string.lower(key) == wire then
+              out[key] = nil
+            end
+          end
+          out[wire] = vs.stringify(val)
+        end
+      end
+    end
   end
-  return {}
+
+  return out
 end
 
 return prepare_headers_util

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

@@ -34,6 +34,16 @@ local function prepare_query_util(ctx)
         end
       end
     end
+    -- A header parameter travels in the headers, which prepare_headers fills.
+    local hl = vs.getpath(point, "args.header")
+    if type(hl) == "table" then
+      for _, hd in ipairs(hl) do
+        local name = vs.getprop(hd, "name")
+        if type(name) == "string" then
+          table.insert(params, name)
+        end
+      end
+    end
   end
 
   -- A query parameter travels under the name the definition gives it, its

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

@@ -6,19 +6,48 @@ local helpers = require("core.helpers")
 -- `$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 table is left
 -- untouched.
-local function strip_action(reqdata)
-  if not vs.ismap(reqdata) or reqdata["$action"] == nil then
+local function omit(reqdata, names)
+  if not vs.ismap(reqdata) then
+    return reqdata
+  end
+  local skip = {}
+  local found = false
+  for _, name in ipairs(names) do
+    skip[name] = true
+    found = found or reqdata[name] ~= nil
+  end
+  if not found then
     return reqdata
   end
   local body = {}
   for k, v in pairs(reqdata) do
-    if k ~= "$action" then
+    if not skip[k] then
       body[k] = v
     end
   end
   return body
 end
 
+local function strip_action(reqdata)
+  return omit(reqdata, { "$action" })
+end
+
+-- A header argument travels as a header, which prepare_headers_util sends, so
+-- the body is built from the request data without it.
+local function header_arg_names(point)
+  local names = {}
+  local hl = point ~= nil and vs.getpath(point, "args.header") or nil
+  if type(hl) == "table" then
+    for _, hd in ipairs(hl) do
+      local name = vs.getprop(hd, "name")
+      if type(name) == "string" and name ~= "" then
+        names[#names + 1] = name
+      end
+    end
+  end
+  return names
+end
+
 local function transform_request_util(ctx)
   local spec = ctx.spec
   local point = ctx.point
@@ -27,18 +56,20 @@ local function transform_request_util(ctx)
     spec.step = "reqform"
   end
 
+  local data = omit(ctx.reqdata, header_arg_names(point))
+
   local transform = helpers.to_map(vs.getprop(point, "transform"))
   if transform == nil then
-    return strip_action(ctx.reqdata)
+    return strip_action(data)
   end
 
   local reqform = vs.getprop(transform, "req")
   if reqform == nil then
-    return strip_action(ctx.reqdata)
+    return strip_action(data)
   end
 
   local reqdata = vs.transform({
-    reqdata = ctx.reqdata,
+    reqdata = data,
   }, reqform)
 
   return strip_action(reqdata)

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -355,9 +355,35 @@ let prepare_method_util (ctx : ctx) : string =
 
 let prepare_headers_util (ctx : ctx) : value =
   let options = client_options_map (cc ctx) in
-  match getp options "headers" with
-  | Noval -> empty_map ()
-  | h -> (match clone h with Map _ as m -> m | _ -> empty_map ())
+  let out =
+    match getp options "headers" with
+    | Noval -> empty_map ()
+    | h -> (match clone h with Map _ as m -> m | _ -> empty_map ())
+  in
+  (* 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. *)
+  (match getp (getp ctx.c_point "args") "header" with
+   | List r ->
+     List.iter (fun hd ->
+         match getp hd "name" with
+         | Str name when name <> "" ->
+           let wire = match getp hd "orig" with Str o when o <> "" -> o | _ -> name in
+           let v = match getp ctx.c_reqmatch name with
+             | Noval | Null -> getp ctx.c_reqdata name
+             | v -> v
+           in
+           (match v with
+            | Noval | Null -> ()
+            | v ->
+              let key = String.lowercase_ascii wire in
+              List.iter (fun k ->
+                  if String.lowercase_ascii k = key then ignore (delprop out (Str k)))
+                (keysof out);
+              setp out key (Str (stringify v)))
+         | _ -> ()) !r
+   | _ -> ());
+  out
 
 let param_util (ctx : ctx) (paramdef : value) : value =
   let point = ctx.c_point and spec = ctx.c_spec in
@@ -418,7 +444,13 @@ let prepare_query_util (ctx : ctx) : value =
     | List r -> List.map (fun pd -> getp pd "name") !r
     | _ -> []
   in
-  let params = params @ arg_names in
+  (* A header parameter travels in the headers, which prepare_headers fills. *)
+  let header_names =
+    match getp (getp ctx.c_point "args") "header" with
+    | List r -> List.map (fun hd -> getp hd "name") !r
+    | _ -> []
+  in
+  let params = params @ arg_names @ header_names in
   let contains_param s = List.exists (fun v -> match v with Str x -> x = s | _ -> false) params in
   (* A query parameter travels under the name the definition gives it, its
    * orig, which the model may have renamed for the caller. *)
@@ -578,27 +610,39 @@ let prepare_auth_util = Sdk_prepare_auth.prepare_auth_util
 
 (* ----- transforms / result helpers ----- *)
 
-(* `$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. *)
-let strip_action (reqdata : value) : value =
+let omit_keys (reqdata : value) (names : string list) : value =
   match reqdata with
-  | Map _ when List.mem "$action" (keysof reqdata) ->
+  | Map _ when List.exists (fun n -> List.mem n (keysof reqdata)) names ->
     let body = empty_map () in
-    List.iter (fun k -> if k <> "$action" then setp body k (getp reqdata k))
+    List.iter (fun k -> if not (List.mem k names) then setp body k (getp reqdata k))
       (keysof reqdata);
     body
   | _ -> reqdata
 
+(* `$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. *)
+let strip_action (reqdata : value) : value = omit_keys reqdata ["$action"]
+
+(* A header argument travels as a header, which prepare_headers_util sends,
+   so the body is built from the request data without it. *)
+let header_arg_names (point : value) : string list =
+  match getp (getp point "args") "header" with
+  | List r ->
+    List.filter_map (fun hd ->
+        match getp hd "name" with Str n when n <> "" -> Some n | _ -> None) !r
+  | _ -> []
+
 let transform_request_util (ctx : ctx) : value =
   (match ctx.c_spec with Some s -> s.sp_step <- "reqform" | None -> ());
+  let data = omit_keys ctx.c_reqdata (header_arg_names ctx.c_point) in
   strip_action
     (match to_map (getp ctx.c_point "transform") with
      | Map _ as tr ->
        (match getp tr "req" with
-        | Noval -> ctx.c_reqdata
-        | reqform -> transform (jo [("reqdata", ctx.c_reqdata)]) reqform)
-     | _ -> ctx.c_reqdata)
+        | Noval -> data
+        | reqform -> transform (jo [("reqdata", data)]) reqform)
+     | _ -> data)
 
 let transform_response_util (ctx : ctx) : value =
   (match ctx.c_spec with Some s -> s.sp_step <- "resform" | None -> ());
@@ -804,6 +848,12 @@ let make_url_util (ctx : ctx) : (string * sdk_error option) =
   | _, None -> ("", Some (ctx_make_error ctx "url_no_result" "Expected context result property to be defined."))
   | Some spec, Some result ->
     let url = ref (join ~sep:(Str "/") ~url:true (ja [Str spec.sp_base; Str spec.sp_prefix; Str spec.sp_path; Str spec.sp_suffix])) in
+    (* 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. *)
+    let ends_slash s = String.length s > 0 && '/' = s.[String.length s - 1] in
+    (match getp ctx.c_point "orig" with
+     | Str o when ends_slash o && spec.sp_suffix = "" && not (ends_slash !url) -> url := !url ^ "/"
+     | _ -> ());
     let resmatch = empty_map () in
     List.iter (fun key ->
         let v = getp spec.sp_params key in

package/project/.sdk/tm/perl/utility/make_url.pm

@@ -29,6 +29,12 @@ $REGISTRY{make_url} = sub {
     [$spec->{base}, $spec->{prefix}, $spec->{path}, $spec->{suffix}], '/', 1);
   my $resmatch = {};
 
+  # 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.
+  my $orig = $ctx->{point} ? ProjectNameHelpers::gp($ctx->{point}, 'orig') : undef;
+  $url .= '/' if defined $orig && !ref $orig && $orig =~ m{/\z}
+    && !(defined $spec->{suffix} && '' ne $spec->{suffix}) && $url !~ m{/\z};
+
   my $param_items = Voxgig::Struct::items($spec->{params});
   if ($param_items) {
     for my $item (@$param_items) {

package/project/.sdk/tm/perl/utility/prepare_headers.pm

@@ -19,9 +19,27 @@ $REGISTRY{prepare_headers} = sub {
   my ($ctx) = @_;
   my $options = $ctx->{client}->options_map;
   my $headers = ProjectNameHelpers::gp($options, 'headers');
-  return {} unless ProjectNameHelpers::rb_truthy($headers);
-  my $out = Voxgig::Struct::clone($headers);
-  return Voxgig::Struct::ismap($out) ? $out : {};
+  my $out = ProjectNameHelpers::rb_truthy($headers) ? Voxgig::Struct::clone($headers) : {};
+  $out = {} unless Voxgig::Struct::ismap($out);
+  # 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.
+  my $hl = $ctx->{point} ? ProjectNameHelpers::gpath($ctx->{point}, 'args.header') : undef;
+  if (Voxgig::Struct::islist($hl)) {
+    for my $hd (@$hl) {
+      my $name = ProjectNameHelpers::gp($hd, 'name');
+      next unless defined $name && !ref $name && '' ne $name;
+      my $orig = ProjectNameHelpers::gp($hd, 'orig');
+      $orig = $name unless defined $orig && !ref $orig && '' ne $orig;
+      my $val = ProjectNameHelpers::gp($ctx->{reqmatch} || {}, $name);
+      $val = ProjectNameHelpers::gp($ctx->{reqdata} || {}, $name) unless defined $val;
+      next unless defined $val;
+      my $wire = lc $orig;
+      delete $out->{$_} for grep { lc $_ eq $wire } keys %$out;
+      $out->{$wire} = Voxgig::Struct::stringify($val);
+    }
+  }
+  return $out;
 };
 
 1;

package/project/.sdk/tm/perl/utility/prepare_query.pm

@@ -32,6 +32,14 @@ $REGISTRY{prepare_query} = sub {
         push @$params, $name if defined $name && !ref $name;
       }
     }
+    # A header parameter travels in the headers, which prepare_headers fills.
+    my $hl = ProjectNameHelpers::gpath($point, 'args.header');
+    if (Voxgig::Struct::islist($hl)) {
+      for my $hd (@$hl) {
+        my $name = ProjectNameHelpers::gp($hd, 'name');
+        push @$params, $name if defined $name && !ref $name;
+      }
+    }
   }
   # A query parameter travels under the name the definition gives it, its
   # orig, which the model may have renamed for the caller.

package/project/.sdk/tm/perl/utility/transform_request.pm

@@ -17,24 +17,36 @@ our %REGISTRY;
 
 # `$action` selects the point (see make_point); it is never an API field, so
 # the body is a copy without it. The caller's hash is left untouched.
-my $strip_action = sub {
-  my ($reqdata) = @_;
-  return $reqdata unless 'HASH' eq ref $reqdata && exists $reqdata->{'$action'};
+my $omit = sub {
+  my ($reqdata, @names) = @_;
+  return $reqdata unless 'HASH' eq ref $reqdata && grep { exists $reqdata->{$_} } @names;
   my %body = %$reqdata;
-  delete $body{'$action'};
+  delete @body{@names};
   return \%body;
 };
 
+my $strip_action = sub { $omit->($_[0], '$action') };
+
+# A header argument travels as a header, which prepare_headers sends, so the
+# body is built from the request data without it.
+my $header_arg_names = sub {
+  my ($point) = @_;
+  my $hl = $point ? ProjectNameHelpers::gpath($point, 'args.header') : undef;
+  return () unless Voxgig::Struct::islist($hl);
+  return grep { defined $_ && !ref $_ && '' ne $_ } map { ProjectNameHelpers::gp($_, 'name') } @$hl;
+};
+
 $REGISTRY{transform_request} = sub {
   my ($ctx) = @_;
   my $spec = $ctx->{spec};
   my $point = $ctx->{point};
   $spec->{step} = 'reqform' if $spec;
+  my $data = $omit->($ctx->{reqdata}, $header_arg_names->($point));
   my $transform = ProjectNameHelpers::to_map(ProjectNameHelpers::gp($point, 'transform'));
-  return $strip_action->($ctx->{reqdata}) unless $transform;
+  return $strip_action->($data) unless $transform;
   my $reqform = ProjectNameHelpers::gp($transform, 'req');
-  return $strip_action->($ctx->{reqdata}) unless ProjectNameHelpers::rb_truthy($reqform);
-  return $strip_action->(Voxgig::Struct::transform({ 'reqdata' => $ctx->{reqdata} }, $reqform));
+  return $strip_action->($data) unless ProjectNameHelpers::rb_truthy($reqform);
+  return $strip_action->(Voxgig::Struct::transform({ 'reqdata' => $data }, $reqform));
 };
 
 1;

package/project/.sdk/tm/php/utility/MakeUrl.php

@@ -20,6 +20,13 @@ class ProjectNameMakeUrl
         $url = \Voxgig\Struct\Struct::join([$spec->base, $spec->prefix, $spec->path, $spec->suffix], '/', true);
         $resmatch = [];
 
+        // 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.
+        $orig = $ctx->point ? \Voxgig\Struct\Struct::getprop($ctx->point, 'orig') : null;
+        if (is_string($orig) && str_ends_with($orig, '/') && '' === $spec->suffix && !str_ends_with($url, '/')) {
+            $url .= '/';
+        }
+
         $param_items = \Voxgig\Struct\Struct::items($spec->params);
         if ($param_items) {
             foreach ($param_items as $item) {