@voxgig/sdkgen 4.31.1 → 4.32.1

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) {

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

@@ -9,10 +9,39 @@ class ProjectNamePrepareHeaders
     {
         $options = $ctx->client->options_map();
         $headers = \Voxgig\Struct\Struct::getprop($options, 'headers');
-        if (!$headers) {
-            return [];
+        $out = $headers ? \Voxgig\Struct\Struct::clone($headers) : [];
+        if (!is_array($out)) {
+            $out = [];
         }
-        $out = \Voxgig\Struct\Struct::clone($headers);
-        return is_array($out) ? $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.
+        $hl = $ctx->point ? \Voxgig\Struct\Struct::getpath($ctx->point, 'args.header') : null;
+        if (is_array($hl)) {
+            foreach ($hl as $hd) {
+                $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
+                if (!is_string($name) || '' === $name) {
+                    continue;
+                }
+                $orig = \Voxgig\Struct\Struct::getprop($hd, 'orig');
+                if (!is_string($orig) || '' === $orig) {
+                    $orig = $name;
+                }
+                $val = \Voxgig\Struct\Struct::getprop($ctx->reqmatch ?? [], $name);
+                if (null === $val) {
+                    $val = \Voxgig\Struct\Struct::getprop($ctx->reqdata ?? [], $name);
+                }
+                if (null !== $val) {
+                    $wire = strtolower($orig);
+                    foreach (array_keys($out) as $key) {
+                        if (is_string($key) && strtolower($key) === $wire) {
+                            unset($out[$key]);
+                        }
+                    }
+                    $out[$wire] = \Voxgig\Struct\Struct::stringify($val);
+                }
+            }
+        }
+        return $out;
     }
 }

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

@@ -27,6 +27,17 @@ class ProjectNamePrepareQuery
                     }
                 }
             }
