@voxgig/sdkgen 4.34.0 → 4.34.1

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

@@ -14,6 +14,9 @@ final class MakeUrl {
 
   private MakeUrl() {}
 
+  private static final java.util.regex.Pattern PLACEHOLDER =
+      java.util.regex.Pattern.compile("\\{[^{}/]+\\}");
+
   static String makeUrl(Context ctx) {
     Spec spec = ctx.spec;
     Result result = ctx.result;
@@ -44,6 +47,9 @@ final class MakeUrl {
 
     Map<String, Object> resmatch = new LinkedHashMap<>();
 
+    // Sent with the request, never recorded as the entity's match.
+    List<String> authquery = spec.authquery == null ? List.of() : spec.authquery;
+
     Map<String, Object> params = spec.params;
     for (List<Object> item : Struct.items(params)) {
       String key = item.get(0) instanceof String ? (String) item.get(0) : "";
@@ -56,6 +62,20 @@ final class MakeUrl {
       }
     }
 
+    // A placeholder left in the route would send the request to the wrong route.
+    // The base's own placeholders are server variables, resolved with the options.
+    String base = null == spec.base ? "" : spec.base.replaceAll("/+$", "");
+    String route = url.startsWith(base) ? url.substring(base.length()) : url;
+    List<String> unfilled = new ArrayList<>();
+    java.util.regex.Matcher found = PLACEHOLDER.matcher(route);
+    while (found.find()) {
+      unfilled.add(found.group());
+    }
+    if (!unfilled.isEmpty()) {
+      throw ctx.makeError("url_param_missing",
+          "URL path has no value for " + String.join(", ", unfilled) + ".");
+    }
+
     // Append query string from spec.query.
     String qsep = "?";
     for (List<Object> item : Struct.items(spec.query)) {
@@ -64,7 +84,9 @@ final class MakeUrl {
       if (val != null) {
         url += qsep + Struct.escurl(key) + "=" + Struct.escurl(Struct.stringify(val));
         qsep = "&";
-        resmatch.put(key, val);
+        if (!authquery.contains(key)) {
+          resmatch.put(key, val);
+        }
       }
     }
 

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

@@ -0,0 +1,117 @@
+package JAVAPACKAGE.utility;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import JAVAPACKAGE.utility.struct.Struct;
+
+// The media types a point declares: `response` (the model's `rs`) for the
+// Accept header, and `body` (the model's `rb`) for the request body.
+final class Media {
+
+  // The data key holding a raw request body. Like `$action`, it can never be
+  // a declared argument name.
+  static final String RAW_BODY = "$body";
+
+  private Media() {}
+
+  static boolean isJsonMedia(Object media) {
+    String m = (media instanceof String ? (String) media : "").split(";", 2)[0]
+        .trim().toLowerCase(Locale.ROOT);
+    return "application/json".equals(m) || "text/json".equals(m) || m.endsWith("+json");
+  }
+
+  // The declared JSON type alone, else every declared type in the model's
+  // order; null when no success response declares a body.
+  static String acceptOf(Object point) {
+    Object res = Struct.getprop(point, "response");
+    Object media = Struct.getprop(res, "media");
+    if (!(media instanceof String) || ((String) media).isEmpty()) {
+      return null;
+    }
+    if ("json".equals(Struct.getprop(res, "kind"))) {
+      return (String) media;
+    }
+    List<String> types = new ArrayList<>();
+    types.add((String) media);
+    Object alts = Struct.getprop(res, "alternatives");
+    if (alts instanceof List) {
+      for (Object alt : (List<?>) alts) {
+        Object m = Struct.getprop(alt, "media");
+        if (m instanceof String && !((String) m).isEmpty()) {
+          types.add((String) m);
+        }
+      }
+    }
+    return String.join(", ", types);
+  }
+
+  static boolean isRawRequest(Object point) {
+    return "raw".equals(Struct.getprop(Struct.getprop(point, "body"), "kind"));
+  }
+
+  static boolean isJsonRequest(Object point) {
+    return "json".equals(Struct.getprop(Struct.getprop(point, "body"), "kind"));
+  }
+
+  // Bytes or a stream go as given. A map or a list is JSON, and so is a scalar
+  // on a point that declares a JSON body.
+  static Object requestBody(Object point, Object body) {
+    if (body instanceof byte[] || body instanceof InputStream) {
+      return body;
+    }
+    if (Struct.isnode(body) || isJsonRequest(point)) {
+      return Struct.jsonify(body);
+    }
+    return body;
+  }
+
+  private static boolean hasHeader(Map<String, Object> headers, String name) {
+    return headers.keySet().stream()
+        .anyMatch(k -> k != null && k.toLowerCase(Locale.ROOT).equals(name));
+  }
+
+  // A caller's accept wins. A declared request type replaces each JSON
+  // content-type, the SDK default, and leaves any other the caller set.
+  static Map<String, Object> headers(Object point, Map<String, Object> headers) {
+    String accept = acceptOf(point);
+    if (accept != null && !hasHeader(headers, "accept")) {
+      headers.put("accept", accept);
+    }
+
+    Object body = Struct.getprop(point, "body");
+    Object kind = Struct.getprop(body, "kind");
+    Object media = Struct.getprop(body, "media");
+    if (("raw".equals(kind) || "json".equals(kind)) &&
+        media instanceof String && !((String) media).isEmpty()) {
+      headers.entrySet().removeIf(e -> e.getKey() != null &&
+          "content-type".equals(e.getKey().toLowerCase(Locale.ROOT)) && isJsonMedia(e.getValue()));
+      if (!hasHeader(headers, "content-type")) {
+        headers.put("content-type", media);
+      }
+    }
+
+    return headers;
+  }
+
+  // Bytes, an InputStream or a String, sent as they are. An InputStream can be
+  // read once, so it is read here, before the first attempt, and a retry sends
+  // the same bytes again.
+  static Object rawBody(Map<String, Object> reqdata) {
+    Object body = reqdata == null ? null : reqdata.get(RAW_BODY);
+    if (body instanceof InputStream) {
+      try {
+        return ((InputStream) body).readAllBytes();
+      }
+      catch (IOException e) {
+        throw new UncheckedIOException(e);
+      }
+    }
+    return body;
+  }
+}

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

@@ -1,10 +1,11 @@
 package JAVAPACKAGE.utility;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.Helpers;
-import JAVAPACKAGE.core.Spec;
 import JAVAPACKAGE.utility.struct.Struct;
 
 final class Param {
@@ -12,13 +13,6 @@ final class Param {
   private Param() {}
 
   static Object param(Context ctx, Object paramdef) {
-    Map<String, Object> point = ctx.point;
-    Spec spec = ctx.spec;
-    Map<String, Object> match = ctx.match;
-    Map<String, Object> reqmatch = ctx.reqmatch;
-    Map<String, Object> data = ctx.data;
-    Map<String, Object> reqdata = ctx.reqdata;
-
     int pt = Struct.typify(paramdef);
 
     String key;
@@ -30,45 +24,90 @@ final class Param {
       key = k instanceof String ? (String) k : "";
     }
 
-    String akey = "";
+    String akey = alias(ctx.point, key);
+    if (ctx.spec != null && !"".equals(akey)
+        && Struct.getprop(ctx.reqmatch, key, null) == null
+        && Struct.getprop(ctx.match, key, null) == null) {
+      ctx.spec.alias.put(akey, key);
+    }
+
+    return paramValue(ctx, ctx.point, key);
+  }
+
+  // The name a point gives a parameter in the call, if it renames it.
+  private static String alias(Map<String, Object> point, String key) {
     if (point != null) {
       Map<String, Object> alias = Helpers.toMapAny(Struct.getprop(point, "alias"));
       if (alias != null) {
         Object ak = Struct.getprop(alias, key);
         if (ak instanceof String) {
-          akey = (String) ak;
+          return (String) ak;
         }
       }
     }
+    return "";
+  }
 
-    Object val = Struct.getprop(reqmatch, key, null);
+  // The value the call or its entity gives a point's parameter, under its
+  // name or the point's alias for it.
+  static Object paramValue(Context ctx, Map<String, Object> point, String key) {
+    String akey = alias(point, key);
+
+    Object val = Struct.getprop(ctx.reqmatch, key, null);
 
     if (val == null) {
-      val = Struct.getprop(match, key, null);
+      val = Struct.getprop(ctx.match, key, null);
     }
 
     if (val == null && !"".equals(akey)) {
-      if (spec != null) {
-        spec.alias.put(akey, key);
-      }
-      val = Struct.getprop(reqmatch, akey, null);
+      val = Struct.getprop(ctx.reqmatch, akey, null);
     }
 
     if (val == null) {
-      val = Struct.getprop(reqdata, key, null);
+      val = Struct.getprop(ctx.reqdata, key, null);
     }
 
     if (val == null) {
-      val = Struct.getprop(data, key, null);
+      val = Struct.getprop(ctx.data, key, null);
     }
 
     if (val == null && !"".equals(akey)) {
-      val = Struct.getprop(reqdata, akey, null);
+      val = Struct.getprop(ctx.reqdata, akey, null);
       if (val == null) {
-        val = Struct.getprop(data, akey, null);
+        val = Struct.getprop(ctx.data, akey, null);
       }
     }
 
     return val;
   }
+
+  // One argument a point declares, with the name it travels under and the
+  // value the call passes for it.
+  record CallArg(String name, String wire, Object val) {}
+
+  // The arguments a point declares in one location, query or header, each
+  // with the name it travels under and the value this call passes in its
+  // match or else its data. Unlike a path parameter, the entity's stored
+  // match and data never supply one.
+  @SuppressWarnings("unchecked")
+  static List<CallArg> callArgs(Context ctx, String kind) {
+    List<CallArg> out = new ArrayList<>();
+    Object defs = ctx.point == null ? null : Struct.getpath(ctx.point, List.of("args", kind));
+    if (defs instanceof List) {
+      for (Object ad : (List<Object>) defs) {
+        Object name = Struct.getprop(ad, "name", null);
+        if (!(name instanceof String) || ((String) name).isEmpty()) {
+          continue;
+        }
+        Object orig = Struct.getprop(ad, "orig", null);
+        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);
+        }
+        out.add(new CallArg((String) name, wire, val));
+      }
+    }
+    return out;
+  }
 }

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

@@ -8,6 +8,9 @@ final class PrepareBody {
 
   static Object prepareBody(Context ctx) {
     if ("data".equals(ctx.op.input)) {
+      if (Media.isRawRequest(ctx.point)) {
+        return Media.rawBody(ctx.reqdata);
+      }
       return ctx.utility.transformRequest.apply(ctx);
     }
 

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

@@ -1,5 +1,6 @@
 package JAVAPACKAGE.utility;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
@@ -9,7 +10,6 @@ import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.Helpers;
 import JAVAPACKAGE.utility.struct.Struct;
 
-@SuppressWarnings({"unchecked"})
 final class PrepareHeaders {
 
   private PrepareHeaders() {}
@@ -22,31 +22,89 @@ final class PrepareHeaders {
     if (out == null) {
       out = new LinkedHashMap<>();
     }
+    out = Media.headers(ctx.point, 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()) {
+    // A header argument replaces a default of the same name, whatever its case.
+    for (Param.CallArg arg : Param.callArgs(ctx, "header")) {
+      if (arg.val() != null) {
+        String key = arg.wire().toLowerCase(Locale.ROOT);
+        out.keySet().removeIf(k -> k != null && k.toLowerCase(Locale.ROOT).equals(key));
+        out.put(key, Struct.stringify(arg.val()));
+      }
+    }
+
+    // A cookie argument travels in the cookie header, form serialized and
+    // percent-encoded, replacing a cookie of the same name among those the
+    // caller's headers already send.
+    List<Param.CallArg> sent = new ArrayList<>();
+    for (Param.CallArg arg : Param.callArgs(ctx, "cookie")) {
+      if (arg.val() != null) {
+        sent.add(arg);
+      }
+    }
+    if (!sent.isEmpty()) {
+      List<String> names = new ArrayList<>();
+      for (Param.CallArg arg : sent) {
+        if (arg.val() instanceof Map<?, ?> map) {
+          for (String key : Struct.keysof(map)) {
+            names.add(Struct.escurl(key));
+          }
+        } else {
+          names.add(arg.wire());
+        }
+      }
+      List<String> kept = new ArrayList<>();
+      for (String k : new ArrayList<>(out.keySet())) {
+        if (k == null || !"cookie".equals(k.toLowerCase(Locale.ROOT))) {
           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);
+        Object given = out.remove(k);
+        if (given instanceof String) {
+          kept.addAll(cookieKeep((String) given, names));
         }
-        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));
+      }
+      for (Param.CallArg arg : sent) {
+        String pair = cookiePair(arg.wire(), arg.val());
+        if (!pair.isEmpty()) {
+          kept.add(pair);
         }
       }
+      if (!kept.isEmpty()) {
+        out.put("cookie", String.join("; ", kept));
+      }
     }
 
     return out;
   }
+
+  // The form style of a cookie parameter: a list repeats the name, a map sends
+  // its own keys, and every value is percent-encoded.
+  private static String cookiePair(String wire, Object val) {
+    List<String> pairs = new ArrayList<>();
+    if (val instanceof List<?> items) {
+      for (Object item : items) {
+        pairs.add(wire + "=" + Struct.escurl(Struct.stringify(item)));
+      }
+    } else if (val instanceof Map<?, ?> map) {
+      for (String key : Struct.keysof(map)) {
+        pairs.add(Struct.escurl(key) + "=" + Struct.escurl(Struct.stringify(map.get(key))));
+      }
+    } else {
+      pairs.add(wire + "=" + Struct.escurl(Struct.stringify(val)));
+    }
+    return String.join("; ", pairs);
+  }
+
+  // The caller's cookie pieces with the named cookies removed: a cookie is one
+  // ;-delimited piece, whatever its value holds.
+  static List<String> cookieKeep(String header, List<String> names) {
+    List<String> kept = new ArrayList<>();
+    for (String piece : header.split(";")) {
+      String cookie = piece.trim();
+      if (!cookie.isEmpty() && !names.contains(cookie.split("=", 2)[0].trim())) {
+        kept.add(cookie);
+      }
+    }
+    return kept;
+  }
 }

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

@@ -1,5 +1,6 @@
 package JAVAPACKAGE.utility;
 
+import java.util.Locale;
 import java.util.Map;
 
 import JAVAPACKAGE.core.Context;
@@ -25,7 +26,7 @@ final class PrepareMethod {
     // Only fall back to the op-name convention when the point has no method.
     Object pm = Struct.getprop(ctx.point, "method");
     if (pm instanceof String && !((String) pm).isEmpty()) {
-      return ((String) pm).toUpperCase();
+      return ((String) pm).toUpperCase(Locale.ROOT);
     }
 
     // No default: an op name outside the convention resolves to NO method,

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

@@ -37,12 +37,29 @@ final class PrepareQuery {
           }
         }
       }
-      // A header parameter travels in the headers, which prepareHeaders fills.
+      // A header or cookie parameter travels in the headers, which prepareHeaders
+      // fills, unless a query parameter shares its name: then both are sent.
+      List<Object> declared = new ArrayList<>();
+      Object dl = Struct.getpath(point, List.of("args", "query"));
+      if (dl instanceof List) {
+        for (Object qd : (List<Object>) dl) {
+          declared.add(Struct.getprop(qd, "name"));
+        }
+      }
       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) {
+          if (name instanceof String && !declared.contains(name)) {
+            params.add(name);
+          }
+        }
+      }
+      Object cl = Struct.getpath(point, List.of("args", "cookie"));
+      if (cl instanceof List) {
+        for (Object cd : (List<Object>) cl) {
+          Object name = Struct.getprop(cd, "name");
+          if (name instanceof String && !declared.contains(name)) {
             params.add(name);
           }
         }
@@ -74,6 +91,13 @@ final class PrepareQuery {
       }
     }
 
+    // A create or update passes its query arguments in its data.
+    for (Param.CallArg arg : Param.callArgs(ctx, "query")) {
+      if (arg.val() != null && !containsStr(params, arg.name())) {
+        out.put(arg.wire(), arg.val());
+      }
+    }
+
     return out;
   }
 

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

