@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -0,0 +1,96 @@
+package SCALAPACKAGE.utility
+
+import java.util.{ArrayList, List => JList, Locale, Map => JMap}
+import SCALAPACKAGE.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.
+object Media {
+
+  // The data key holding a raw request body. Like `$action`, it can never be
+  // a declared argument name.
+  val RawBody: String = "$body"
+
+  def isJsonMedia(media: Object): Boolean = {
+    val m = (media match { case s: String => s; case _ => "" })
+      .split(";", 2)(0).trim.toLowerCase(Locale.ROOT)
+    m == "application/json" || m == "text/json" || 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.
+  def acceptOf(point: Object): String = {
+    val res = Struct.getprop(point, "response")
+    Struct.getprop(res, "media") match {
+      case media: String if media.nonEmpty =>
+        if ("json" == Struct.getprop(res, "kind")) media
+        else {
+          val types = new ArrayList[String]()
+          types.add(media)
+          Struct.getprop(res, "alternatives") match {
+            case alts: JList[_] =>
+              alts.forEach { alt =>
+                Struct.getprop(alt, "media") match {
+                  case m: String if m.nonEmpty => types.add(m)
+                  case _ =>
+                }
+              }
+            case _ =>
+          }
+          String.join(", ", types)
+        }
+      case _ => null
+    }
+  }
+
+  def isRawRequest(point: Object): Boolean =
+    "raw" == Struct.getprop(Struct.getprop(point, "body"), "kind")
+
+  def isJsonRequest(point: Object): Boolean =
+    "json" == 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.
+  def requestBody(point: Object, body: Object): Object = body match {
+    case _: Array[Byte] | _: java.io.InputStream => body
+    case _ if Struct.isnode(body) || isJsonRequest(point) => Struct.jsonify(body)
+    case _ => body
+  }
+
+  private def hasHeader(headers: JMap[String, Object], name: String): Boolean =
+    headers.keySet().stream().anyMatch(k => k != null && k.toLowerCase(Locale.ROOT) == 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.
+  def headers(point: Object, headers: JMap[String, Object]): JMap[String, Object] = {
+    val accept = acceptOf(point)
+    if (accept != null && !hasHeader(headers, "accept")) {
+      headers.put("accept", accept)
+    }
+
+    val body = Struct.getprop(point, "body")
+    val kind = Struct.getprop(body, "kind")
+    Struct.getprop(body, "media") match {
+      case media: String if media.nonEmpty && ("raw" == kind || "json" == kind) =>
+        headers.entrySet().removeIf(e => e.getKey != null &&
+          e.getKey.toLowerCase(Locale.ROOT) == "content-type" && isJsonMedia(e.getValue))
+        if (!hasHeader(headers, "content-type")) {
+          headers.put("content-type", media)
+        }
+      case _ =>
+    }
+
+    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.
+  def rawBody(reqdata: JMap[String, Object]): Object = {
+    val body = if (reqdata == null) null else reqdata.get(RawBody)
+    body match {
+      case stream: java.io.InputStream => stream.readAllBytes()
+      case other => other
+    }
+  }
+}

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

@@ -383,39 +383,72 @@ object Done {
 
 object Param {
   def param(ctx: Context, paramdef: Object): Object = {
-    val point = ctx.point
-    val spec = ctx.spec
-    val matchData = ctx.matchData
-    val reqmatch = ctx.reqmatch
-    val data = ctx.data
-    val reqdata = ctx.reqdata
-
     val pt = Struct.typify(paramdef)
 
     val key: String =
       if (0 < (Struct.T_string & pt)) paramdef match { case s: String => s; case _ => "" }
       else Struct.getprop(paramdef, "name") match { case s: String => s; case _ => "" }
 
-    var akey = ""
-    if (point != null) {
-      val alias = Helpers.toMapAny(Struct.getprop(point, "alias"))
-      if (alias != null) {
-        Struct.getprop(alias, key) match { case ak: String => akey = ak; case _ => }
-      }
+    val akey = alias(ctx.point, key)
+    if (ctx.spec != null && "" != akey &&
+      Struct.getprop(ctx.reqmatch, key, null) == null && Struct.getprop(ctx.matchData, key, null) == null) {
+      ctx.spec.alias.put(akey, key)
     }
 
-    var v = Struct.getprop(reqmatch, key, null)
-    if (v == null) v = Struct.getprop(matchData, key, null)
-    if (v == null && "" != akey) {
-      if (spec != null) spec.alias.put(akey, key)
-      v = Struct.getprop(reqmatch, akey, null)
-    }
-    if (v == null) v = Struct.getprop(reqdata, key, null)
-    if (v == null) v = Struct.getprop(data, key, null)
+    value(ctx, ctx.point, key)
+  }
+
+  // The name a point gives a parameter in the call, if it renames it.
+  private def alias(point: Object, key: String): String = {
+    if (point == null) return ""
+    val aliasMap = Helpers.toMapAny(Struct.getprop(point, "alias"))
+    if (aliasMap == null) return ""
+    Struct.getprop(aliasMap, key) match { case ak: String => ak; case _ => "" }
+  }
+
+  // The value the call or its entity gives a point's parameter, under its
+  // name or the point's alias for it.
+  def value(ctx: Context, point: Object, key: String): Object = {
+    val akey = alias(point, key)
+
+    var v = Struct.getprop(ctx.reqmatch, key, null)
+    if (v == null) v = Struct.getprop(ctx.matchData, key, null)
+    if (v == null && "" != akey) v = Struct.getprop(ctx.reqmatch, akey, null)
+    if (v == null) v = Struct.getprop(ctx.reqdata, key, null)
+    if (v == null) v = Struct.getprop(ctx.data, key, null)
     if (v == null && "" != akey) {
-      v = Struct.getprop(reqdata, akey, null)
-      if (v == null) v = Struct.getprop(data, akey, null)
+      v = Struct.getprop(ctx.reqdata, akey, null)
+      if (v == null) v = Struct.getprop(ctx.data, akey, null)
     }
     v
   }
+
+  // The arguments a point declares in one location, query or header, each as
+  // (name, wire, value): 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.
+  def callArgs(ctx: Context, kind: String): Seq[(String, String, Object)] = {
+    if (ctx.point == null) return Seq.empty
+    Struct.getpath(ctx.point, java.util.List.of("args", kind)) match {
+      case l: JList[_] =>
+        val out = scala.collection.mutable.ArrayBuffer[(String, String, Object)]()
+        val it = l.iterator()
+        while (it.hasNext) {
+          val ad = it.next()
+          Struct.getprop(ad, "name") match {
+            case name: String if name.nonEmpty =>
+              val wire = Struct.getprop(ad, "orig") match {
+                case o: String if o.nonEmpty => o
+                case _ => name
+              }
+              var v: Object = if (ctx.reqmatch == null) null else Struct.getprop(ctx.reqmatch, name, null)
+              if (v == null && ctx.reqdata != null) v = Struct.getprop(ctx.reqdata, name, null)
+              out += ((name, wire, v))
+            case _ =>
+          }
+        }
+        out.toSeq
+      case _ => Seq.empty
+    }
+  }
 }

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

@@ -18,7 +18,7 @@ object PrepareMethod {
   // exposes `update` as POST or PATCH, not the PUT the op name implies.
   // Only fall back to the op-name convention when the point has no method.
   def prepareMethod(ctx: Context): String = Struct.getprop(ctx.point, "method") match {
-    case s: String if s.nonEmpty => s.toUpperCase
+    case s: String if s.nonEmpty => s.toUpperCase(java.util.Locale.ROOT)
     case _ => ctx.op.name match {
       case "create" => "POST"
       case "update" => "PUT"
@@ -80,12 +80,18 @@ object PrepareQuery {
           }
         case _ =>
       }
-      // A header parameter travels in the headers, which prepareHeaders fills.
-      Struct.getpath(point, java.util.List.of("args", "header")) match {
+      // A header or cookie name leaves the query unless a query parameter shares it: then both are sent.
+      val declared = new ArrayList[Object]()
+      Struct.getpath(point, java.util.List.of("args", "query")) match {
+        case l: JList[_] => val dit = l.iterator(); while (dit.hasNext) declared.add(Struct.getprop(dit.next(), "name"))
+        case _ =>
+      }
+      for (located <- Seq(Struct.getpath(point, java.util.List.of("args", "header")),
+        Struct.getpath(point, java.util.List.of("args", "cookie")))) located match {
         case l: JList[_] =>
           val hit = l.iterator()
           while (hit.hasNext) {
-            Struct.getprop(hit.next(), "name") match { case s: String => params.add(s); case _ => }
+            Struct.getprop(hit.next(), "name") match { case s: String if !declared.contains(s) => params.add(s); case _ => }
           }
         case _ =>
       }
@@ -117,6 +123,11 @@ object PrepareQuery {
       val v = item.get(1)
       if (v != null && "$action" != key && !containsStr(params, key)) out.put(wire.getOrDefault(key, key), v)
     }
+
+    // A create or update passes its query arguments in its data.
+    for ((name, orig, v) <- Param.callArgs(ctx, "query") if v != null && !containsStr(params, name)) {
+      out.put(orig, v)
+    }
     out
   }
 
@@ -134,44 +145,86 @@ object PrepareHeaders {
     val options = ctx.client.optionsMap()
     val headers = Struct.getprop(options, "headers")
     val cloned = if (headers == null) null else Helpers.toMapAny(Struct.clone(headers))
-    val out: JMap[String, Object] = if (cloned != null) cloned else new LinkedHashMap[String, Object]()
+    val out: JMap[String, Object] = Media.headers(ctx.point,
+      if (cloned != null) cloned else new LinkedHashMap[String, Object]())
+
+    // A header argument replaces a default of the same name, whatever its case.
+    for ((_, wire, v) <- Param.callArgs(ctx, "header") if v != null) {
+      val key = wire.toLowerCase(java.util.Locale.ROOT)
+      out.keySet().removeIf(k => k != null && k.toLowerCase(java.util.Locale.ROOT) == key)
+      out.put(key, Struct.stringify(v))
+    }
 
-    // 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.
-    if (ctx.point != null) {
-      Struct.getpath(ctx.point, java.util.List.of("args", "header")) match {
-        case l: JList[_] =>
-          val hit = l.iterator()
-          while (hit.hasNext) {
-            val hd = hit.next()
-            Struct.getprop(hd, "name") match {
-              case name: String if name.nonEmpty =>
-                val wire = Struct.getprop(hd, "orig") match {
-                  case o: String if o.nonEmpty => o
-                  case _ => name
-                }
-                var v: Object = if (ctx.reqmatch == null) null else Struct.getprop(ctx.reqmatch, name, null)
-                if (v == null && ctx.reqdata != null) v = Struct.getprop(ctx.reqdata, name, null)
-                if (v != null) {
-                  val key = wire.toLowerCase(java.util.Locale.ROOT)
-                  out.keySet().removeIf(k => k != null && k.toLowerCase(java.util.Locale.ROOT) == key)
-                  out.put(key, Struct.stringify(v))
-                }
-              case _ =>
-            }
+    // 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.
+    val sent = Param.callArgs(ctx, "cookie").filter { case (_, _, v) => v != null }
+    if (sent.nonEmpty) {
+      val names = sent.flatMap { case (_, wire, v) =>
+        v match {
+          case m: JMap[_, _] => Struct.keysof(m).toArray(Array.empty[String]).toSeq.map(k => Struct.escurl(k))
+          case _ => Seq(wire)
+        }
+      }
+      val kept = scala.collection.mutable.ArrayBuffer[String]()
+      val it = out.entrySet().iterator()
+      while (it.hasNext) {
+        val e = it.next()
+        if (e.getKey != null && "cookie" == e.getKey.toLowerCase(java.util.Locale.ROOT)) {
+          e.getValue match {
+            case s: String => kept ++= cookieKeep(s, names)
+            case _ =>
           }
-        case _ =>
+          it.remove()
+        }
       }
+      sent.foreach { case (_, wire, v) =>
+        val pair = cookiePair(wire, v)
+        if (pair.nonEmpty) kept += pair
+      }
+      if (kept.nonEmpty) out.put("cookie", kept.mkString("; "))
     }
 
     out
   }
+
+  // The caller's cookie pieces with the named cookies removed: a cookie is one
+  // ;-delimited piece, whatever its value holds.
+  def cookieKeep(header: String, names: Seq[String]): scala.collection.mutable.ArrayBuffer[String] = {
+    val kept = scala.collection.mutable.ArrayBuffer[String]()
+    header.split(";").foreach { piece =>
+      val cookie = piece.trim
+      if (cookie.nonEmpty && !names.contains(cookie.split("=", 2)(0).trim)) kept += cookie
+    }
+    kept
+  }
+
+  // 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 def cookiePair(wire: String, v: Object): String = {
+    def esc(x: Object): String = Struct.escurl(Struct.stringify(x))
+    val pairs = scala.collection.mutable.ArrayBuffer[String]()
+    v match {
+      case l: JList[_] =>
+        val it = l.iterator()
+        while (it.hasNext) pairs += wire + "=" + esc(it.next().asInstanceOf[Object])
+      case m: JMap[_, _] =>
+        val keys = Struct.keysof(m).iterator()
+        while (keys.hasNext) {
+          val k = keys.next()
+          pairs += Struct.escurl(k) + "=" + esc(Struct.getprop(m, k))
+        }
+      case _ => pairs += wire + "=" + esc(v)
+    }
+    pairs.mkString("; ")
+  }
 }
 
 object PrepareBody {
   def prepareBody(ctx: Context): Object =
-    if ("data" == ctx.op.input) ctx.utility.transformRequest(ctx) else null
+    if ("data" != ctx.op.input) null
+    else if (Media.isRawRequest(ctx.point)) Media.rawBody(ctx.reqdata)
+    else ctx.utility.transformRequest(ctx)
 }
 
 // NO `object PrepareAuth` HERE, and its absence is the point.

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

@@ -38,6 +38,11 @@ object ResultBody {
       if (response != null && response.jsonFunc != null && response.body != null) {
         result.body = response.jsonFunc.get()
       }
+      if (response != null && response.unreadable) {
+        val sent = if (ctx.spec == null) null else ctx.spec.headers
+        result.err = Response.unreadableBody(ctx, result.status, result.headers, response.body,
+          sent, result.err)
+      }
     }
 
     result

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

@@ -8,7 +8,7 @@ object TransformRequest {
   def transformRequest(ctx: Context): Object = {
     if (ctx.spec != null) ctx.spec.step = "reqform"
 
-    val reqdata = omit(ctx.reqdata, headerArgNames(ctx))
+    val reqdata = omit(ctx.reqdata, routedArgNames(ctx))
 
     val transform = Helpers.toMapAny(Struct.getprop(ctx.point, "transform"))
     if (transform == null) return stripAction(reqdata)
@@ -26,25 +26,21 @@ object TransformRequest {
   // the body is a copy without it. The caller's map is left untouched.
   private def stripAction(reqdata: Object): Object = omit(reqdata, Seq("$action"))
 
-  // A header argument travels as a header, which PrepareHeaders sends, so the
-  // body is built from the request data without it.
-  private def headerArgNames(ctx: Context): Seq[String] = {
-    if (ctx.point == null) return Seq.empty
-    Struct.getpath(ctx.point, java.util.List.of("args", "header")) match {
-      case l: java.util.List[_] =>
-        val names = scala.collection.mutable.ArrayBuffer[String]()
-        val hit = l.iterator()
-        while (hit.hasNext) {
-          val hd = hit.next()
-          Struct.getprop(hd, "name") match {
-            case name: String if name.nonEmpty => names += name
-            case _ =>
-          }
-        }
-        names.toSeq
-      case _ => Seq.empty
+  // 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 def routedArgNames(ctx: Context): Seq[String] =
+    (Param.callArgs(ctx, "header") ++ Param.callArgs(ctx, "cookie") ++ Param.callArgs(ctx, "query")).map(_._1)
+      .filterNot(name => fieldArg(ctx, name))
+
+  private def fieldArg(ctx: Context, name: String): Boolean =
+    ctx.point != null && Seq("header", "cookie", "query").exists { kind =>
+      Struct.getpath(ctx.point, java.util.List.of("args", kind)) match {
+        case l: java.util.List[_] =>
+          l.toArray.exists(ad => name == Struct.getprop(ad, "name") && java.lang.Boolean.TRUE == Struct.getprop(ad, "field"))
+        case _ => false
+      }
     }
-  }
 
   private def omit(reqdata: Object, names: Seq[String]): Object = {
     reqdata match {

package/project/.sdk/tm/swift/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/swift/Sources/ProjectNameSDK/core/Context.swift

@@ -137,7 +137,7 @@ public final class Context {
     let store: Value = config == nil ? .noval : .map(config!)
     let opcfg = getpath(store, jtp("entity", entname, "op", opname))
 
-    let input = (opname == "update" || opname == "create") ? "data" : "match"
+    let input = (opname == "update" || opname == "create" || opname == "patch") ? "data" : "match"
 
     var points: VList = VList()
     if let ocm = opcfg.asMap, let tl = ocm.entries["points"]?.asList {
@@ -150,6 +150,8 @@ public final class Context {
     opm.entries["input"] = .string(input)
     opm.entries["points"] = .list(points)
 
+    // Each context holds its own copy of the cache, so a request racing
+    // another builds its own Operation, a read-only descriptor.
     let op = Operation(opm)
     opmap[cacheKey] = op
     return op

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Response.swift

@@ -9,6 +9,10 @@ public final class Response {
   public var jsonFunc: NativeCall0? = nil
   public var body: Value = .noval
   public var err: Error? = nil
+  // Set by a transport that could not read a non-blank body as JSON.
+  public var unreadable: Bool = false
+
+  private static let previewLength = 160
 
   public init(_ resmap: VMap?) {
     let m: Value = resmap == nil ? .map(VMap()) : .map(resmap!)
@@ -25,5 +29,58 @@ public final class Response {
     body = getprop(m, .string("body"))
 
     if let e = getprop(m, .string("err")).asNative as? Error { err = e }
+
+    unreadable = getprop(m, .string("unreadable")) == .bool(true)
+  }
+
+  // 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.
+  static func unreadableBody(
+    _ ctx: Context, _ status: Int, _ headers: Value, _ text: Value, _ sent: Value, _ failed: Error?
+  ) -> Error {
+    let type = headerValue(headers, "content-type")
+    let agent = clean(ctx, headerValue(sent, "user-agent"))
+    var detail = "HTTP \(status), content-type " + (type.isEmpty ? "none" : type)
+      + ", user-agent " + (agent.isEmpty ? "transport default" : agent)
+    if !isNil(text) {
+      detail += ", body: " + preview(ctx, text)
+    }
+
+    if let sdkErr = failed as? ProjectNameError {
+      sdkErr.message += " (\(detail))"
+      return sdkErr
+    }
+    if let other = failed {
+      return ctx.makeError("", "\(other) (\(detail))")
+    }
+    if type.isEmpty || type.lowercased().contains("json") {
+      return ctx.makeError("response_json_invalid", "response: body is not valid JSON (\(detail))")
+    }
+    return ctx.makeError("response_content_type", "response: expected JSON, got \(type) (\(detail))")
+  }
+
+  private static func headerValue(_ headers: Value, _ name: String) -> String {
+    guard let hm = headers.asMap else { return "" }
+    for (k, v) in hm.entries where k.lowercased() == name {
+      return v.asString ?? stringify(v)
+    }
+    return ""
+  }
+
+  private static func clean(_ ctx: Context, _ s: String) -> String {
+    guard let u = ctx.utility, let c = u.clean else { return s }
+    return c(ctx, .string(s)).asString ?? s
+  }
+
+  // Cleaned whole: a secret the bound would split could leave its prefix.
+  private static func preview(_ ctx: Context, _ text: Value) -> String {
+    let raw = text.asString ?? stringify(text)
+    let flat = clean(ctx, raw.split(whereSeparator: { $0.isWhitespace }).joined(separator: " "))
+    let scalars = flat.unicodeScalars
+    if scalars.count <= previewLength { return flat }
+    var out = String.UnicodeScalarView()
+    out.append(contentsOf: scalars.prefix(previewLength))
+    return String(out) + "..."
   }
 }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Spec.swift

@@ -16,6 +16,9 @@ public final class Spec {
   public var body: Value = .noval
   public var url: String = ""
   public var path: String = ""
+  // The query parameters prepareAuth placed: the credential, which the
+  // request sends and the entity's match leaves out.
+  public var authquery: [String] = []
 
   public init(_ specmap: VMap?) {
     guard let m = specmap else { return }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Support.swift

@@ -85,6 +85,14 @@ func gpath(_ m: VMap?, _ segs: String...) -> Value {
 }
 func gpath(_ v: Value, _ segs: String...) -> Value { getpath(v, jtpv(segs)) }
 
+// Whether a comma-separated allow option names the item: whole names, any case.
+func allowed(_ names: Value, _ item: String?) -> Bool {
+  guard let list = names.asString, let item = item, !item.isEmpty else { return false }
+  let want = item.uppercased()
+  return list.split(separator: ",", omittingEmptySubsequences: false)
+    .contains { $0.trimmingCharacters(in: .whitespacesAndNewlines).uppercased() == want }
+}
+
 // regexReplace replaces every match of `pattern` in `input` with the literal
 // `replacement` (template metacharacters in the replacement are escaped).
 func regexReplace(_ input: String, _ pattern: String, _ replacement: String) -> String {

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -5,6 +5,20 @@
 
 import Foundation
 
+// The key a list's response transform
+// ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+private func testItemEnvelopeKey(_ restf: Value?) -> String? {
+  guard case .list(let spec)? = restf, spec.items.count == 3,
+        case .string(let each) = spec.items[0], each == "`$EACH`",
+        case .string(let body) = spec.items[1], body == "body",
+        case .map(let child) = spec.items[2],
+        case .string(let merge)? = child.entries["`$MERGE`"],
+        merge.count > 3, merge.hasPrefix("`."), merge.hasSuffix("`") else { return nil }
+  let key = String(merge.dropFirst(2).dropLast(1))
+  guard !key.contains(where: { $0 == "." || $0 == "`" || $0 == "$" }) else { return nil }
+  return key
+}
+
 // THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
 // `transform.res: `body.item`` describes an API that answers {"item": {...}},
 // and the response transform unwraps that key on the way back. Returning the
@@ -15,6 +29,13 @@ private func testEnvelope(_ ctx: Context, _ data: Value) -> Value {
   if case .null = data { return data }
   guard let point = ctx.point else { return data }
   guard case .map(let tm)? = point.entries["transform"] else { return data }
+  if let key = testItemEnvelopeKey(tm.entries["res"]), case .list(let items) = data {
+    return .list(VList(items.items.map { item -> Value in
+      let wrapped = VMap()
+      wrapped.entries[key] = item
+      return .map(wrapped)
+    }))
+  }
   guard case .string(let spec)? = tm.entries["res"] else { return data }
   // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
   // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
@@ -58,6 +79,16 @@ private func testResolveMatch(_ ctx2: Context, _ explicitMatch: VMap) -> VMap {
   return VMap()
 }
 
+// The record the mock keeps: the request data without `$body`, which only the
+// wire carries.
+private func testRecord(_ reqdata: VMap) -> VMap {
+  let out = VMap()
+  for (k, v) in reqdata.entries where k != "$body" {
+    out.entries[k] = v
+  }
+  return out
+}
+
 private func testBuildArgs(_ ctx: Context, _ op: Operation, _ args: VMap?) -> Value {
   let opname = op.name
 
@@ -197,7 +228,7 @@ public final class TestFeature: BaseFeature {
           for item in fl.items { delprop(item, .string("$KEY")) }
         }
         return testRespond(ctx2, 200, clone(found), nil)
-      } else if op.name == "update" {
+      } else if op.name == "update" || op.name == "patch" {
         var updateMatch = VMap()
         if let idv = ctx2.reqdata.entries["id"] {
           updateMatch.entries["id"] = idv
@@ -219,7 +250,7 @@ public final class TestFeature: BaseFeature {
           return testRespond(ctx2, 404, .noval, extra)
         }
         if ent.isMap {
-          _ = merge(.list(VList([ent, .map(ctx2.reqdata)])))
+          _ = merge(.list(VList([ent, .map(testRecord(ctx2.reqdata))])))
         }
         delprop(ent, .string("$KEY"))
         return testRespond(ctx2, 200, clone(ent), nil)
@@ -241,7 +272,7 @@ public final class TestFeature: BaseFeature {
             Int.random(in: 0..<0x10000), Int.random(in: 0..<0x10000),
             Int.random(in: 0..<0x10000), Int.random(in: 0..<0x10000)))
         }
-        let ent = clone(.map(ctx2.reqdata))
+        let ent = clone(.map(testRecord(ctx2.reqdata)))
         if let entm = ent.asMap {
           entm.entries["id"] = id
           if let idStr = id.asString { entmap.entries[idStr] = .map(entm) }