@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -0,0 +1,186 @@
+// Requests in flight at once on one client. Each resolves its operation
+// through the cache the client's root context shares with every request, and
+// registers and cleans secrets through the one registry the client holds.
+
+import java.util.concurrent.{ConcurrentLinkedQueue, CountDownLatch, CyclicBarrier}
+import java.util.function.{BiFunction, Supplier}
+import java.util.{Map => JMap}
+
+import SCALAPACKAGE.core.{Context, Operation, ProjectNameSDK, Utility}
+
+object SdkConcurrencyTestMain {
+
+  private val Rounds = 200
+  private val Width = 8
+  private val Ops = 32
+
+  private def om(kv: (String, Object)*): JMap[String, Object] = SdkTestSupport.om(kv*)
+
+  // A live client whose transport answers at once.
+  private def liveClient(): ProjectNameSDK = {
+    val json: Supplier[Object] = () => om("ok" -> SdkTestSupport.B(true))
+    val fetch: BiFunction[String, JMap[String, Object], Object] = (_, _) =>
+      om("status" -> SdkTestSupport.I(200), "statusText" -> "OK", "headers" -> om(), "json" -> json)
+    new ProjectNameSDK(om(
+      "base" -> "http://concurrency.test/api",
+      "allow" -> om("op" -> "direct"),
+      "system" -> om("fetch" -> fetch)))
+  }
+
+  // Runs body on Width threads released together, and returns what they threw.
+  private def atOnce(body: Int => Unit): List[Throwable] = {
+    val start = new CyclicBarrier(Width)
+    val thrown = new ConcurrentLinkedQueue[Throwable]()
+    val threads = (0 until Width).map { n =>
+      val runner: Runnable = () =>
+        try {
+          start.await()
+          body(n)
+        }
+        catch { case e: Throwable => thrown.add(e); () }
+      val thread = new Thread(runner)
+      thread.start()
+      thread
+    }
+    threads.foreach(_.join())
+    thrown.toArray(new Array[Throwable](0)).toList
+  }
+
+  private def addedSecret(round: Int, n: Int, k: Int): String =
+    "ADDED-SECRET-" + round + "-" + n + "-" + k
+
+  // Registers thread n's secrets, then counts the thread out of registering.
+  private def registerSecrets(utility: Utility, root: Context, round: Int, n: Int,
+      registering: CountDownLatch): Unit =
+    try {
+      for (k <- 0 until Ops) utility.cleanAdd(root, addedSecret(round, n, k))
+    }
+    finally registering.countDown()
+
+  // The first secret registered in the round that a clean leaves raw.
+  private def unmasked(utility: Utility, root: Context, round: Int): Option[String] =
+    (for (n <- 0 until Width / 2; k <- 0 until Ops) yield addedSecret(round, n, k))
+      .find(added => "[redacted]" != utility.clean(root, added))
+
+  // The first failure across the rounds, or null.
+  private def firstFailure(round: Int => String): String = {
+    var failure: String = null
+    var n = 0
+    while (failure == null && n < Rounds) {
+      failure = round(n)
+      n += 1
+    }
+    failure
+  }
+
+  def main(args: Array[String]): Unit = {
+    val rep = new SdkTestReport()
+
+    rep.scope("concurrency.requests") {
+      val failure = firstFailure { round =>
+        // A fresh client each round, so every request in it is a first request.
+        val client = liveClient()
+        val results = new Array[JMap[String, Object]](Width)
+        val thrown = atOnce(n => results(n) = client.direct(om("path" -> ("p" + n))))
+        val failed = (0 until Width).find(n =>
+          results(n) == null || java.lang.Boolean.TRUE != results(n).get("ok"))
+        if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+        else failed.map(n => "round " + round + ", request " + n + " failed: " + results(n)).orNull
+      }
+      rep.check("concurrency.requests", failure == null, failure)
+    }
+
+    rep.scope("concurrency.operations") {
+      val failure = firstFailure { round =>
+        val client = liveClient()
+        val utility = client.getUtility()
+        val root = client.getRootCtx()
+        val got = Array.ofDim[Operation](Width, Ops)
+        val thrown = atOnce { n =>
+          for (k <- 0 until Ops) {
+            got(n)(k) = utility.makeContext(om("opname" -> ("op" + k)), root).op
+          }
+        }
+        val split = (0 until Ops).find { k =>
+          val cached = utility.makeContext(om("opname" -> ("op" + k)), root).op
+          (0 until Width).exists(n => !(got(n)(k) eq cached))
+        }
+        if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+        else split.map(k => "round " + round + ": op" + k + " resolved to more than one Operation").orNull
+      }
+      rep.check("concurrency.operations", failure == null, failure)
+    }
+
+    // Secrets registered on some threads while others clean: every clean
+    // masks what was registered before it, the longer secret whole, and no
+    // registration is lost.
+    rep.scope("concurrency.registry") {
+      val masked = "a [redacted] b [redacted] c"
+      val failure = firstFailure { round =>
+        if (round >= Rounds / 4) null
+        else {
+          val client = liveClient()
+          val utility = client.getUtility()
+          val root = client.getRootCtx()
+          val inner = "INNER-SECRET-" + round
+          utility.cleanAdd(root, inner)
+          utility.cleanAdd(root, "OUTER-" + inner + "-TAIL")
+          val text = "a " + inner + " b OUTER-" + inner + "-TAIL c"
+          val before = utility.clean(root, text)
+          val registering = new CountDownLatch(Width / 2)
+          val wrong = new ConcurrentLinkedQueue[Object]()
+          val thrown = atOnce { n =>
+            if (n < Width / 2) registerSecrets(utility, root, round, n, registering)
+            else {
+              while (0L < registering.getCount) {
+                val got = utility.clean(root, text)
+                if (masked != got) wrong.add(got)
+              }
+            }
+          }
+          if (masked != before) "round " + round + " cleaned to: " + before
+          else if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+          else if (!wrong.isEmpty) "round " + round + " cleaned to: " + wrong
+          else unmasked(utility, root, round)
+            .map(added => "round " + round + ": " + added + " was registered but not masked").orNull
+        }
+      }
+      rep.check("concurrency.registry", failure == null, failure)
+    }
+
+    // Requests on one client while secrets register on it: each request
+    // copies the client's options, the registry among them.
+    rep.scope("concurrency.registry.requests") {
+      val failure = firstFailure { round =>
+        if (round >= Rounds / 4) null
+        else {
+          val client = liveClient()
+          val utility = client.getUtility()
+          val root = client.getRootCtx()
+          val registering = new CountDownLatch(Width / 2)
+          val failed = new ConcurrentLinkedQueue[Object]()
+          val thrown = atOnce { n =>
+            if (n < Width / 2) registerSecrets(utility, root, round, n, registering)
+            else {
+              var going = true
+              while (going && 0L < registering.getCount) {
+                val res = client.direct(om("path" -> ("p" + n)))
+                if (java.lang.Boolean.TRUE != res.get("ok")) {
+                  failed.add(res)
+                  going = false
+                }
+              }
+            }
+          }
+          if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+          else if (!failed.isEmpty) "round " + round + ", a request failed: " + failed
+          else unmasked(utility, root, round)
+            .map(added => "round " + round + ": " + added + " was registered but not masked").orNull
+        }
+      }
+      rep.check("concurrency.registry.requests", failure == null, failure)
+    }
+
+    rep.finish("CONCURRENCY")
+  }
+}

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
   }
 

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