@@ -16,6 +16,11 @@ final class ResultBody {
       if (response != null && response.jsonFunc != null && response.body != null) {
         result.body = response.jsonFunc.get();
       }
+      if (response != null && response.unreadable) {
+        Object sent = ctx.spec == null ? null : ctx.spec.headers;
+        result.err = Response.unreadableBody(ctx, result.status, result.headers, response.body,
+            sent, result.err);
+      }
     }
 
     return result;

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

@@ -18,7 +18,7 @@ final class TransformRequest {
       ctx.spec.step = "reqform";
     }
 
-    Object reqdata = omit(ctx.reqdata, headerArgNames(ctx));
+    Object reqdata = omit(ctx.reqdata, routedArgNames(ctx));
 
     Map<String, Object> transform =
         Helpers.toMapAny(Struct.getprop(ctx.point, "transform"));
@@ -43,23 +43,36 @@ final class TransformRequest {
     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) {
+  // A header, cookie or query argument travels where PrepareHeaders or
+  // PrepareQuery sends it, so the body is built from the request data without
+  // it, unless the entity declares it as a field too.
+  private static List<String> routedArgNames(Context ctx) {
     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);
+    for (String kind : List.of("header", "cookie", "query")) {
+      for (Param.CallArg arg : Param.callArgs(ctx, kind)) {
+        if (!fieldArg(ctx, arg.name())) {
+          names.add(arg.name());
         }
       }
     }
     return names;
   }
 
