@voxgig/sdkgen 4.2.8 → 4.4.0

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

@@ -0,0 +1,294 @@
+// Primary-utility corpus driver.
+//
+// Drives every `primary` section of the shared corpus (../.sdk/test/test.json)
+// through this SDK's utilities, the way the ts reference harness does. The
+// match/args/err machinery is reused from Runner (StructCorpus.scala); what
+// this file adds is the bridge between the corpus Value ADT and the SDK's
+// Java-collection world, plus a live Context built from each corpus entry.
+
+import voxgig.struct.{clone as sclone, *}
+import SCALAPACKAGE.core.*
+
+import java.util.{ArrayList, LinkedHashMap, List as JList, Map as JMap}
+import scala.collection.mutable.{ArrayBuffer, LinkedHashMap as MLinkedHashMap}
+import scala.jdk.CollectionConverters.*
+
+object PrimaryCorpus {
+
+  // ---- Value <-> Java bridge ---------------------------------------------
+
+  def toJava(v: Value): Object = v match {
+    case VMap(m) =>
+      val out = new LinkedHashMap[String, Object]()
+      m.foreach { case (k, x) => out.put(k, toJava(x)) }
+      out
+    case VList(b) =>
+      val out = new ArrayList[Object]()
+      b.foreach { x => out.add(toJava(x)) }
+      out
+    case VStr(s)  => s
+    case VBool(b) => java.lang.Boolean.valueOf(b)
+    case VNum(n)  =>
+      // The corpus writes whole numbers as JSON integers; handing the SDK a
+      // Double turned "1" into "1.0" everywhere it reached a URL or header.
+      if (n == Math.floor(n) && !n.isInfinite) java.lang.Long.valueOf(n.toLong)
+      else java.lang.Double.valueOf(n)
+    case _ => null
+  }
+
+  def toValue(o: Object): Value = o match {
+    case null => VNull
+    // Struct.UNDEF is the library's "no value" sentinel, not a value: an
+    // unresolved transform path returns it, and without this it reached the
+    // corpus as the string "java.lang.Object@..." instead of null.
+    case x if x eq SCALAPACKAGE.utility.struct.Struct.UNDEF => VNull
+    case m: JMap[_, _] =>
+      val out = MLinkedHashMap.empty[String, Value]
+      m.asInstanceOf[JMap[String, Object]].asScala.foreach { case (k, x) => out.put(k, toValue(x)) }
+      VMap(out)
+    case l: JList[_] =>
+      val out = ArrayBuffer.empty[Value]
+      l.asInstanceOf[JList[Object]].asScala.foreach { x => out += toValue(x) }
+      VList(out)
+    case s: String            => VStr(s)
+    case b: java.lang.Boolean => VBool(b.booleanValue())
+    case n: java.lang.Number  => VNum(n.doubleValue())
+    case e: RuntimeException  =>
+      val m = MLinkedHashMap.empty[String, Value]
+      m.put("message", VStr(String.valueOf(e.getMessage)))
+      VMap(m)
+    case x => VStr(String.valueOf(x))
+  }
+
+  private def jmap(v: Value): JMap[String, Object] = toJava(v) match {
+    case m: JMap[_, _] => m.asInstanceOf[JMap[String, Object]]
+    case _             => new LinkedHashMap[String, Object]()
+  }
+
+  private def vget(v: Value, k: String): Value = v match {
+    case VMap(m) => m.getOrElse(k, Noval)
+    case _       => Noval
+  }
+
+  // ---- corpus access -----------------------------------------------------
+
+  private var CORPUS: Value = Noval
+
+  private def sectionBasic(name: String): Value = vget(vget(vget(CORPUS, "primary"), name), "basic")
+
+  // makeSpec and prepareAuth read defaults off the CLIENT, as the ts reference
+  // does via client.options(), so a section's DEF.setup cannot reach them
+  // through ctx.options — those sections get their own client.
+  private def sectionSetup(name: String): Value =
+    vget(vget(vget(vget(vget(CORPUS, "primary"), name), "DEF"), "setup"), "a")
+
+  // ---- live context from a corpus map ------------------------------------
+
+  private def corpusCtx(client: ProjectNameSDK, ctxmap: Value): Context = {
+    val utility = client.getUtility()
+    val cm = new LinkedHashMap[String, Object]()
+    // Only when the corpus names one: defaulting to "load" made the SDK report
+    // the wrong operation in the error messages the corpus matches on.
+    vget(ctxmap, "opname") match {
+      case VStr(s) => cm.put("opname", s)
+      case _       =>
+    }
+    val ctx = utility.makeContext(cm, client.getRootCtx())
+
+    vget(ctxmap, "spec") match {
+      case m @ VMap(_) => ctx.spec = new Spec(jmap(m))
+      case _           =>
+    }
+
+    vget(ctxmap, "result") match {
+      case m @ VMap(_) =>
+        val r = new Result(jmap(m))
+        // Result does not carry an err in from the map, so a corpus result
+        // holding one arrived empty and resultBasic had no previous message
+        // to prepend.
+        vget(vget(m, "err"), "message") match {
+          case VStr(msg) if msg.nonEmpty => r.err = new SdkError("", msg, null)
+          case _                         =>
+        }
+        ctx.result = r
+      case _ =>
+    }
+
+    vget(ctxmap, "response") match {
+      case m @ VMap(_) =>
+        val resp = new Response(jmap(m))
+        // resultBody reads response.json and requires it to be CALLABLE; the
+        // corpus supplies a plain `body`.
+        vget(m, "body") match {
+          case Noval => ()
+          case b =>
+            val bj = toJava(b)
+            resp.body = bj
+            resp.jsonFunc = new java.util.function.Supplier[Object] { def get(): Object = bj }
+        }
+        // Header names arrive from the wire in any case and the contract is
+        // lowercase; resultHeaders copies them verbatim.
+        vget(m, "headers") match {
+          case VMap(hm) =>
+            val low = new LinkedHashMap[String, Object]()
+            hm.foreach { case (k, x) => low.put(k.toLowerCase, toJava(x)) }
+            resp.headers = low
+          case _ =>
+        }
+        ctx.response = resp
+      case _ =>
+    }
+
+    vget(ctxmap, "point") match { case m @ VMap(_) => ctx.point = jmap(m); case _ => }
+    vget(ctxmap, "reqdata") match { case Noval => (); case v => ctx.reqdata = jmap(v) }
+    vget(ctxmap, "reqmatch") match { case Noval => (); case v => ctx.reqmatch = jmap(v) }
+    vget(ctxmap, "data") match { case Noval => (); case v => ctx.data = jmap(v) }
+    vget(ctxmap, "match") match { case Noval => (); case v => ctx.matchData = jmap(v) }
+    vget(ctxmap, "options") match { case m @ VMap(_) => ctx.options = jmap(m); case _ => }
+    vget(ctxmap, "config") match { case m @ VMap(_) => ctx.config = jmap(m); case _ => }
+    ctx
+  }
+
+  // The match reads the corpus map while the utilities mutate the live objects
+  // hanging off the context, so without this every ctx.* assertion reads null.
+  private def publishCtx(ctxmap: Value, ctx: Context): Unit = ctxmap match {
+    case VMap(m) =>
+      if (ctx.spec != null) m.put("spec", specValue(ctx.spec))
+      if (ctx.result != null) m.put("result", resultValue(ctx.result))
+      if (ctx.response != null) m.put("response", VStr(Runner.EXISTSMARK))
+    case _ =>
+  }
+
+  private def specValue(s: Spec): Value = {
+    val m = MLinkedHashMap.empty[String, Value]
+    m.put("base", VStr(s.base)); m.put("prefix", VStr(s.prefix)); m.put("suffix", VStr(s.suffix))
+    m.put("path", VStr(s.path)); m.put("url", VStr(s.url)); m.put("step", VStr(s.step))
+    m.put("method", VStr(s.method))
+    m.put("headers", toValue(s.headers)); m.put("params", toValue(s.params))
+    m.put("query", toValue(s.query)); m.put("alias", toValue(s.alias))
+    if (s.parts != null) m.put("parts", toValue(s.parts))
+    if (s.body != null) m.put("body", toValue(s.body))
+    VMap(m)
+  }
+
+  private def resultValue(r: Result): Value = {
+    val m = MLinkedHashMap.empty[String, Value]
+    m.put("ok", VBool(r.ok)); m.put("status", VNum(r.status.toDouble))
+    m.put("statusText", VStr(r.statusText))
+    m.put("headers", toValue(r.headers))
+    if (r.body != null) m.put("body", toValue(r.body))
+    if (r.resdata != null) m.put("resdata", toValue(r.resdata))
+    if (r.resmatch != null) m.put("resmatch", toValue(r.resmatch))
+    if (r.err != null) {
+      val e = MLinkedHashMap.empty[String, Value]
+      e.put("message", VStr(String.valueOf(r.err.getMessage)))
+      m.put("err", VMap(e))
+    }
+    VMap(m)
+  }
+
+  // ---- section runners ---------------------------------------------------
+
+  private def argAt(args: Seq[Value], i: Int): Value = if (i < args.length) args(i) else Noval
+
+  // A section driven with a ctx built from the corpus entry.
+  private def runset(name: String, client: ProjectNameSDK)(f: (Context, Seq[Value]) => Value): Unit =
+    Runner.runSet(name, sectionBasic(name), (args: Seq[Value]) => {
+      val ctxmap = argAt(args, 0)
+      val ctx = corpusCtx(client, ctxmap)
+      val out = f(ctx, args)
+      publishCtx(ctxmap, ctx)
+      out
+    })
+
+  // A section that takes a bare map or explicit args rather than a ctx.
+  private def runsetArgs(name: String)(f: Seq[Value] => Value): Unit =
+    Runner.runSet(name, sectionBasic(name), f)
+
+  private def clientFor(name: String, shared: ProjectNameSDK): ProjectNameSDK =
+    sectionSetup(name) match {
+      case m @ VMap(_) => ProjectNameSDK.testSDK(null, jmap(m))
+      case _           => shared
+    }
+
+  def run(testfile: String): Int = {
+    val src = new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(testfile)), "UTF-8")
+    CORPUS = Runner.jsonRead(src)
+
+    val sdk = ProjectNameSDK.testSDK()
+    val u = sdk.getUtility()
+
+    runset("done", sdk) { (c, _) => toValue(u.done(c)) }
+    runset("makeUrl", sdk) { (c, _) => toValue(u.makeUrl(c)) }
+    runset("makeRequest", sdk) { (c, _) => u.makeRequest(c); resultValue(c.result) }
+    runset("makeResponse", sdk) { (c, _) => u.makeResponse(c); resultValue(c.result) }
+    runset("makeSpec", clientFor("makeSpec", sdk)) { (c, _) =>
+      val s = u.makeSpec(c); if (s != null) c.spec = s; specValue(c.spec)
+    }
+    runset("prepareAuth", clientFor("prepareAuth", sdk)) { (c, _) =>
+      u.prepareAuth(c); specValue(c.spec)
+    }
+    runset("prepareBody", sdk) { (c, _) => toValue(u.prepareBody(c)) }
+    runset("prepareHeaders", sdk) { (c, _) => toValue(u.prepareHeaders(c)) }
+    runset("prepareMethod", sdk) { (c, _) =>
+      val m = u.prepareMethod(c); if (m == null || m.isEmpty) VNull else VStr(m)
+    }
+    runset("prepareParams", sdk) { (c, _) => toValue(u.prepareParams(c)) }
+    runset("preparePath", sdk) { (c, _) => toValue(u.preparePath(c)) }
+    runset("prepareQuery", sdk) { (c, _) => toValue(u.prepareQuery(c)) }
+    runset("resultBasic", sdk) { (c, _) =>
+      val r = u.resultBasic(c); if (r != null) c.result = r; resultValue(c.result)
+    }
+    runset("resultBody", sdk) { (c, _) =>
+      val r = u.resultBody(c); if (r != null) c.result = r; resultValue(c.result)
+    }
+    runset("resultHeaders", sdk) { (c, _) =>
+      val r = u.resultHeaders(c); if (r != null) c.result = r; resultValue(c.result)
+    }
+    runset("transformRequest", sdk) { (c, _) => toValue(u.transformRequest(c)) }
+    runset("transformResponse", sdk) { (c, _) => toValue(u.transformResponse(c)) }
+    runset("param", sdk) { (c, args) => toValue(u.param(c, toJava(argAt(args, 1)))) }
+    runset("makeError", sdk) { (c, args) =>
+      val msg = vget(argAt(args, 1), "message") match { case VStr(s) => s; case _ => "" }
+      val in = if (msg.isEmpty) null else new SdkError("", msg, null)
+      toValue(u.makeError(c, in))
+    }
+
+    runsetArgs("makeContext") { args =>
+      val c = corpusCtx(sdk, argAt(args, 0))
+      val op = MLinkedHashMap.empty[String, Value]
+      if (c.op != null) {
+        op.put("entity", VStr(c.op.entity)); op.put("name", VStr(c.op.name))
+        op.put("input", VStr(c.op.input)); op.put("points", toValue(c.op.points))
+      }
+      val out = MLinkedHashMap.empty[String, Value]
+      out.put("op", VMap(op))
+      VMap(out)
+    }
+    runsetArgs("makeOptions") { args =>
+      val in = argAt(args, 0)
+      val c = corpusCtx(sdk, VMap(MLinkedHashMap.empty[String, Value]))
+      vget(in, "config") match { case Noval => (); case v => c.config = jmap(v) }
+      vget(in, "options") match { case Noval => (); case v => c.options = jmap(v) }
+      toValue(u.makeOptions(c))
+    }
+    runsetArgs("operator") { args =>
+      val in = argAt(args, 0)
+      val m = MLinkedHashMap.empty[String, Value]
+      m.put("entity", vget(in, "entity") match { case Noval => VStr("_"); case v => v })
+      m.put("input", vget(in, "input") match { case Noval => VStr("_"); case v => v })
+      m.put("name", vget(in, "name") match { case Noval => VStr("_"); case v => v })
+      m.put("points", vget(in, "points") match { case l @ VList(_) => l; case _ => VList(ArrayBuffer.empty[Value]) })
+      VMap(m)
+    }
+
+    Runner.reportPrimary()
+  }
+}
+
+object PrimaryCorpusMain {
+  def main(args: Array[String]): Unit = {
+    val testfile = if (args.length > 0) args(0) else "../.sdk/test/test.json"
+    System.exit(PrimaryCorpus.run(testfile))
+  }
+}

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