@@ -64,6 +64,64 @@ object MakeError {
 }
 
 object MakePoint {
+  private val PathParam = "\\{([^{}/]+)\\}".r
+
+  // A terminal parameter marks a record route (/boards/{id}); a
+  // cross-reference ends in the relationship's name (/posts/{id}/author).
+  // Failing that, the shallower path wins. The same rule runs at generation
+  // time, in helpers/opShape.ts — both sides must move together.
+  private def partsLen(p: JMap[String, Object]): Int =
+    Struct.getprop(p, "parts") match {
+      case parts: JList[_] => parts.size()
+      case _ => 0
+    }
+
+  private def terminalParam(p: JMap[String, Object]): Boolean =
+    Struct.getprop(p, "parts") match {
+      case parts: JList[_] if parts.size() > 0 =>
+        parts.get(parts.size() - 1) match {
+          case s: String => s.startsWith("{")
+          case _ => false
+        }
+      case _ => false
+    }
+
+  private def ownPoint(points: Seq[JMap[String, Object]]): JMap[String, Object] = {
+    var best = points.head
+    for (cand <- points) {
+      val candTerm = terminalParam(cand)
+      val bestTerm = terminalParam(best)
+      if (candTerm != bestTerm) {
+        if (candTerm) best = cand
+      } else if (partsLen(cand) < partsLen(best)) {
+        best = cand
+      }
+    }
+    best
+  }
+
+  // The path parameters of a point that neither the call nor the entity gives
+  // a value for, looked up as param looks them up.
+  private def unfilled(ctx: Context, point: JMap[String, Object]): Seq[String] =
+    Struct.getprop(point, "parts") match {
+      case parts: JList[_] =>
+        val missing = scala.collection.mutable.ArrayBuffer[String]()
+        val it = parts.iterator()
+        while (it.hasNext) {
+          it.next() match {
+            case text: String =>
+              text match {
+                case PathParam(name) =>
+                  if (Param.value(ctx, point, name) == null) missing += name
+                case _ =>
+              }
+            case _ =>
+          }
+        }
+        missing.toSeq
+      case _ => Seq.empty
+    }
+
   def makePoint(ctx: Context): JMap[String, Object] = {
     val outPoint = ctx.out.get("point")
     if (outPoint != null) {
@@ -79,8 +137,9 @@ object MakePoint {
     val op = ctx.op
     val options = ctx.options
 
-    val allowOp = Struct.getpath(options, java.util.List.of("allow", "op")) match { case s: String => s; case _ => "" }
-    if (!allowOp.contains(op.name)) {
+    val allowOpRaw = Struct.getpath(options, java.util.List.of("allow", "op"))
+    val allowOp = allowOpRaw match { case s: String => s; case _ => "" }
+    if (!Helpers.allowed(allowOpRaw, op.name)) {
       throw ctx.makeError("point_op_allow",
         "Operation \"" + op.name + "\" not allowed by SDK option allow.op value: \"" + allowOp + "\"")
     }
@@ -146,39 +205,25 @@ object MakePoint {
               Struct.stringify(unmatchedAction) + "\" is not valid.")
         }
 
-        // A terminal parameter marks a record route (/boards/{id}); a
-        // cross-reference ends in the relationship's name
-        // (/posts/{id}/author). Failing that, the shallower path wins. The
-        // same rule runs at generation time, in helpers/opShape.ts — both
-        // sides must move together.
-        def partsLen(p: JMap[String, Object]): Int =
-          Struct.getprop(p, "parts") match {
-            case parts: JList[_] => parts.size()
-            case _ => 0
-          }
-        def terminalParam(p: JMap[String, Object]): Boolean =
-          Struct.getprop(p, "parts") match {
-            case parts: JList[_] if parts.size() > 0 =>
-              parts.get(parts.size() - 1) match {
-                case s: String => s.startsWith("{")
-                case _ => false
-              }
-            case _ => false
-          }
+        // A call without an action falls back to a point without one, as
+        // generation does, and only to a route the call can fill.
+        val all = (0 until op.points.size()).map(op.points.get(_))
+        val plain = all.filter(cand =>
+          Struct.getprop(Helpers.toMapAny(Struct.getprop(cand, "select")), "$action", null) == null)
+        if (plain.isEmpty) {
+          throw ctx.makeError("point_action_required",
+            "Operation \"" + op.name + "\" has only action endpoints; pass $action to choose one.")
+        }
 
-        point = op.points.get(0)
-        var j = 0
-        while (j < op.points.size()) {
-          val cand = op.points.get(j)
-          val candTerm = terminalParam(cand)
-          val bestTerm = terminalParam(point)
-          if (candTerm != bestTerm) {
-            if (candTerm) point = cand
-          } else if (partsLen(cand) < partsLen(point)) {
-            point = cand
-          }
-          j += 1
+        val fillable = plain.filter(cand => unfilled(ctx, cand).isEmpty)
+
+        if (fillable.isEmpty) {
+          throw ctx.makeError("point_no_match",
+            "Operation \"" + op.name + "\" has no endpoint whose path parameters are all given (missing: " +
+              unfilled(ctx, ownPoint(plain)).mkString(", ") + ").")
         }
+
+        point = ownPoint(fillable)
       }
 
       if (reqselector != null) {
@@ -202,6 +247,9 @@ object MakePoint {
 
 object MakeOptions {
 
+  // A {name} placeholder in a templated server URL (an OpenAPI server variable).
+  private val SERVER_VAR = "\\{([A-Za-z0-9_]+)\\}".r
+
   /**
    * Replaces one utility member from `options.utility`, matching the ts
    * reference: a key naming a real member REPLACES it, and any other key is
@@ -373,6 +421,38 @@ object MakeOptions {
       else { val sm = new LinkedHashMap[String, Object](); sm.put("fetch", sysFetch); opts.put("system", sm) }
     }
 
+    // A templated base URL takes each {name} from options.server. An empty
+    // value cannot make a working URL, so it fails construction, except in
+    // test mode, where it becomes test-<name>.
+    opts.get("base") match {
+      case base: String if base.contains("{") =>
+        val testmode =
+          java.lang.Boolean.TRUE == Struct.getpath(opts, java.util.List.of("test", "active")) ||
+            java.lang.Boolean.TRUE == Struct.getpath(opts, java.util.List.of("feature", "test", "active"))
+        val server = Helpers.toMapAny(opts.get("server"))
+        val sdkname = Struct.getpath(config, java.util.List.of("main", "name")) match {
+          case s: String if s.nonEmpty => s
+          case _ => "SDK"
+        }
+        val resolved = SERVER_VAR.replaceAllIn(base, (m: scala.util.matching.Regex.Match) => {
+          val name = m.group(1)
+          val value = (if (server == null) null else server.get(name)) match {
+            case s: String => s
+            case _ => ""
+          }
+          val filled =
+            if ("" != value) value
+            else if (testmode) "test-" + name
+            else throw new SdkError("server_var_required",
+              sdkname + ": the server variable '" + name + "' is required: the API base URL is '" +
+                base + "' - pass options.put(\"server\", java.util.Map.of(\"" + name +
+                "\", \"...\")) in the SDK options", ctx)
+          scala.util.matching.Regex.quoteReplacement(filled)
+        })
+        opts.put("base", resolved)
+      case _ =>
+    }
+
     // Resolve the feature add-order: an explicit list order (above) wins;
     // otherwise order the map test-first, then the remaining names sorted, so
     // the outcome is deterministic and `test` is always the base transport.
@@ -403,19 +483,28 @@ object MakeOptions {
 
   // A feature's name is not a field name: a feature called `secrets` does not
   // make every one of its options a secret. Entity blocks (entity settings,
-  // seeded records) hold no credential.
+  // seeded records) hold no credential, and nor do rbac's rules, keyed by
+  // entity and operation names.
   private def addSensitiveOptions(cfg: CleanConfig, m: JMap[String, Object], keys: String*): Unit = {
     val top = omit(m, (keys :+ "feature" :+ "entity")*)
-    if (top.containsKey("test")) top.put("test", noEntity(top.get("test")))
+    if (top.containsKey("test")) top.put("test", plain(top.get("test"), null))
     Clean.addSensitiveWith(cfg, top)
     m.get("feature") match {
-      case fm: JMap[_, _] => fm.values().forEach(v => Clean.addSensitiveWith(cfg, noEntity(v.asInstanceOf[Object])))
-      case fl: JList[_] => fl.forEach(v => Clean.addSensitiveWith(cfg, noEntity(v.asInstanceOf[Object])))
+      case fm: JMap[_, _] =>
+        fm.asInstanceOf[JMap[Object, Object]].forEach((k, v) => Clean.addSensitiveWith(cfg, plain(v, String.valueOf(k))))
+      case fl: JList[_] => fl.forEach { v =>
+        val name = v match {
+          case vm: JMap[_, _] => vm.get("name") match { case s: String => s; case _ => null }
+          case _ => null
+        }
+        Clean.addSensitiveWith(cfg, plain(v.asInstanceOf[Object], name))
+      }
       case other => Clean.addSensitiveWith(cfg, other)
     }
   }
 
-  private def noEntity(block: Object): Object = block match {
+  private def plain(block: Object, name: String): Object = block match {
+    case bm: JMap[_, _] if "rbac" == name => omit(bm.asInstanceOf[JMap[String, Object]], "entity", "rules")
     case bm: JMap[_, _] => omit(bm.asInstanceOf[JMap[String, Object]], "entity")
     case other => other
   }
@@ -445,10 +534,7 @@ object MakeFetchDef {
     fetchdef.put("headers", spec.headers)
 
     if (spec.body != null) {
-      spec.body match {
-        case _: JMap[_, _] => fetchdef.put("body", Struct.jsonify(spec.body))
-        case _ => fetchdef.put("body", spec.body)
-      }
+      fetchdef.put("body", Media.requestBody(ctx.point, spec.body))
     }
 
     fetchdef
@@ -603,6 +689,10 @@ object MakeUrl {
 
     val resmatch = new LinkedHashMap[String, Object]()
 
+    // Sent with the request, never recorded as the entity's match.
+    val authquery: JList[String] =
+      if (spec.authquery == null) new java.util.ArrayList[String]() else spec.authquery
+
     val pit = Struct.items(spec.params).iterator()
     while (pit.hasNext) {
       val item = pit.next()
@@ -615,6 +705,14 @@ object 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.
+    val base = if (null == spec.base) "" else spec.base.replaceAll("/+$", "")
+    val unfilled = "\\{[^{}/]+\\}".r.findAllIn(url.stripPrefix(base)).toList
+    if (unfilled.nonEmpty) {
+      throw ctx.makeError("url_param_missing", "URL path has no value for " + unfilled.mkString(", ") + ".")
+    }
+
     var qsep = "?"
     val qit = Struct.items(spec.query).iterator()
     while (qit.hasNext) {
@@ -624,7 +722,7 @@ object MakeUrl {
       if (v != null) {
         url += qsep + Struct.escurl(key) + "=" + Struct.escurl(Struct.stringify(v))
         qsep = "&"
-        resmatch.put(key, v)
+        if (!authquery.contains(key)) resmatch.put(key, v)
       }
     }
 

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

@@ -35,8 +35,9 @@ object MakeSpec {
 
     ctx.spec.method = utility.prepareMethod(ctx)
 
-    val allowMethod = Struct.getpath(options, java.util.List.of("allow", "method")) match { case s: String => s; case _ => "" }
-    if (!allowMethod.contains(ctx.spec.method)) {
+    val allowMethodRaw = Struct.getpath(options, java.util.List.of("allow", "method"))
+    val allowMethod = allowMethodRaw match { case s: String => s; case _ => "" }
+    if (!Helpers.allowed(allowMethodRaw, ctx.spec.method)) {
       throw ctx.makeError("spec_method_allow",
         "Method \"" + ctx.spec.method + "\" not allowed by SDK option allow.method value: \"" + allowMethod + "\"")
     }
@@ -69,7 +70,24 @@ object MakeSpec {
 
     if (ctx.ctrl.explain != null) ctx.ctrl.explain.put("spec", ctx.spec)
 
+    // Whatever prepareAuth sets in the query, under whichever name, is the
+    // credential; a key it leaves as it was is the caller's.
+    val query = new LinkedHashMap[String, Object]()
+    if (ctx.spec.query != null) query.putAll(ctx.spec.query)
+
     val spec = utility.prepareAuth(ctx)
+    val authquery = new java.util.ArrayList[String]()
+    if (spec.query != null) {
+      val qit = spec.query.entrySet().iterator()
+      while (qit.hasNext) {
+        val entry = qit.next()
+        if (!query.containsKey(entry.getKey) ||
+          !java.util.Objects.equals(query.get(entry.getKey), entry.getValue)) {
+          authquery.add(entry.getKey)
+        }
+      }
+    }
+    spec.authquery = authquery
     ctx.spec = spec
     spec
   }