+            // A header parameter travels in the headers, which prepareHeaders
+            // fills.
+            $hl = \Voxgig\Struct\Struct::getpath($point, 'args.header');
+            if (is_array($hl)) {
+                foreach ($hl as $hd) {
+                    $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
+                    if (is_string($name)) {
+                        $params[] = $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/php/utility/TransformRequest.php

@@ -14,15 +14,16 @@ class ProjectNameTransformRequest
         if ($spec) {
             $spec->step = 'reqform';
         }
+        $data = self::omit($ctx->reqdata, self::header_arg_names($point));
         $transform = ProjectNameHelpers::to_map(\Voxgig\Struct\Struct::getprop($point, 'transform'));
         if (!$transform) {
-            return self::strip_action($ctx->reqdata);
+            return self::strip_action($data);
         }
         $reqform = \Voxgig\Struct\Struct::getprop($transform, 'req');
         if (!$reqform) {
-            return self::strip_action($ctx->reqdata);
+            return self::strip_action($data);
         }
-        return self::strip_action(\Voxgig\Struct\Struct::transform(['reqdata' => $ctx->reqdata], $reqform));
+        return self::strip_action(\Voxgig\Struct\Struct::transform(['reqdata' => $data], $reqform));
     }
 
     // `$action` selects the point (see MakePoint); it is never an API field,
@@ -30,10 +31,32 @@ class ProjectNameTransformRequest
     // never reaches the caller's copy.
     private static function strip_action(mixed $reqdata): mixed
     {
-        if (!is_array($reqdata) || !array_key_exists('$action', $reqdata)) {
+        return self::omit($reqdata, ['$action']);
+    }
+
+    // A header argument travels as a header, which PrepareHeaders sends, so
+    // the body is built from the request data without it.
+    private static function header_arg_names(mixed $point): array
+    {
+        $hl = $point ? \Voxgig\Struct\Struct::getpath($point, 'args.header') : null;
+        $names = [];
+        foreach (is_array($hl) ? $hl : [] as $hd) {
+            $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
+            if (is_string($name) && '' !== $name) {
+                $names[] = $name;
+            }
+        }
+        return $names;
+    }
+
+    private static function omit(mixed $reqdata, array $names): mixed
+    {
+        if (!is_array($reqdata)) {
             return $reqdata;
         }
-        unset($reqdata['$action']);
+        foreach ($names as $name) {
+            unset($reqdata[$name]);
+        }
         return $reqdata;
     }
 }

package/project/.sdk/tm/py/pkg/utility/make_url.py

@@ -18,6 +18,13 @@ def make_url_util(ctx):
     url = vs.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 = vs.getprop(ctx.point, "orig") if ctx.point is not None else None
+    if isinstance(orig, str) and orig.endswith("/") and not spec.suffix \
+            and not url.endswith("/"):
+        url += "/"
+
     param_items = vs.items(spec.params)
     if param_items is not None:
         for item in param_items:

package/project/.sdk/tm/py/pkg/utility/prepare_headers.py

@@ -8,10 +8,31 @@ def prepare_headers_util(ctx):
     options = ctx.client.options_map()
     headers = vs.getprop(options, "headers")
 
-    if headers is None:
-        return {}
+    out = {}
+    if headers is not None:
+        cloned = vs.clone(headers)
+        if isinstance(cloned, dict):
+            out = cloned
 
-    out = vs.clone(headers)
-    if isinstance(out, dict):
-        return out
-    return {}
+    # 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.
+    hl = vs.getpath(ctx.point, "args.header") if ctx.point is not None else None
+    if isinstance(hl, list):
+        for hd in hl:
+            name = vs.getprop(hd, "name")
+            if not isinstance(name, str) or name == "":
+                continue
+            orig = vs.getprop(hd, "orig")
+            if not isinstance(orig, str) or orig == "":
+                orig = name
+            val = vs.getprop(ctx.reqmatch or {}, name)
+            if val is None:
+                val = vs.getprop(ctx.reqdata or {}, name)
+            if val is not None:
+                wire = orig.lower()
+                for key in [k for k in out if isinstance(k, str) and k.lower() == wire]:
+                    del out[key]
+                out[wire] = vs.stringify(val)
+
+    return out

package/project/.sdk/tm/py/pkg/utility/prepare_query.py

@@ -29,6 +29,14 @@ def prepare_query_util(ctx):
                 name = vs.getprop(pd, "name")
                 if isinstance(name, str):
                     params.append(name)
+        # A header parameter travels in the headers, which prepare_headers
+        # fills.
+        hl = vs.getpath(point, "args.header")
+        if isinstance(hl, list):
+            for hd in hl:
+                name = vs.getprop(hd, "name")
+                if isinstance(name, str):
+                    params.append(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/py/pkg/utility/transform_request.py

@@ -8,9 +8,23 @@ from projectname_sdk.core.helpers import to_map
 # `$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 dict is left untouched.
 def _strip_action(reqdata):
-    if not isinstance(reqdata, dict) or "$action" not in reqdata:
+    return _omit(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.
+def _header_arg_names(point):
+    hl = vs.getpath(point, "args.header") if point is not None else None
+    if not isinstance(hl, list):
+        return []
+    names = [vs.getprop(hd, "name") for hd in hl]
+    return [n for n in names if isinstance(n, str) and n != ""]
+
+
+def _omit(reqdata, names):
+    if not isinstance(reqdata, dict) or not any(n in reqdata for n in names):
         return reqdata
-    return {k: v for k, v in reqdata.items() if k != "$action"}
+    return {k: v for k, v in reqdata.items() if k not in names}
 
 
 def transform_request_util(ctx):
@@ -20,16 +34,18 @@ def transform_request_util(ctx):
     if spec is not None:
         spec.step = "reqform"
 
+    data = _omit(ctx.reqdata, _header_arg_names(point))
+
     transform = to_map(vs.getprop(point, "transform"))
     if transform is None:
-        return _strip_action(ctx.reqdata)
+        return _strip_action(data)
 
     reqform = vs.getprop(transform, "req")
     if reqform is None:
-        return _strip_action(ctx.reqdata)
+        return _strip_action(data)
 
     reqdata = vs.transform({
-        "reqdata": ctx.reqdata,
+        "reqdata": data,
     }, reqform)
 
     return _strip_action(reqdata)

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

@@ -11,6 +11,13 @@ module ProjectNameUtilities
     url = VoxgigStruct.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 ? VoxgigStruct.getprop(ctx.point, "orig") : nil
+    if orig.is_a?(String) && orig.end_with?("/") && spec.suffix.to_s.empty? && !url.end_with?("/")
+      url += "/"
+    end
+
     param_items = VoxgigStruct.items(spec.params)
     if param_items
       param_items.each do |item|

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

@@ -4,8 +4,26 @@ module ProjectNameUtilities
   PrepareHeaders = ->(ctx) {
     options = ctx.client.options_map
     headers = VoxgigStruct.getprop(options, "headers")
-    return {} unless headers
-    out = VoxgigStruct.clone(headers)
-    out.is_a?(Hash) ? out : {}
+    out = headers ? VoxgigStruct.clone(headers) : {}
+    out = {} unless out.is_a?(Hash)
+    # 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.
+    hl = ctx.point ? VoxgigStruct.getpath(ctx.point, "args.header") : nil
+    if hl.is_a?(Array)
+      hl.each do |hd|
+        name = VoxgigStruct.getprop(hd, "name")
+        next unless name.is_a?(String) && !name.empty?
+        orig = VoxgigStruct.getprop(hd, "orig")
+        orig = name unless orig.is_a?(String) && !orig.empty?
+        val = VoxgigStruct.getprop(ctx.reqmatch || {}, name)
+        val = VoxgigStruct.getprop(ctx.reqdata || {}, name) if val.nil?
+        next if val.nil?
+        wire = orig.downcase
+        out.delete_if { |k, _| k.is_a?(String) && k.downcase == wire }
+        out[wire] = VoxgigStruct.stringify(val)
+      end
+    end
+    out
   }
 end

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

@@ -17,6 +17,14 @@ module ProjectNameUtilities
           params << name if name.is_a?(String)
         end
       end
+      # A header parameter travels in the headers, which prepare_headers fills.
+      hl = VoxgigStruct.getpath(point, "args.header")
+      if hl.is_a?(Array)
+        hl.each do |hd|
+          name = VoxgigStruct.getprop(hd, "name")
+          params << name if name.is_a?(String)
+        end
+      end
     end
     # 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/rb/utility/transform_request.rb

@@ -5,18 +5,31 @@ module ProjectNameUtilities
   # `$action` selects the point (see MakePoint); it is never an API field, so
   # the body is a copy without it. The caller's hash is left untouched.
   def self.strip_action(reqdata)
-    return reqdata unless reqdata.is_a?(Hash) && reqdata.key?("$action")
-    reqdata.reject { |k, _| k == "$action" }
+    omit_keys(reqdata, ["$action"])
+  end
+
+  # A header argument travels as a header, which PrepareHeaders sends, so the
+  # body is built from the request data without it.
+  def self.header_arg_names(point)
+    hl = point ? VoxgigStruct.getpath(point, "args.header") : nil
+    return [] unless hl.is_a?(Array)
+    hl.map { |hd| VoxgigStruct.getprop(hd, "name") }.select { |n| n.is_a?(String) && !n.empty? }
+  end
+
+  def self.omit_keys(reqdata, names)
+    return reqdata unless reqdata.is_a?(Hash) && names.any? { |n| reqdata.key?(n) }
+    reqdata.reject { |k, _| names.include?(k) }
   end
 
   TransformRequest = ->(ctx) {
     spec = ctx.spec
     point = ctx.point
     spec.step = "reqform" if spec
+    data = ProjectNameUtilities.omit_keys(ctx.reqdata, ProjectNameUtilities.header_arg_names(point))
     transform = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "transform"))
-    return ProjectNameUtilities.strip_action(ctx.reqdata) unless transform
+    return ProjectNameUtilities.strip_action(data) unless transform
     reqform = VoxgigStruct.getprop(transform, "req")
-    return ProjectNameUtilities.strip_action(ctx.reqdata) unless reqform
-    ProjectNameUtilities.strip_action(VoxgigStruct.transform({ "reqdata" => ctx.reqdata }, reqform))
+    return ProjectNameUtilities.strip_action(data) unless reqform
+    ProjectNameUtilities.strip_action(VoxgigStruct.transform({ "reqdata" => data }, reqform))
   }
 end

package/project/.sdk/tm/rust/utility/make_url.rs

@@ -2,7 +2,7 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::error::ProjectNameError;
-use crate::core::helpers::setp;
+use crate::core::helpers::{getp, setp};
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
@@ -26,6 +26,7 @@ pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
         )
     };
 