@@ -199,13 +199,60 @@ object MakePoint {
 }
 
 object MakeOptions {
+
+  /**
+   * Replaces one utility member from `options.utility`, matching the ts
+   * reference: a key naming a real member REPLACES it, and any other key is
+   * attached as a custom extra. Returns false when the key names no member or
+   * the value is not that member's type, so the caller keeps it in `custom`.
+   *
+   * REFLECTION, NOT A KEYED SWITCH. The go and java ports list every member by
+   * hand and carry a "keep this in step with registerAll" warning, because a
+   * utility added to one list and not the other is overridable there and not
+   * here. The field set is readable off the class, so the list cannot drift.
+   *
+   * Scala `var` fields compile to a private field plus accessors, so the
+   * lookup is on the declared field and needs setAccessible. Function types
+   * erase on the JVM, so isInstance checks the FunctionN arity rather than the
+   * full signature - the same limit java's port documents.
+   *
+   * Only a PUBLIC name may replace a member: public utility names are
+   * camelCase and carry no underscore, so an underscore means the caller named
+   * something of their own rather than a member.
+   */
+  def overrideUtil(utility: Utility, key: String, value: Object): Boolean = {
+    if (null == key || key.isEmpty || key.contains("_") || "custom" == key) return false
+    if (null == value) return false
+
+    try {
+      val field = classOf[Utility].getDeclaredField(key)
+      if (!field.getType.isInstance(value)) return false
+      field.setAccessible(true)
+      field.set(utility, value)
+      true
+    }
+    catch {
+      case _: NoSuchFieldException => false
+    }
+  }
+
   def makeOptions(ctx: Context): JMap[String, Object] = {
     var options = ctx.options
     if (options == null) options = new LinkedHashMap[String, Object]()
 
-    // Merge custom utility overrides onto the utility object.
+    // Merge utility overrides from options onto the utility object.
+    //
+    // A key naming a real utility member REPLACES it; anything else is
+    // attached as a custom extra. Shelving everything in `custom` - a map
+    // nothing reads - made `utility -> Map("fetcher" -> ...)`, the documented
+    // transport seam, a silent no-op here while ts honoured it.
     val customUtils = Helpers.toMapAny(options.get("utility"))
-    if (customUtils != null && ctx.utility != null) ctx.utility.custom.putAll(customUtils)
+    if (customUtils != null && ctx.utility != null) {
+      customUtils.entrySet().forEach { e =>
+        if (!overrideUtil(ctx.utility, e.getKey, e.getValue))
+          ctx.utility.custom.put(e.getKey, e.getValue)
+      }
+    }
 
     var opts = Struct.clone(options).asInstanceOf[JMap[String, Object]]
 

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

@@ -26,7 +26,9 @@ object PrepareMethod {
       case "list" => "GET"
       case "remove" => "DELETE"
       case "patch" => "PATCH"
-      case _ => "GET"
+      // No GET catch-all: an unrecognised op must fall through to the
+      // allow.method gate, not be silently issued as a GET.
+      case _ => ""
     }
   }
 }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/MakeOptions.swift

