@voxgig/sdkgen 4.31.0 → 4.32.0

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

@@ -1003,13 +1003,24 @@ defmodule ProjectName.Utility do
         {"", Context.make_error(ctx, "url_no_result", "Expected context result property to be defined.")}
 
       true ->
-        url0 =
+        joined =
           S.join(
             S.jt([S.getprop(spec, "base"), S.getprop(spec, "prefix"), S.getprop(spec, "path"), S.getprop(spec, "suffix")]),
             "/",
             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.
+        orig = S.getprop(S.getprop(ctx, "point"), "orig")
+        suffix = S.getprop(spec, "suffix")
+
+        url0 =
+          if is_binary(orig) and String.ends_with?(orig, "/") and (suffix == nil or suffix == "") and
+               not String.ends_with?(joined, "/"),
+             do: joined <> "/",
+             else: joined
+
         resmatch = S.jm([])
 
         url1 =
@@ -1125,12 +1136,44 @@ defmodule ProjectName.Utility do
     options = opts_map(S.getprop(ctx, "client"))
     headers = S.getprop(options, "headers")
 
-    if headers == nil do
-      S.jm([])
-    else
-      out = S.clone(headers)
-      if S.ismap(out), do: out, else: S.jm([])
+    out =
+      if headers == nil do
+        S.jm([])
+      else
+        cloned = S.clone(headers)
+        if S.ismap(cloned), do: cloned, else: S.jm([])
+      end
+
+    # 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.
+    point = S.getprop(ctx, "point")
+    aheader = if point != nil, do: S.getpath(point, "args.header"), else: nil
+
+    if S.islist(aheader) and S.size(aheader) > 0 do
+      Enum.each(0..(S.size(aheader) - 1), fn i ->
+        hd = S.getelem(aheader, i)
+        name = S.getprop(hd, "name")
+
+        if is_binary(name) and name != "" do
+          orig = S.getprop(hd, "orig")
+          wire = if is_binary(orig) and orig != "", do: orig, else: name
+          val = S.getprop(S.getprop(ctx, "reqmatch"), name)
+          val = if val == nil, do: S.getprop(S.getprop(ctx, "reqdata"), name), else: val
+          if val != nil do
+            key = String.downcase(wire)
+
+            Enum.each(H.entries(out), fn {k, _} ->
+              if is_binary(k) and String.downcase(k) == key, do: S.delprop(out, k)
+            end)
+
+            S.setprop(out, key, S.stringify(val))
+          end
+        end
+      end)
     end
+
+    out
   end
 
   def prepare_body_impl(ctx) do
@@ -1187,6 +1230,19 @@ defmodule ProjectName.Utility do
     S.join(parts, "/", true)
   end
 
+  # The names in one of a point's lists of argument definitions.
+  defp arg_names(nil, _path), do: []
+
+  defp arg_names(point, path) do
+    defs = S.getpath(point, path)
+
+    if S.islist(defs) and S.size(defs) > 0 do
+      Enum.map(0..(S.size(defs) - 1), fn i -> S.getprop(S.getelem(defs, i), "name") end)
+    else
+      []
+    end
+  end
+
   def prepare_query_impl(ctx) do
     point = S.getprop(ctx, "point")
     reqmatch = H.or_(S.getprop(ctx, "reqmatch"), S.jm([]))
@@ -1208,18 +1264,8 @@ defmodule ProjectName.Utility do
 
     # A path parameter travels in the path. The generated config lists them
     # as args.params, which prepare_params reads; params is the older list.
-    aparams = if point != nil, do: S.getpath(point, "args.params"), else: nil
-
-    arg_strs =
-      if S.islist(aparams) and S.size(aparams) > 0 do
-        Enum.map(0..(S.size(aparams) - 1), fn i ->
-          S.getprop(S.getelem(aparams, i), "name")
-        end)
-      else
-        []
-      end
-
-    param_strs = param_strs ++ arg_strs
+    # A header parameter travels in the headers, which prepare_headers fills.
+    param_strs = param_strs ++ arg_names(point, "args.params") ++ arg_names(point, "args.header")
 
     # A query parameter travels under the name the definition gives it, its
     # orig, which the model may have renamed for the caller.
@@ -1484,12 +1530,27 @@ defmodule ProjectName.Utility do
   # `$action` selects the point (see make_point_impl); it is never an API
   # field, so the body is a copy without it. The caller's map is left
   # untouched.
-  defp strip_action(reqdata) do
-    if S.ismap(reqdata) and S.haskey(reqdata, "$action") do
+  defp strip_action(reqdata), do: omit_keys(reqdata, ["$action"])
+
+  # A header argument travels as a header, which prepare_headers_impl sends, so
+  # the body is built from the request data without it.
+  defp header_arg_names(point) do
+    aheader = if point != nil, do: S.getpath(point, "args.header"), else: nil
+
+    if S.islist(aheader) and S.size(aheader) > 0 do
+      Enum.map(0..(S.size(aheader) - 1), &S.getprop(S.getelem(aheader, &1), "name"))
+      |> Enum.filter(&(is_binary(&1) and &1 != ""))
+    else
+      []
+    end
+  end
+
+  defp omit_keys(reqdata, names) do
+    if S.ismap(reqdata) and Enum.any?(names, &S.haskey(reqdata, &1)) do
       body = S.jm([])
 
       Enum.each(H.entries(reqdata), fn {key, val} ->
-        if key != "$action", do: S.setprop(body, key, val)
+        if key not in names, do: S.setprop(body, key, val)
       end)
 
       body
@@ -1503,18 +1564,19 @@ defmodule ProjectName.Utility do
     point = S.getprop(ctx, "point")
     if spec != nil, do: S.setprop(spec, "step", "reqform")
 
+    data = omit_keys(S.getprop(ctx, "reqdata"), header_arg_names(point))
     transform = H.to_map(S.getprop(point, "transform"))
 
     reqdata =
       if transform == nil do
-        S.getprop(ctx, "reqdata")
+        data
       else
         reqform = S.getprop(transform, "req")
 
         if reqform == nil do
-          S.getprop(ctx, "reqdata")
+          data
         else
-          S.transform(S.jm(["reqdata", S.getprop(ctx, "reqdata")]), reqform)
+          S.transform(S.jm(["reqdata", data]), reqform)
         end
       end
 

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

@@ -2,6 +2,7 @@ package utility
 
 import (
 	"regexp"
+	"strings"
 
 	vs "github.com/voxgig/struct"
 
@@ -24,6 +25,13 @@ func makeUrlUtil(ctx *core.Context) (string, error) {
 	url := vs.Join([]any{spec.Base, spec.Prefix, spec.Path, spec.Suffix}, "/", true)
 	resmatch := map[string]any{}
 
+	// 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 orig, _ := vs.GetProp(ctx.Point, "orig").(string); strings.HasSuffix(orig, "/") &&
+		spec.Suffix == "" && !strings.HasSuffix(url, "/") {
+		url += "/"
+	}
+
 	params := spec.Params
 	for _, item := range vs.Items(params) {
 		key, _ := item[0].(string)

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

@@ -1,6 +1,8 @@
 package utility
 
 import (
+	"strings"
+
 	vs "github.com/voxgig/struct"
 
 	"GOMODULE/core"
@@ -9,14 +11,41 @@ import (
 func prepareHeadersUtil(ctx *core.Context) map[string]any {
 	options := ctx.Client.OptionsMap()
 
-	headers := vs.GetProp(options, "headers")
-	if headers == nil {
-		return map[string]any{}
+	out := map[string]any{}
+	if headers := vs.GetProp(options, "headers"); headers != nil {
+		if om, ok := vs.Clone(headers).(map[string]any); ok {
+			out = om
+		}
 	}
 
-	out := vs.Clone(headers)
-	if om, ok := out.(map[string]any); ok {
-		return om
+	// 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 hl, ok := vs.GetPath(ctx.Point, []any{"args", "header"}).([]any); ok {
+		for _, hd := range hl {
+			name, _ := vs.GetProp(hd, "name").(string)
+			orig, _ := vs.GetProp(hd, "orig").(string)
+			if "" == name {
+				continue
+			}
+			if "" == orig {
+				orig = name
+			}
+			val := vs.GetProp(ctx.Reqmatch, name)
+			if val == nil {
+				val = vs.GetProp(ctx.Reqdata, name)
+			}
+			if val != nil {
+				wire := strings.ToLower(orig)
+				for key := range out {
+					if strings.ToLower(key) == wire {
+						delete(out, key)
+					}
+				}
+				out[wire] = vs.Stringify(val)
+			}
+		}
 	}
-	return map[string]any{}
+
+	return out
 }

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

@@ -37,6 +37,17 @@ func prepareQueryUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
+	// A header parameter travels in the headers, which prepareHeaders fills.
+	if point != nil {
+		if hl, ok := vs.GetPath(point, []any{"args", "header"}).([]any); ok {
+			for _, hd := range hl {
+				if name, ok := vs.GetProp(hd, "name").(string); ok {
+					params = append(params, name)
+				}
+			}
+		}
+	}
+
 	// A query parameter travels under the name the definition gives it, its
 	// orig, which the model may have renamed for the caller.
 	wire := map[string]string{}

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

@@ -14,18 +14,20 @@ func transformRequestUtil(ctx *core.Context) any {
 		spec.Step = "reqform"
 	}
 
+	data := omitKeys(ctx.Reqdata, headerArgNames(point))
+
 	transform := core.ToMapAny(vs.GetProp(point, "transform"))
 	if transform == nil {
-		return stripAction(ctx.Reqdata)
+		return stripAction(data)
 	}
 
 	reqform := vs.GetProp(transform, "req")
 	if reqform == nil {
-		return stripAction(ctx.Reqdata)
+		return stripAction(data)
 	}
 
 	reqdata, terr := vs.Transform(map[string]any{
-		"reqdata": ctx.Reqdata,
+		"reqdata": data,
 	}, reqform)
 
 	if terr != nil {
@@ -42,16 +44,40 @@ func transformRequestUtil(ctx *core.Context) any {
 // `$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.
 func stripAction(reqdata any) any {
+	return omitKeys(reqdata, []string{"$action"})
+}
+
+// A header argument travels as a header, which prepareHeadersUtil sends, so
+// the body is built from the request data without it.
+func headerArgNames(point any) []string {
+	names := []string{}
+	if hl, ok := vs.GetPath(point, []any{"args", "header"}).([]any); ok {
+		for _, hd := range hl {
+			if name, _ := vs.GetProp(hd, "name").(string); "" != name {
+				names = append(names, name)
+			}
+		}
+	}
+	return names
+}
+
+func omitKeys(reqdata any, names []string) any {
 	src, ok := reqdata.(map[string]any)
 	if !ok {
 		return reqdata
 	}
-	if _, has := src["$action"]; !has {
+	skip := map[string]bool{}
+	for _, name := range names {
+		if _, has := src[name]; has {
+			skip[name] = true
+		}
+	}
+	if 0 == len(skip) {
 		return reqdata
 	}
 	body := make(map[string]any, len(src))
 	for k, v := range src {
-		if k != "$action" {
+		if !skip[k] {
 			body[k] = v
 		}
 	}

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

@@ -34,6 +34,14 @@ final class MakeUrl {
     joinParts.add(spec.suffix);
     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.
+    Object orig = ctx.point == null ? null : Struct.getprop(ctx.point, "orig", null);
+    if (orig instanceof String && ((String) orig).endsWith("/") &&
+        (spec.suffix == null || spec.suffix.isEmpty()) && !url.endsWith("/")) {
+      url = url + "/";
+    }
+
     Map<String, Object> resmatch = new LinkedHashMap<>();
 
     Map<String, Object> params = spec.params;

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

@@ -1,12 +1,15 @@
 package JAVAPACKAGE.utility;
 
 import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.Helpers;
 import JAVAPACKAGE.utility.struct.Struct;
 
+@SuppressWarnings({"unchecked"})
 final class PrepareHeaders {
 
   private PrepareHeaders() {}
@@ -15,14 +18,35 @@ final class PrepareHeaders {
     Map<String, Object> options = ctx.client.optionsMap();
 
     Object headers = Struct.getprop(options, "headers");
-    if (headers == null) {
-      return new LinkedHashMap<>();
+    Map<String, Object> out = headers == null ? null : Helpers.toMapAny(Struct.clone(headers));
+    if (out == null) {
+      out = new LinkedHashMap<>();
     }
 
-    Map<String, Object> out = Helpers.toMapAny(Struct.clone(headers));
-    if (out != null) {
-      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.
+    Object hl = ctx.point == null ? null : Struct.getpath(ctx.point, List.of("args", "header"));
+    if (hl instanceof List) {
+      for (Object hd : (List<Object>) hl) {
+        Object name = Struct.getprop(hd, "name");
+        if (!(name instanceof String) || ((String) name).isEmpty()) {
+          continue;
+        }
+        Object orig = Struct.getprop(hd, "orig");
+        String wire = orig instanceof String && !((String) orig).isEmpty() ? (String) orig : (String) name;
+        Object val = ctx.reqmatch == null ? null : Struct.getprop(ctx.reqmatch, name, null);
+        if (val == null && ctx.reqdata != null) {
+          val = Struct.getprop(ctx.reqdata, name, null);
+        }
+        if (val != null) {
+          String key = wire.toLowerCase(Locale.ROOT);
+          out.keySet().removeIf(k -> k != null && k.toLowerCase(Locale.ROOT).equals(key));
+          out.put(key, Struct.stringify(val));
+        }
+      }
     }
-    return new LinkedHashMap<>();
+
+    return out;
   }
 }

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

@@ -37,6 +37,16 @@ final class PrepareQuery {
           }
         }
       }
+      // A header parameter travels in the headers, which prepareHeaders fills.
+      Object hl = Struct.getpath(point, List.of("args", "header"));
+      if (hl instanceof List) {
+        for (Object hd : (List<Object>) hl) {
+          Object name = Struct.getprop(hd, "name");
+          if (name instanceof String) {
+            params.add(name);
+          }
+        }
+      }
     }
 
     // A query parameter travels under the name the definition gives it, its

package/project/.sdk/tm/java/utility/TransformRequest.java

@@ -1,6 +1,8 @@
 package JAVAPACKAGE.utility;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 
 import JAVAPACKAGE.core.Context;
@@ -16,19 +18,21 @@ final class TransformRequest {
       ctx.spec.step = "reqform";
     }
 
+    Object reqdata = omit(ctx.reqdata, headerArgNames(ctx));
+
     Map<String, Object> transform =
         Helpers.toMapAny(Struct.getprop(ctx.point, "transform"));
     if (transform == null) {
-      return stripAction(ctx.reqdata);
+      return stripAction(reqdata);
     }
 
     Object reqform = Struct.getprop(transform, "req", null);
     if (reqform == null) {
-      return stripAction(ctx.reqdata);
+      return stripAction(reqdata);
     }
 
     Map<String, Object> data = new LinkedHashMap<>();
-    data.put("reqdata", ctx.reqdata);
+    data.put("reqdata", reqdata);
 
     return stripAction(Struct.transform(data, reqform));
   }
@@ -36,12 +40,33 @@ final class 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.
   private static Object stripAction(Object reqdata) {
-    if (!(reqdata instanceof Map) || !((Map<?, ?>) reqdata).containsKey("$action")) {
+    return omit(reqdata, List.of("$action"));
+  }
+
+  // A header argument travels as a header, which PrepareHeaders sends, so the
+  // body is built from the request data without it.
+  @SuppressWarnings("unchecked")
+  private static List<String> headerArgNames(Context ctx) {
+    List<String> names = new ArrayList<>();
+    Object hl = ctx.point == null ? null : Struct.getpath(ctx.point, List.of("args", "header"));
+    if (hl instanceof List) {
+      for (Object hd : (List<Object>) hl) {
+        Object name = Struct.getprop(hd, "name", null);
+        if (name instanceof String && !((String) name).isEmpty()) {
+          names.add((String) name);
+        }
+      }
+    }
+    return names;
+  }
+
+  private static Object omit(Object reqdata, List<String> names) {
+    if (!(reqdata instanceof Map) || names.stream().noneMatch(((Map<?, ?>) reqdata)::containsKey)) {
       return reqdata;
     }
     Map<String, Object> body = new LinkedHashMap<>();
     for (Map.Entry<?, ?> e : ((Map<?, ?>) reqdata).entrySet()) {
-      if (!"$action".equals(e.getKey())) {
+      if (!names.contains(e.getKey())) {
         body.put(String.valueOf(e.getKey()), e.getValue());
       }
     }

package/project/.sdk/tm/js/src/utility/MakeUrlUtility.js

@@ -19,6 +19,13 @@ function makeUrl(ctx) {
   }
 
   let url = join([spec.base, spec.prefix, spec.path, spec.suffix], '/', 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.
+  const orig = ctx.point && ctx.point.orig
+  if ('string' === typeof orig && orig.endsWith('/') && !spec.suffix && !url.endsWith('/')) {
+    url += '/'
+  }
   let resmatch = {}
 
   const params = spec.params

package/project/.sdk/tm/js/src/utility/PrepareHeadersUtility.js

@@ -3,6 +3,7 @@ function prepareHeaders(ctx) {
   const struct = ctx.utility.struct
   const clone = struct.clone
   const getprop = struct.getprop
+  const stringify = struct.stringify
 
   const client = ctx.client
 
@@ -10,6 +11,23 @@ function prepareHeaders(ctx) {
 
   let out = clone(getprop(options, 'headers', {}))
 
+  // 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.
+  const hargs = (ctx.point && ctx.point.args && ctx.point.args.header) || []
+  for (const h of hargs) {
+    if (null == h || 'string' !== typeof h.name || '' === h.name) continue
+    let val = getprop(ctx.reqmatch, h.name)
+    if (null == val) val = getprop(ctx.reqdata, h.name)
+    if (null != val) {
+      const wire = String(h.orig || h.name).toLowerCase()
+      for (const key of Object.keys(out)) {
+        if (wire === key.toLowerCase()) delete out[key]
+      }
+      out[wire] = stringify(val)
+    }
+  }
+
   return out
 }
 

package/project/.sdk/tm/js/src/utility/PrepareQueryUtility.js

@@ -13,8 +13,10 @@ function prepareQuery(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.
   const inpath = params.concat(
-    ((point.args && point.args.params) || []).map((p) => p && p.name))
+    ((point.args && point.args.params) || []).map((p) => p && p.name),
+    ((point.args && point.args.header) || []).map((h) => h && h.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/js/src/utility/TransformRequestUtility.js

@@ -13,7 +13,7 @@ function transformRequest(ctx) {
   try {
     const reqform = point.transform.req
     const reqdata = isfunc(reqform) ? reqform(ctx) : transform({
-      reqdata: ctx.reqdata
+      reqdata: omit(ctx.reqdata, headerArgNames(ctx))
     }, reqform)
 
     return stripAction(reqdata)
@@ -42,17 +42,31 @@ function transformRequest(ctx) {
 // as StructUtility's condenseSet, for the same reason.
 
 function stripAction(reqdata) {
+  return omit(reqdata, ['$action'])
+}
+
+
+// A header argument travels as a header, which prepareHeaders sends, so the
+// body is built from the request data without it.
+function headerArgNames(ctx) {
+  const hargs = (ctx.point && ctx.point.args && ctx.point.args.header) || []
+  return hargs.map((h) => h && h.name)
+    .filter((name) => 'string' === typeof name && '' !== name)
+}
+
+
+function omit(reqdata, names) {
   if (null == reqdata || 'object' !== typeof reqdata || Array.isArray(reqdata)) {
     return reqdata
   }
 
-  if (!Object.prototype.hasOwnProperty.call(reqdata, '$action')) {
+  if (!names.some((name) => Object.prototype.hasOwnProperty.call(reqdata, name))) {
     return reqdata
   }
 
   const body = {}
   for (const key of Object.keys(reqdata)) {
-    if ('$action' === key) {
+    if (names.includes(key)) {
       continue
     }
     if ('__proto__' === key) {