+  private static boolean fieldArg(Context ctx, String name) {
+    for (String kind : List.of("header", "cookie", "query")) {
+      Object defs = ctx.point == null ? null : Struct.getpath(ctx.point, List.of("args", kind));
+      if (defs instanceof List) {
+        for (Object ad : (List<?>) defs) {
+          if (name.equals(Struct.getprop(ad, "name", null)) &&
+              Boolean.TRUE.equals(Struct.getprop(ad, "field", null))) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
   private static Object omit(Object reqdata, List<String> names) {
     if (!(reqdata instanceof Map) || names.stream().noneMatch(((Map<?, ?>) reqdata)::containsKey)) {
       return reqdata;

package/project/.sdk/tm/js/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/js/src/Context.js

@@ -96,7 +96,7 @@ class Context {
       const opcfg = getpath(this.config, ['entity', entname, 'op', opname])
       let input = 'match'
 
-      if ('update' === opname || 'create' === opname) {
+      if ('update' === opname || 'create' === opname || 'patch' === opname) {
         input = 'data'
       }
 

package/project/.sdk/tm/js/src/Control.js

@@ -7,6 +7,7 @@ class Control {
     this.throw = getprop(ctrlmap, 'throw')
     this.err = getprop(ctrlmap, 'err')
     this.explain = getprop(ctrlmap, 'explain')
+    this.signal = getprop(ctrlmap, 'signal')
   }
 }
 

package/project/.sdk/tm/js/src/Response.js

@@ -20,7 +20,16 @@ function readJson(resmap) {
   if ('function' === typeof resmap.text) {
     return async () => {
       const text = await resmap.text()
-      return '' === text.trim() ? undefined : JSON.parse(text)
+      if ('' === text.trim()) {
+        return undefined
+      }
+      try {
+        return JSON.parse(text)
+      }
+      catch (err) {
+        err.text = text
+        throw err
+      }
     }
   }
   return resmap.json ? resmap.json.bind(resmap) : async () => undefined

package/project/.sdk/tm/js/src/Spec.js

@@ -17,6 +17,9 @@ class Spec {
     this.body = getprop(specmap, 'body')
     this.url = getprop(specmap, 'url')
     this.path = getprop(specmap, 'path')
+    // The query parameters prepareAuth placed: the credential, which the
+    // request sends and the entity's match leaves out.
+    this.authquery = getprop(specmap, 'authquery', [])
   }
 }
 

package/project/.sdk/tm/js/src/feature/base/BaseFeature.js

@@ -37,6 +37,34 @@ class BaseFeature {
 
   PreUnexpected(_ctx) { }
 
+
+  // Settles as `wait` does unless the signal aborts first, which runs `stop`
+  // and rejects with the signal's reason.
+  _untilAbort(wait, signal, stop) {
+    if (null == signal) {
+      return wait
+    }
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        if (null != stop) {
+          stop()
+        }
+        reject(signal.reason)
+      }
+      if (signal.aborted) {
+        return abort()
+      }
+      signal.addEventListener('abort', abort, { once: true })
+      wait.then((value) => {
+        signal.removeEventListener('abort', abort)
+        resolve(value)
+      }, (err) => {
+        signal.removeEventListener('abort', abort)
+        reject(err)
+      })
+    })
+  }
+
 }