@voxgig/sdkgen 4.33.0 → 4.34.1

package/project/.sdk/tm/scala/core/Helpers.scala

@@ -10,6 +10,13 @@ object Helpers {
   // underlying API spec doesn't define. The static SdkEntity contract
   // requires every CRUD method on every entity, so absent ops must still be
   // callable — they error at runtime instead of failing to compile.
+  // Whether a comma-separated allow option names the item: whole names, any case.
+  def allowed(names: Object, item: String): Boolean = names match {
+    case list: String if null != item && item.nonEmpty =>
+      list.split(",", -1).exists(_.trim.equalsIgnoreCase(item))
+    case _ => false
+  }
+
   def unsupportedOp(opname: String, entityname: String): SdkError =
     new SdkError("op_unsupported",
       "operation '" + opname + "' not supported by entity '" + entityname + "'", null)

package/project/.sdk/tm/scala/core/Response.scala

@@ -13,6 +13,8 @@ class Response(resmap: JMap[String, Object]) {
   var jsonFunc: Supplier[Object] = null
   var body: Object = null
   var err: RuntimeException = null
+  // Set by a transport that could not read a non-blank body as JSON.
+  var unreadable: Boolean = false
 
   locally {
     val s = Struct.getprop(resmap, "status")
@@ -33,5 +35,58 @@ class Response(resmap: JMap[String, Object]) {
       case e: RuntimeException => err = e
       case _ =>
     }
+
+    unreadable = java.lang.Boolean.TRUE == Struct.getprop(resmap, "unreadable")
+  }
+}
+
+object Response {
+  private val PreviewLength = 160
+
+  // A body that is not JSON. An HTTP failure keeps its own error, with the
+  // response described; otherwise the code tells a wrong content type from
+  // malformed JSON.
+  def unreadableBody(ctx: Context, status: Int, headers: Object, text: Object, sent: Object,
+      failed: RuntimeException): RuntimeException = {
+    val ctype = headerValue(headers, "content-type")
+    val agent = clean(ctx, headerValue(sent, "user-agent"))
+    val detail = "HTTP " + status + ", content-type " + (if (ctype.isEmpty) "none" else ctype) +
+      ", user-agent " + (if (agent.isEmpty) "transport default" else agent) +
+      (if (text == null) "" else ", body: " + preview(ctx, text))
+
+    failed match {
+      case null if ctype.isEmpty || ctype.toLowerCase.contains("json") =>
+        ctx.makeError("response_json_invalid", "response: body is not valid JSON (" + detail + ")")
+      case null =>
+        ctx.makeError("response_content_type",
+          "response: expected JSON, got " + ctype + " (" + detail + ")")
+      case e: SdkError =>
+        e.msg += " (" + detail + ")"
+        e
+      case e =>
+        new RuntimeException(e.getMessage + " (" + detail + ")", e)
+    }
+  }
+
+  private def headerValue(headers: Object, name: String): String = headers match {
+    case hm: JMap[_, _] =>
+      val it = hm.entrySet().iterator()
+      while (it.hasNext) {
+        val e = it.next()
+        if (name.equalsIgnoreCase(String.valueOf(e.getKey))) return String.valueOf(e.getValue)
+      }
+      ""
+    case _ => ""
+  }
+
+  private def clean(ctx: Context, s: String): String =
+    if (ctx.utility == null || ctx.utility.clean == null) s
+    else String.valueOf(ctx.utility.clean(ctx, s))
+
+  // Cleaned whole: a secret the bound would split could leave its prefix.
+  private def preview(ctx: Context, text: Object): String = {
+    val flat = clean(ctx, String.valueOf(text).replaceAll("\\s+", " ").trim)
+    if (flat.codePointCount(0, flat.length) <= PreviewLength) flat
+    else flat.substring(0, flat.offsetByCodePoints(0, PreviewLength)) + "..."
   }
 }

package/project/.sdk/tm/scala/core/SdkClient.scala

@@ -106,6 +106,14 @@ abstract class SdkClient(options0: JMap[String, Object]) {
     val path = Struct.getprop(fetchargs, "path") match { case s: String => s; case _ => "" }
     var method = Struct.getprop(fetchargs, "method") match { case s: String => s; case _ => "" }
     if ("" == method) method = "GET"
+    method = method.toUpperCase(java.util.Locale.ROOT)
+
+    val allowMethod = Struct.getpath(opts, java.util.List.of("allow", "method"))
+    if (!Helpers.allowed(allowMethod, method)) {
+      throw ctx.makeError("spec_method_allow",
+        "Method \"" + method + "\" not allowed by SDK option allow.method value: \"" +
+          (allowMethod match { case s: String => s; case _ => "" }) + "\"")
+    }
 
     var params = Helpers.toMapAny(Struct.getprop(fetchargs, "params"))
     if (params == null) params = new LinkedHashMap[String, Object]()
@@ -149,10 +157,7 @@ abstract class SdkClient(options0: JMap[String, Object]) {
 
   // Is this raw-access op permitted by the SDK's allow.op option?
   private def opAllowed(op: String): Boolean =
-    Struct.getpath(this.options, java.util.List.of("allow", "op")) match {
-      case s: String => s.contains(op)
-      case _ => false
-    }
+    Helpers.allowed(Struct.getpath(this.options, java.util.List.of("allow", "op")), op)
 
   private def opDenied(op: String): JMap[String, Object] = {
     val allow = Struct.getpath(this.options, java.util.List.of("allow", "op")) match {
@@ -278,17 +283,25 @@ abstract class SdkClient(options0: JMap[String, Object]) {
         val noBody = status == 204 || status == 304 || "0" == contentLength
 
         var jsonData: Object = null
+        var bodyErr: RuntimeException = null
         if (!noBody) {
           Struct.getprop(fm, "json") match {
             case jf: Supplier[_] => jsonData = jf.asInstanceOf[Supplier[Object]].get()
             case _ =>
           }
+          if (java.lang.Boolean.TRUE == Struct.getprop(fm, "unreadable")) {
+            val failed = if (status >= 200 && status < 300) null else ctx.makeError(
+              "request_status", "request: " + status + ": " + Struct.getprop(fm, "statusText"))
+            bodyErr = Response.unreadableBody(ctx, status, headers, Struct.getprop(fm, "body"),
+              fetchdef.get("headers"), failed)
+          }
         }
 
-        out.put("ok", java.lang.Boolean.valueOf(status >= 200 && status < 300))
+        out.put("ok", java.lang.Boolean.valueOf(bodyErr == null && status >= 200 && status < 300))
         out.put("status", java.lang.Integer.valueOf(status))
         out.put("headers", headers)
         out.put("data", jsonData)
+        if (bodyErr != null) out.put("err", cleanErr(ctx, bodyErr))
         out
       case _ =>
         out.put("ok", java.lang.Boolean.FALSE)

package/project/.sdk/tm/scala/core/Spec.scala

@@ -18,6 +18,9 @@ class Spec(specmap: JMap[String, Object]) {
   var body: Object = null
   var url: String = ""
   var path: String = ""
+  // The query parameters prepareAuth placed: the credential, which the
+  // request sends and the entity's match leaves out.
+  var authquery: JList[String] = new java.util.ArrayList[String]()
 
   def this() = this(null)
 

package/project/.sdk/tm/scala/feature/TestFeature.scala

@@ -45,9 +45,42 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
   // and the response transform unwraps that key on the way back. Returning the
   // bare payload means the transform unwraps a property that is not there and
   // the caller gets nothing. Mirrors the go/ts/lua/php mocks.
+  // The record the mock keeps: the request data without `$body`, which only the
+  // wire carries.
+  private def record(reqdata: JMap[String, Object]): JMap[String, Object] = {
+    if (reqdata == null) return null
+    val out = new LinkedHashMap[String, Object](reqdata)
+    out.remove("$body")
+    out
+  }
+
+  // The key a list's response transform
+  // ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+  private def itemEnvelopeKey(restf: Object): String = restf match {
+    case spec: JList[_] if 3 == spec.size && "`$EACH`" == spec.get(0) && "body" == spec.get(1) =>
+      spec.get(2) match {
+        case m: JMap[_, _] => m.get("`$MERGE`") match {
+          case merge: String => "^`\\.([^.`$]+)`$".r.findFirstMatchIn(merge).map(_.group(1)).orNull
+          case _ => null
+        }
+        case _ => null
+      }
+    case _ => null
+  }
+
   private def envelope(ctx: Context, data: Object): Object = {
     if (data == null || ctx == null || ctx.point == null) return data
     val tm = Struct.getprop(ctx.point, "transform")
+    val key = itemEnvelopeKey(Struct.getprop(tm, "res"))
+    if (null != key && data.isInstanceOf[JList[_]]) {
+      val items = new java.util.ArrayList[Object]()
+      data.asInstanceOf[JList[Object]].forEach { item =>
+        val wrapped = new LinkedHashMap[String, Object]()
+        wrapped.put(key, item)
+        items.add(wrapped)
+      }
+      return items
+    }
     Struct.getprop(tm, "res") match {
       case spec: String =>
         // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
@@ -124,7 +157,7 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
       while (it.hasNext) Struct.delprop(it.next(), "$KEY")
       val out = Struct.clone(found)
       respond(ctx, 200, out, null)
-    } else if ("update" == op.name) {
+    } else if ("update" == op.name || "patch" == op.name) {
       var updateMatch = new LinkedHashMap[String, Object]()
       if (ctx.reqdata != null) {
         if (ctx.reqdata.containsKey("id")) updateMatch.put("id", ctx.reqdata.get("id"))
@@ -141,7 +174,7 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
       val ent = Struct.getelem(found, java.lang.Integer.valueOf(0))
       // update miss: 404, never another record
       if (ent == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
-      ent match { case _: JMap[_, _] if ctx.reqdata != null => Struct.merge(Struct.jt(ent, ctx.reqdata)); case _ => }
+      ent match { case _: JMap[_, _] if ctx.reqdata != null => Struct.merge(Struct.jt(ent, record(ctx.reqdata))); case _ => }
       Struct.delprop(ent, "$KEY")
       val out = Struct.clone(ent)
       respond(ctx, 200, out, null)
@@ -166,7 +199,7 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           java.lang.Integer.valueOf(r.nextInt(0x10000)), java.lang.Integer.valueOf(r.nextInt(0x10000)))
       }
 
-      val ent = Struct.clone(ctx.reqdata)
+      val ent = Struct.clone(record(ctx.reqdata))
       ent match {
         case entm0: JMap[_, _] =>
           val entm = entm0.asInstanceOf[JMap[String, Object]]

package/project/.sdk/tm/scala/feature/TimeoutFeature.scala

@@ -2,6 +2,7 @@ package SCALAPACKAGE.feature
 
 import java.util.{Map => JMap}
 import java.util.concurrent.{CompletableFuture, CompletionException, TimeUnit, TimeoutException}
+import java.util.concurrent.atomic.AtomicLong
 import java.util.function.Supplier
 import SCALAPACKAGE.core.{Context, FetcherFn, SdkClient}
 
@@ -28,28 +29,53 @@ class TimeoutFeature extends BaseFeature("timeout", "0.0.1", true) {
     val deadline = FeatureOptions.foptInt(this.options, "ms", 30000)
     if (deadline <= 0) return inner(ctx, url, fetchdef)
 
-    val sup: Supplier[Object] = () => inner(ctx, url, fetchdef)
+    // The deadline runs from here, not from the wait below: a caller paused
+    // between the two would otherwise find a late response complete and take
+    // it. The worker notes when it finished, so a response or a failure after
+    // the deadline is a timeout however late the caller looks.
+    val now = FeatureOptions.foptNow(this.options)
+    val start = now.getAsLong
+    val arrived = new AtomicLong(Long.MaxValue)
+    val sup: Supplier[Object] = () => {
+      try inner(ctx, url, fetchdef)
+      finally arrived.set(now.getAsLong)
+    }
     val fut = CompletableFuture.supplyAsync(sup)
 
-    try fut.get(deadline.toLong, TimeUnit.MILLISECONDS)
+    try {
+      val remaining = Math.max(0L, deadline - (now.getAsLong - start))
+      val out = try fut.get(remaining, TimeUnit.MILLISECONDS)
+      catch {
+        case e: java.util.concurrent.ExecutionException =>
+          if (deadline < arrived.get - start) throw timeout(ctx, deadline)
+          throw unwrap(e)
+      }
+      if (deadline < arrived.get - start) throw timeout(ctx, deadline)
+      out
+    }
     catch {
-      case _: TimeoutException =>
-        track(deadline)
-        throw ctx.makeError("timeout", "Request exceeded timeout of " + deadline + "ms")
-      case e: java.util.concurrent.ExecutionException =>
-        var cause = e.getCause
-        cause match { case ce: CompletionException if ce.getCause != null => cause = ce.getCause; case _ => }
-        cause match {
-          case re: RuntimeException => throw re
-          case err: Error => throw err
-          case _ => throw new RuntimeException(cause)
-        }
+      case _: TimeoutException => throw timeout(ctx, deadline)
       case _: InterruptedException =>
         Thread.currentThread().interrupt()
         throw new RuntimeException("interrupted")
     }
   }
 
+  private def unwrap(e: java.util.concurrent.ExecutionException): Throwable = {
+    var cause = e.getCause
+    cause match { case ce: CompletionException if ce.getCause != null => cause = ce.getCause; case _ => }
+    cause match {
+      case re: RuntimeException => re
+      case err: Error => err
+      case _ => new RuntimeException(cause)
+    }
+  }
+
+  private def timeout(ctx: Context, deadline: Int): Throwable = {
+    track(deadline)
+    ctx.makeError("timeout", "Request exceeded timeout of " + deadline + "ms")
+  }
+
   private def track(deadline: Int): Unit = {
     this.count += 1
     this.ms = deadline

package/project/.sdk/tm/scala/feature/ValidateFeature.scala

@@ -171,6 +171,8 @@ class ValidateFeature extends BaseFeature("validate", "0.0.1", true) {
     // fields will never name it - and under `strict` every custom-action call
     // would be rejected for the one key that made it reachable.
     out.remove("$action")
+    // Nor is `$body`, the raw request body.
+    out.remove("$body")
 
     out
   }

package/project/.sdk/tm/scala/sdktest/SdkTestMain.scala

@@ -130,7 +130,7 @@ object SdkTestMain {
   }
 
   def fhDefaultMethod(op: String): String = op match {
-    case "create" => "POST"; case "update" => "PATCH"; case "remove" => "DELETE"; case _ => "GET"
+    case "create" => "POST"; case "update" | "patch" => "PATCH"; case "remove" => "DELETE"; case _ => "GET"
   }
 
   def fhBuildUrl(spec: Spec): String = {
@@ -348,6 +348,21 @@ object SdkTestMain {
     { val f = new TimeoutFeature()
       val h = fhMake((c, u, fd) => { Thread.sleep(60); fhResponse(200, om("ok" -> B(true)), null) }, fhF(f, om("ms" -> I(10))))
       val r = h.op(fhOp("load")); eq("timeout.err", "timeout", fhErrCode(r.err)); eqI("timeout.count", 1, f.count) }
+    // A clock standing at 0 for the calling thread and at `later` for any other.
+    def workerClock(later: Long): LongSupplier = {
+      val caller = Thread.currentThread()
+      () => if (Thread.currentThread() eq caller) 0L else later
+    }
+    // The deadline runs from the request's start, not from the wait: the
+    // clock stands at the start for the caller and 300 ms later for the worker.
+    { val f = new TimeoutFeature()
+      val h = fhMake(null, fhF(f, om("ms" -> I(20), "now" -> f0(workerClock(300L)))))
+      val r = h.op(fhOp("load")); eq("timeout.late", "timeout", fhErrCode(r.err)); eqI("timeout.late.count", 1, f.count) }
+    // A transport failure after the deadline is a timeout too, not the failure.
+    { val f = new TimeoutFeature()
+      val h = fhMake((c, u, fd) => throw new IllegalStateException("socket closed"),
+        fhF(f, om("ms" -> I(20), "now" -> f0(workerClock(300L)))))
+      val r = h.op(fhOp("load")); eq("timeout.latefail", "timeout", fhErrCode(r.err)); eqI("timeout.latefail.count", 1, f.count) }
     { val h = fhMake(null, fhF(new TimeoutFeature(), om("ms" -> I(1000))))
       check("timeout.fast", h.op(fhOp("load")).ok, "expected ok") }
     { val h = fhMake(null, fhF(new TimeoutFeature(), om("ms" -> I(0))))

package/project/.sdk/tm/scala/sdktest/ServerVariableTest.scala

@@ -0,0 +1,49 @@
+// A templated base URL takes each {name} from the `server` option. A missing
+// or empty value fails construction; test mode fills in test-<name>.
+
+import java.util.{Map => JMap}
+
+import SCALAPACKAGE.core.{ProjectNameSDK, SdkError}
+
+object SdkServerTestMain {
+
+  // A variable no API declares, so the API's own server defaults cannot fill it.
+  private val BASE = "https://api.example.test/bot{zzvar}"
+
+  private def om(kv: (String, Object)*): JMap[String, Object] = SdkTestSupport.om(kv*)
+
+  def main(args: Array[String]): Unit = {
+    val rep = new SdkTestReport()
+
+    rep.scope("server.missing") {
+      for (server <- List(om(), om("zzvar" -> ""))) {
+        val err =
+          try { new ProjectNameSDK(om("base" -> BASE, "server" -> server)); null }
+          catch { case e: SdkError => e }
+        rep.check("server.missing.fails", err != null,
+          "construction should fail without a value for zzvar: " + server)
+        if (err != null) {
+          rep.eq("server.missing.code", "server_var_required", err.code)
+          rep.check("server.missing.message",
+            err.msg.contains("the server variable 'zzvar' is required") && err.msg.contains(BASE), err.msg)
+        }
+      }
+    }
+
+    rep.scope("server.filled") {
+      val client = new ProjectNameSDK(om("base" -> BASE, "server" -> om("zzvar" -> "T1")))
+      rep.eq("server.filled", "https://api.example.test/botT1", client.optionsMap().get("base"))
+    }
+
+    rep.scope("server.testmode") {
+      val client = new ProjectNameSDK(om("base" -> BASE, "test" -> om("active" -> SdkTestSupport.B(true))))
+      rep.eq("server.testmode.option", "https://api.example.test/bottest-zzvar",
+        client.optionsMap().get("base"))
+      val mock = ProjectNameSDK.testSDK(null, om("base" -> BASE))
+      rep.eq("server.testmode.feature", "https://api.example.test/bottest-zzvar",
+        mock.optionsMap().get("base"))
+    }
+
+    rep.finish("SERVER")
+  }
+}

package/project/.sdk/tm/scala/sdktest/feature/secrets/SecretsTestMain.scala

@@ -716,6 +716,7 @@ object SecretsTestMain {
     "Gcpsecrets" -> List("gcpsecrets"),
     "Hashicorp" -> List("hashicorp"),
     "Infisical" -> List("infisical"),
+    "Minivault" -> List("minivault"),
     "Onepassword" -> List("onepassword"),
     "Secretspec" -> List("secretspec"),
   )

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

@@ -48,6 +48,8 @@ object Fetcher {
     var bodyPublisher = HttpRequest.BodyPublishers.noBody()
     fetchdef.get("body") match {
       case b: String if b != "" => bodyPublisher = HttpRequest.BodyPublishers.ofString(b)
+      case b: Array[Byte] => bodyPublisher = HttpRequest.BodyPublishers.ofByteArray(b)
+      case b: java.io.InputStream => bodyPublisher = HttpRequest.BodyPublishers.ofInputStream(() => b)
       case _ =>
     }
 
@@ -70,7 +72,15 @@ object Fetcher {
         }
       case _ =>
     }
-    if (!hasUA) reqb.setHeader("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)")
+    // The default User-Agent is recorded with the headers the request sent.
+    if (!hasUA) {
+      val agent = "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)"
+      reqb.setHeader("User-Agent", agent)
+      fetchdef.get("headers") match {
+        case hm: JMap[_, _] => hm.asInstanceOf[JMap[String, Object]].put("user-agent", agent)
+        case _ =>
+      }
+    }
 
     val resp =
       try clientFor(fetchdef).send(reqb.build(), HttpResponse.BodyHandlers.ofString())
@@ -86,7 +96,11 @@ object Fetcher {
     }
 
     val bodyText = if (resp.body() == null) "" else resp.body()
-    val jsonBody: Object = if (bodyText.isEmpty) null else Json.parseOrNull(bodyText)
+    var unreadable = false
+    val jsonBody: Object =
+      if (bodyText.isBlank) null
+      else try Json.parse(bodyText)
+      catch { case _: RuntimeException => unreadable = true; null }
     val jsonSupplier: Supplier[Object] = () => jsonBody
 
     val out = new LinkedHashMap[String, Object]()
@@ -95,6 +109,7 @@ object Fetcher {
     out.put("headers", headers)
     out.put("json", jsonSupplier)
     out.put("body", bodyText)
+    out.put("unreadable", java.lang.Boolean.valueOf(unreadable))
     out
   }