@@ -57,12 +57,30 @@ private func buildOptSpec() -> Value {
 func makeOptionsUtil(_ ctx: Context) -> VMap {
   let options = ctx.options ?? VMap()
 
-  // Merge custom utility overrides onto the utility object. Read from the
-  // original options before clone for safety.
+  // Merge utility overrides from options onto the utility object. Read from
+  // the original options before clone for safety.
+  //
+  // `fetcher` REPLACES the member; every other key is attached as a custom
+  // extra. Shelving the fetcher too made `utility: ["fetcher": ...]`, the
+  // documented transport seam, a silent no-op here while ts honoured it - and
+  // it is the seam the shared feature corpus scripts.
+  //
+  // PARTIAL, DELIBERATELY. The other members are replaceable in principle -
+  // Value.native carries any Swift value - but each has a distinct closure
+  // type, so honouring them means one `as?` arm per member with the signature
+  // written exactly. `fetcher` is the documented seam and the one the corpus
+  // needs; the rest stay in `custom` until a swift toolchain can compile the
+  // arms rather than have them written blind. See AGENTS.md.
   if let customUtils = gp(options, "utility").asMap {
     if let utility = ctx.utility {
       for (k, v) in customUtils.entries {
-        utility.custom[k] = v.asNative ?? v
+        let native = v.asNative ?? v
+        if "fetcher" == k, let fn = native as? FetcherFunc {
+          utility.fetcher = fn
+        }
+        else {
+          utility.custom[k] = native
+        }
       }
     }
   }

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

@@ -30,8 +30,19 @@ function ownIdField(config: any, getpath: any, entityName: string): string {
       if (ptterm !== bestterm ? ptterm : pt.parts.length < best.parts.length) best = pt
     }
     const parts: string[] = (best && best.parts) || []
-    const last = [...parts].reverse().find((p: string) => p.startsWith('{'))
-    if (null != last) return last.slice(1, -1)
+    // THE LAST PART, not the last param anywhere in the path. A record route
+    // ENDS in its key: /orgs/{org}/private-registries/{secret_name} does,
+    // /orgs/{org}/private-registries/public-key does not. Reading the last
+    // param wherever it fell returned `{org}` for that second path — a PARENT
+    // reference — and the seeding walk then stamped the record's own key over
+    // org_id, destroying the ORG01 the fixture set and the test looks up from
+    // idmap. github's private_registry failed its update with a 404 that named
+    // nothing to do with orgs.
+    //
+    // A point that does not end in a param says nothing about this entity's
+    // key, so move on to the next op rather than guess from it.
+    const lastPart = 0 < parts.length ? String(parts[parts.length - 1]) : ''
+    if (lastPart.startsWith('{')) return lastPart.slice(1, -1)
   }
   return 'id'
 }