+    let suffixless = suffix.is_empty();
     let mut url = vs::join(
         &Value::list(vec![
             Value::str(base),
@@ -37,6 +38,14 @@ pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
         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.
+    if let Value::Str(orig) = getp(&ctx.point.borrow().clone(), "orig") {
+        if orig.ends_with('/') && suffixless && !url.ends_with('/') {
+            url.push('/');
+        }
+    }
+
     let resmatch = Value::empty_map();
 
     if let Value::Map(pm) = &params {

package/project/.sdk/tm/rust/utility/prepare_headers.rs

@@ -1,7 +1,7 @@
 use std::rc::Rc;
 
 use crate::core::context::Context;
-use crate::core::helpers::getp;
+use crate::core::helpers::{getp, setp};
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
@@ -12,12 +12,48 @@ pub fn prepare_headers_util(ctx: &Rc<Context>) -> Value {
     };
 
     let headers = getp(&options, "headers");
-    if headers.is_noval() || headers.is_null() {
-        return Value::empty_map();
-    }
+    let out = if headers.is_noval() || headers.is_null() {
+        Value::empty_map()
+    } else {
+        match vs::clone(&headers) {
+            Value::Map(m) => Value::Map(m),
+            _ => Value::empty_map(),
+        }
+    };
 
-    match vs::clone(&headers) {
-        Value::Map(m) => Value::Map(m),
-        _ => Value::empty_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.
+    let point = ctx.point.borrow().clone();
+    if let Value::List(hl) = getp(&getp(&point, "args"), "header") {
+        let reqmatch = ctx.reqmatch.borrow().clone();
+        let reqdata = ctx.reqdata.borrow().clone();
+        for hd in hl.borrow().iter() {
+            let name = match getp(hd, "name") {
+                Value::Str(n) if !n.is_empty() => n,
+                _ => continue,
+            };
+            let wire = match getp(hd, "orig") {
+                Value::Str(o) if !o.is_empty() => o,
+                _ => name.clone(),
+            };
+            let mut val = getp(&reqmatch, &name);
+            if val.is_noval() || val.is_null() {
+                val = getp(&reqdata, &name);
+            }
+            if !val.is_noval() && !val.is_null() {
+                let key = wire.to_lowercase();
+                if let Value::Map(m) = &out {
+                    let same: Vec<String> =
+                        m.borrow().keys().filter(|k| k.to_lowercase() == key).cloned().collect();
+                    for k in same {
+                        m.borrow_mut().shift_remove(&k);
+                    }
+                }
+                setp(&out, &key, Value::Str(vs::stringify(&val, None, false)));
+            }
+        }
     }
+
+    out
 }

package/project/.sdk/tm/rust/utility/prepare_query.rs

@@ -45,6 +45,21 @@ pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
         false
     };
 
+    // A header parameter travels in the headers, which prepare_headers fills.
+    let aheader = getp(&getp(&point, "args"), "header");
+    let in_header = |key: &str| -> bool {
+        if let Value::List(hl) = &aheader {
+            for hd in hl.borrow().iter() {
+                if let Value::Str(s) = getp(hd, "name") {
+                    if s == key {
+                        return true;
+                    }
+                }
+            }
+        }
+        false
+    };
+
     // A query parameter travels under the name the definition gives it, its
     // orig, which the model may have renamed for the caller.
     let aquery = getp(&getp(&point, "args"), "query");
@@ -69,7 +84,9 @@ pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect();
         for (key, val) in entries {
-            if !val.is_noval() && !val.is_null() && "$action" != key && !contains(&key) && !in_args(&key) {
+            if !val.is_noval() && !val.is_null() && "$action" != key && !contains(&key) && !in_args(&key)
+                && !in_header(&key)
+            {
                 setp(&out, &wire_name(&key), val);
             }
         }

package/project/.sdk/tm/rust/utility/transform_request.rs

@@ -8,8 +8,28 @@ use crate::utility::voxgigstruct::Value;
 // `$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.
 fn strip_action(reqdata: Value) -> Value {
+    omit_keys(reqdata, &["$action".to_string()])
+}
+
+// A header argument travels as a header, which prepare_headers_util sends, so
+// the body is built from the request data without it.
+fn header_arg_names(point: &Value) -> Vec<String> {
+    match getp(&getp(point, "args"), "header") {
+        Value::List(hl) => hl
+            .borrow()
+            .iter()
+            .filter_map(|hd| match getp(hd, "name") {
+                Value::Str(n) if !n.is_empty() => Some(n),
+                _ => None,
+            })
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn omit_keys(reqdata: Value, names: &[String]) -> Value {
     let has = match &reqdata {
-        Value::Map(src) => src.borrow().contains_key("$action"),
+        Value::Map(src) => names.iter().any(|n| src.borrow().contains_key(n)),
         _ => false,
     };
     if !has {
@@ -23,7 +43,7 @@ fn strip_action(reqdata: Value) -> Value {
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect();
         for (k, v) in entries {
-            if "$action" != k {
+            if !names.contains(&k) {
                 setp(&body, &k, v);
             }
         }
@@ -39,19 +59,21 @@ pub fn transform_request_util(ctx: &Rc<Context>) -> Value {
         sp.borrow_mut().step = "reqform".to_string();
     }
 
+    let reqdata = omit_keys(ctx.reqdata.borrow().clone(), &header_arg_names(&point));
+
     let transform = to_map(&getp(&point, "transform"));
     if transform.is_noval() {
-        return strip_action(ctx.reqdata.borrow().clone());
+        return strip_action(reqdata);
     }
 
     let reqform = getp(&transform, "req");
     if reqform.is_noval() || reqform.is_null() {
-        return strip_action(ctx.reqdata.borrow().clone());
+        return strip_action(reqdata);
     }
 
-    let store = jo(vec![("reqdata", ctx.reqdata.borrow().clone())]);
+    let store = jo(vec![("reqdata", reqdata.clone())]);
     strip_action(match vs::transform(&store, &reqform, None) {
-        Ok(reqdata) => reqdata,
-        Err(_) => ctx.reqdata.borrow().clone(),
+        Ok(out) => out,
+        Err(_) => reqdata,
     })
 }

package/project/.sdk/tm/scala/utility/Make.scala

@@ -549,6 +549,15 @@ object MakeUrl {
     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 orig = if (ctx.point == null) null else Struct.getprop(ctx.point, "orig", null)
+    orig match {
+      case o: String if o.endsWith("/") && (spec.suffix == null || spec.suffix.isEmpty) && !url.endsWith("/") =>
+        url = url + "/"
+      case _ =>
+    }
+
     val resmatch = new LinkedHashMap[String, Object]()
 
     val pit = Struct.items(spec.params).iterator()