@voxgig/sdkgen 4.34.0 → 4.34.2

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 point marks it as a field the body keeps.
+  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)
+      })
+    })
+  }
+
 }
 
 

package/project/.sdk/tm/js/src/feature/netsim/NetsimFeature.js

@@ -52,7 +52,7 @@ class NetsimFeature extends BaseFeature {
 
     // Total outage: every call fails at the transport level.
     if (true === opts.offline) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.offline = true
       this._track(ctx, applied)
       return ctx.error('netsim_offline', 'Simulated network offline (URL was: "' + url + '")')
@@ -60,7 +60,7 @@ class NetsimFeature extends BaseFeature {
 
     // Connection-level errors for the first N calls (e.g. ECONNRESET).
     if (call <= (opts.errorTimes | 0)) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.error = true
       this._track(ctx, applied)
       return ctx.error('netsim_conn', 'Simulated connection error (call ' + call + ')')
@@ -68,7 +68,7 @@ class NetsimFeature extends BaseFeature {
 
     // Rate-limit responses (HTTP 429 + Retry-After) for the first N calls.
     if (call <= (opts.rateLimitTimes | 0)) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.rateLimited = true
       this._track(ctx, applied)
       return this._respond(ctx, 429, undefined, {
@@ -83,7 +83,7 @@ class NetsimFeature extends BaseFeature {
     const failByEvery = 0 < (opts.failEvery | 0) && 0 === call % opts.failEvery
     const failByRate = 0 < (opts.failRate || 0) && this._rand() < opts.failRate
     if (failByCount || failByEvery || failByRate) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.failStatus = failStatus
       this._track(ctx, applied)
       return this._respond(ctx, failStatus, undefined, { statusText: 'Simulated Failure' })
@@ -93,7 +93,7 @@ class NetsimFeature extends BaseFeature {
     const latency = this._pickLatency()
     applied.latency = latency
     this._track(ctx, applied)
-    await this._sleep(latency)
+    await this._sleep(latency, fetchdef?.signal)
     return inner(ctx, url, fetchdef)
   }
 
@@ -116,15 +116,17 @@ class NetsimFeature extends BaseFeature {
   }
 
 
-  _sleep(ms) {
+  _sleep(ms, signal) {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/js/src/feature/ratelimit/RatelimitFeature.js

@@ -38,13 +38,13 @@ class RatelimitFeature extends BaseFeature {
     const inner = utility.fetcher
 
     utility.fetcher = async function (ctx2, url, fetchdef) {
-      await self._acquire(ctx2)
+      await self._acquire(ctx2, fetchdef?.signal)
       return inner(ctx2, url, fetchdef)
     }
   }
 
 
-  async _acquire(ctx) {
+  async _acquire(ctx, signal) {
     const rate = this._options.rate || 5
     const burst = null == this._options.burst ? rate : this._options.burst
 
@@ -63,7 +63,7 @@ class RatelimitFeature extends BaseFeature {
     const needed = 1 - this._tokens
     const waitMs = Math.ceil((needed / rate) * 1000)
     this._track(ctx, waitMs)
-    await this._sleep(waitMs)
+    await this._sleep(waitMs, signal)
     this._last = this._now()
     this._tokens = 0
   }
@@ -78,15 +78,17 @@ class RatelimitFeature extends BaseFeature {
   }
 
 
-  _sleep(ms) {
+  _sleep(ms, signal) {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/js/src/feature/retry/RetryFeature.js

@@ -44,6 +44,7 @@ class RetryFeature extends BaseFeature {
     const maxDelay = null == opts.maxDelay ? 2000 : opts.maxDelay
     const factor = null == opts.factor ? 2 : opts.factor
 
+    const signal = fetchdef?.signal
     let attempt = 0
     let last
 
@@ -60,6 +61,12 @@ class RetryFeature extends BaseFeature {
 
       last = res
 
+      // An abort is never retried, whatever the transport threw for it: the
+      // reason need not be an Error, so decide before the retryable test.
+      if (threw && true === signal?.aborted) {
+        throw signal.reason
+      }
+
       const retryable = this._retryable(res)
       if (!retryable || attempt >= max) {
         // Out of attempts: rethrow a thrown error to preserve pipeline
@@ -70,9 +77,13 @@ class RetryFeature extends BaseFeature {
         return res
       }
 
+      if (true === signal?.aborted) {
+        throw signal.reason
+      }
+
       const wait = this._backoff(res, attempt, minDelay, maxDelay, factor)
       this._track(ctx, attempt + 1, res, wait)
-      await this._sleep(wait)
+      await this._sleep(wait, signal)
       attempt++
     }
   }
@@ -125,15 +136,17 @@ class RetryFeature extends BaseFeature {
   }
 
 
-  _sleep(ms) {
+  _sleep(ms, signal) {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/js/src/feature/test/TestFeature.js

@@ -16,6 +16,28 @@ function mintId() {
 
 
 
+// The record the mock keeps: the request data without `$body`, which only the
+// wire carries.
+function recordOf(reqdata) {
+  const out = { ...(reqdata || {}) }
+  delete out.$body
+  return out
+}
+
+
+// The key a list response wraps each record under, where the response
+// transform is `["`$EACH`", "body", { "`$MERGE`": "`.<key>`" }]`.
+function itemEnvelopeKey(restf) {
+  if (!Array.isArray(restf) || 3 !== restf.length ||
+    '`$EACH`' !== restf[0] || 'body' !== restf[1]) {
+    return null
+  }
+  const merge = restf[2]?.['`$MERGE`']
+  const m = 'string' === typeof merge ? merge.match(/^`\.([^.`$]+)`$/) : null
+  return null == m ? null : m[1]
+}
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -69,6 +91,10 @@ class TestFeature extends BaseFeature {
       // whose responses happen to be unwrapped.
       function envelope(data) {
         const restf = getprop(getprop(ctx.point, 'transform', {}), 'res')
+        const itemkey = itemEnvelopeKey(restf)
+        if (null != itemkey && Array.isArray(data)) {
+          return data.map((item) => ({ [itemkey]: item }))
+        }
         if (null == data || 'string' !== typeof restf) {
           return data
         }
@@ -143,8 +169,8 @@ class TestFeature extends BaseFeature {
           return respond(200, out)
         }
       }
-      else if ('update' === op.name) {
-        const args = self.buildArgs(ctx, op, ctx.reqdata)
+      else if ('update' === op.name || 'patch' === op.name) {
+        const args = self.buildArgs(ctx, op, recordOf(ctx.reqdata))
         const found = select(entmap, args)
         const ent = getelem(found, 0)
         if (null == ent) {
@@ -152,7 +178,7 @@ class TestFeature extends BaseFeature {
           return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
         else {
-          merge([ent, (ctx.reqdata || {})])
+          merge([ent, recordOf(ctx.reqdata)])
           delprop(ent, '$KEY')
           const out = clone(ent)
           return respond(200, out)
@@ -170,13 +196,13 @@ class TestFeature extends BaseFeature {
         return respond(200)
       }
       else if ('create' === op.name) {
-        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        const args = self.buildArgs(ctx, op, recordOf(ctx.reqdata))
         let id = param(ctx, 'id')
         if (null == id) {
           id = mintId()
         }
 
-        const ent = clone(ctx.reqdata)
+        const ent = clone(recordOf(ctx.reqdata))
         setprop(ent, 'id', id)
         setprop(entmap, id, ent)
         delprop(ent, '$KEY')
@@ -213,10 +239,12 @@ class TestFeature extends BaseFeature {
       return max <= min ? min : min + ((max - min) >> 1)
     }
 
-    function sleep(ms) {
+    function sleep(ms, signal) {
       if (null == ms || 0 >= ms) { return Promise.resolve() }
-      if ('function' === typeof net.sleep) { return Promise.resolve(net.sleep(ms)) }
-      return new Promise((r) => setTimeout(r, ms))
+      if ('function' === typeof net.sleep) { return self._untilAbort(Promise.resolve(net.sleep(ms)), signal) }
+      let timer
+      return self._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+        () => clearTimeout(timer))
     }
 
     return async function netsimFetcher(ctx, url, fetchdef) {
@@ -224,15 +252,15 @@ class TestFeature extends BaseFeature {
       const call = self._netcalls
 
       if (true === net.offline) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         return ctx.error('netsim_offline', 'Simulated network offline (URL was: "' + url + '")')
       }
       if (call <= (net.errorTimes | 0)) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         return ctx.error('netsim_conn', 'Simulated connection error (call ' + call + ')')
       }
       if (call <= (net.failTimes | 0)) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         const status = null == net.failStatus ? 503 : net.failStatus
         return {
           status,
@@ -242,7 +270,7 @@ class TestFeature extends BaseFeature {
           headers: { forEach(_cb) { }, get(_k) { return undefined } },
         }
       }
-      await sleep(pickLatency())
+      await sleep(pickLatency(), fetchdef?.signal)
       return inner(ctx, url, fetchdef)
     }
   }