@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -36,33 +36,87 @@ func preparePathUtil(_ ctx: Context) -> String {
   return join(.list(parts), "/", true)
 }
 
+// The arguments a point declares in one location, query or header, each with
+// 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.
+func callArgs(_ ctx: Context, _ kind: String) -> [(name: String, wire: String, val: Value)] {
+  var out: [(name: String, wire: String, val: Value)] = []
+  guard let defs = gpath(ctx.point, "args", kind).asList else { return out }
+  for ad in defs.items {
+    guard let name = gp(ad, "name").asString, !name.isEmpty else { continue }
+    let orig = gp(ad, "orig").asString ?? ""
+    var val = gp(ctx.reqmatch, name)
+    if isNil(val) { val = gp(ctx.reqdata, name) }
+    out.append((name: name, wire: orig.isEmpty ? name : orig, val: val))
+  }
+  return out
+}
+
 func prepareHeadersUtil(_ ctx: Context) -> VMap {
   let options = ctx.client!.optionsMap()
   let headers = gp(options, "headers")
-  let out = isNil(headers) ? VMap() : (clone(headers).asMap ?? VMap())
-
-  // 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 let ahl = gpath(ctx.point, "args", "header").asList {
-    for hd in ahl.items {
-      guard let name = gp(hd, "name").asString, !name.isEmpty else { continue }
-      let orig = gp(hd, "orig").asString ?? ""
-      let wire = orig.isEmpty ? name : orig
-      var val = gp(ctx.reqmatch, name)
-      if isNil(val) { val = gp(ctx.reqdata, name) }
-      if !isNil(val) {
-        let key = wire.lowercased()
-        for k in out.entries.keys where k.lowercased() == key {
-          _ = out.entries.removeValue(forKey: k)
-        }
-        out.entries[key] = .string(stringify(val))
-      }
+  let out = mediaHeaders(ctx.point, isNil(headers) ? VMap() : (clone(headers).asMap ?? VMap()))
+
+  // A header argument replaces a default of the same name, whatever its case.
+  for arg in callArgs(ctx, "header") where !isNil(arg.val) {
+    let key = arg.wire.lowercased()
+    for k in out.entries.keys where k.lowercased() == key {
+      _ = out.entries.removeValue(forKey: k)
+    }
+    out.entries[key] = .string(stringify(arg.val))
+  }
+
+  // A cookie argument travels in the cookie header, form serialized and
+  // percent-encoded, replacing a cookie of the same name among those the
+  // caller's headers already send.
+  let sent = callArgs(ctx, "cookie").filter { !isNil($0.val) }
+  if !sent.isEmpty {
+    let names = sent.flatMap { arg in
+      arg.val.asMap != nil ? keysof(arg.val).map { escurl(.string($0)) } : [arg.wire]
+    }
+    var kept: [String] = []
+    for k in out.entries.keys where k.lowercased() == "cookie" {
+      if let given = out.entries[k]?.asString { kept.append(contentsOf: cookieKeep(given, names)) }
+      _ = out.entries.removeValue(forKey: k)
     }
+    for arg in sent {
+      let pair = cookiePair(arg.wire, arg.val)
+      if !pair.isEmpty { kept.append(pair) }
+    }
+    if !kept.isEmpty { out.entries["cookie"] = .string(kept.joined(separator: "; ")) }
   }
   return out
 }
 
+// The form style of a cookie parameter: a list repeats the name, a map sends
+// its own keys, and every value is percent-encoded.
+private func cookiePair(_ wire: String, _ val: Value) -> String {
+  let esc = { (v: Value) in escurl(.string(stringify(v))) }
+  var pairs: [String] = []
+  if let items = val.asList?.items {
+    for item in items { pairs.append(wire + "=" + esc(item)) }
+  } else if let entries = val.asMap?.entries {
+    for key in keysof(val) { pairs.append(escurl(.string(key)) + "=" + esc(entries[key] ?? .null)) }
+  } else {
+    pairs.append(wire + "=" + esc(val))
+  }
+  return pairs.joined(separator: "; ")
+}
+
+// The caller's cookie pieces with the named cookies removed: a cookie is one
+// ;-delimited piece, whatever its value holds.
+func cookieKeep(_ header: String, _ names: [String]) -> [String] {
+  var kept: [String] = []
+  for piece in header.split(separator: ";", omittingEmptySubsequences: false) {
+    let cookie = piece.trimmingCharacters(in: .whitespaces)
+    let name = cookie.split(separator: "=", maxSplits: 1, omittingEmptySubsequences: false)
+      .first.map { $0.trimmingCharacters(in: .whitespaces) } ?? ""
+    if !cookie.isEmpty && !names.contains(name) { kept.append(cookie) }
+  }
+  return kept
+}
+
 func prepareParamsUtil(_ ctx: Context) -> VMap {
   let utility = ctx.utility!
   var paramdefs: VList = VList()
@@ -93,10 +147,21 @@ func prepareQueryUtil(_ ctx: Context) -> VMap {
       paramnames.append(gp(pd, "name"))
     }
   }
-  // A header parameter travels in the headers, which prepareHeaders fills.
-  if let ahl = gpath(ctx.point, "args", "header").asList {
-    for hd in ahl.items {
-      paramnames.append(gp(hd, "name"))
+  // A header or cookie parameter travels in the headers, which prepareHeaders
+  // fills, unless a query parameter shares its name: then both are sent.
+  var declared: [Value] = []
+  if let dql = gpath(ctx.point, "args", "query").asList {
+    for qd in dql.items {
+      declared.append(gp(qd, "name"))
+    }
+  }
+  for located in [gpath(ctx.point, "args", "header"), gpath(ctx.point, "args", "cookie")] {
+    guard let defs = located.asList else { continue }
+    for hd in defs.items {
+      let name = gp(hd, "name")
+      if let s = name.asString, !containsStr(declared, s) {
+        paramnames.append(name)
+      }
     }
   }
 
@@ -119,6 +184,11 @@ func prepareQueryUtil(_ ctx: Context) -> VMap {
       query.entries[wire[key] ?? key] = val
     }
   }
+
+  // A create or update passes its query arguments in its data.
+  for arg in callArgs(ctx, "query") where !isNil(arg.val) && !containsStr(paramnames, arg.name) {
+    query.entries[arg.wire] = arg.val
+  }
   return query
 }
 
@@ -129,6 +199,7 @@ private func containsStr(_ list: [Value], _ s: String) -> Bool {
 func prepareBodyUtil(_ ctx: Context) -> Value {
   let op = ctx.op!
   if op.input == "data" {
+    if isRawRequest(ctx.point) { return rawBodyOf(ctx.reqdata) }
     return ctx.utility!.transformRequest(ctx)
   }
   return .noval
@@ -152,16 +223,9 @@ func prepareBodyUtil(_ ctx: Context) -> Value {
 // SwiftPM target.
 //
 // The seven functions above and paramUtil below do not depend on the model,
-// so they stay templated.
+// so they stay templated, and so does the lookup it shares with makePoint.
 
 func paramUtil(_ ctx: Context, _ paramdef: Value) -> Value {
-  let point = ctx.point
-  let spec = ctx.spec
-  let match = ctx.match
-  let reqmatch = ctx.reqmatch
-  let data = ctx.data
-  let reqdata = ctx.reqdata
-
   let pt = typify(paramdef)
 
   let key: String
@@ -171,25 +235,36 @@ func paramUtil(_ ctx: Context, _ paramdef: Value) -> Value {
     key = gp(paramdef, "name").asString ?? ""
   }
 
-  var akey = ""
-  if let alias = gp(point, "alias").asMap, let ak = gp(alias, key).asString {
-    akey = ak
+  let akey = paramAlias(ctx.point, key)
+  if let sp = ctx.spec, akey != "", isNil(gp(ctx.reqmatch, key)), isNil(gp(ctx.match, key)) {
+    sp.alias.entries[akey] = .string(key)
   }
 
-  var val = gp(reqmatch, key)
-  if isNil(val) { val = gp(match, key) }
+  return paramValue(ctx, ctx.point, key)
+}
 
-  if isNil(val) && akey != "" {
-    if let sp = spec { sp.alias.entries[akey] = .string(key) }
-    val = gp(reqmatch, akey)
+// The name a point gives a parameter in the call, if it renames it.
+private func paramAlias(_ point: VMap?, _ key: String) -> String {
+  if let alias = gp(point, "alias").asMap, let ak = gp(alias, key).asString {
+    return ak
   }
+  return ""
+}
+
+// The value the call or its entity gives a point's parameter, under its name
+// or the point's alias for it.
+func paramValue(_ ctx: Context, _ point: VMap?, _ key: String) -> Value {
+  let akey = paramAlias(point, key)
 
-  if isNil(val) { val = gp(reqdata, key) }
-  if isNil(val) { val = gp(data, key) }
+  var val = gp(ctx.reqmatch, key)
+  if isNil(val) { val = gp(ctx.match, key) }
+  if isNil(val) && akey != "" { val = gp(ctx.reqmatch, akey) }
+  if isNil(val) { val = gp(ctx.reqdata, key) }
+  if isNil(val) { val = gp(ctx.data, key) }
 
   if isNil(val) && akey != "" {
-    val = gp(reqdata, akey)
-    if isNil(val) { val = gp(data, akey) }
+    val = gp(ctx.reqdata, akey)
+    if isNil(val) { val = gp(ctx.data, akey) }
   }
 
   return val

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

@@ -34,6 +34,11 @@ func resultBodyUtil(_ ctx: Context) -> Result {
     if let jf = response?.jsonFunc, let resp = response, !isNil(resp.body) {
       result.body = jf()
     }
+    if let resp = response, resp.unreadable {
+      let sent: Value = ctx.spec == nil ? .noval : .map(ctx.spec!.headers)
+      result.err = Response.unreadableBody(
+        ctx, result.status, .map(result.headers), resp.body, sent, result.err)
+    }
   }
 
   return result!
@@ -60,13 +65,18 @@ private func stripAction(_ reqdata: Value) -> Value {
   return omitKeys(reqdata, ["$action"])
 }
 
-// A header argument travels as a header, which prepareHeadersUtil sends, so
-// the body is built from the request data without it.
-private func headerArgNames(_ ctx: Context) -> [String] {
-  guard let ahl = gpath(ctx.point, "args", "header").asList else { return [] }
-  return ahl.items.compactMap { hd in
-    guard let name = gp(hd, "name").asString, !name.isEmpty else { return nil }
-    return name
+// A header, cookie or query argument travels where prepareHeadersUtil or
+// prepareQueryUtil 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 func routedArgNames(_ ctx: Context) -> [String] {
+  return (callArgs(ctx, "header") + callArgs(ctx, "cookie") + callArgs(ctx, "query")).map { $0.name }
+    .filter { !fieldArg(ctx, $0) }
+}
+
+private func fieldArg(_ ctx: Context, _ name: String) -> Bool {
+  return ["header", "cookie", "query"].contains { kind in
+    guard let defs = gpath(ctx.point, "args", kind).asList else { return false }
+    return defs.items.contains { gp($0, "name").asString == name && gp($0, "field").asBool == true }
   }
 }
 
@@ -84,7 +94,7 @@ private func omitKeys(_ reqdata: Value, _ names: [String]) -> Value {
 func transformRequestUtil(_ ctx: Context) -> Value {
   if let sp = ctx.spec { sp.step = "reqform" }
 
-  let reqdata = omitKeys(.map(ctx.reqdata), headerArgNames(ctx))
+  let reqdata = omitKeys(.map(ctx.reqdata), routedArgNames(ctx))
 
   guard let tfm = gp(ctx.point, "transform").asMap else { return stripAction(reqdata) }
   let reqform = gp(tfm, "req")
@@ -133,11 +143,43 @@ extension Utility {
   public final class CleanConfig {
     public var active = true
     public var keys: [String] = []
-    public var values: [String] = []
     public var mask = "[redacted]"
     public var hint = 0
     public var min = 4
+
+    // Requests on other threads clean while one registers, so the registry
+    // is read and written under its own lock.
+    private let lock = NSLock()
+    private var registry: [String] = []
+
+    public var values: [String] {
+      get {
+        lock.lock()
+        defer { lock.unlock() }
+        return registry
+      }
+      set {
+        lock.lock()
+        defer { lock.unlock() }
+        registry = newValue
+      }
+    }
+
     public init() {}
+
+    // The forms not yet registered are added, longest first, in one step.
+    func register(_ forms: [String]) {
+      lock.lock()
+      defer { lock.unlock() }
+      var changed = false
+      for form in forms where form.count >= min && !registry.contains(form) {
+        registry.append(form)
+        changed = true
+      }
+      if changed {
+        registry.sort { $0.count > $1.count }
+      }
+    }
   }
 }
 
@@ -218,16 +260,7 @@ private func cleanForms(_ value: String) -> [String] {
 func cleanAddUtil(_ ctx: Context, _ value: Value) {
   let cfg = cleanConfigOf(ctx)
   guard let s = value.asString, s.count >= cfg.min else { return }
-  var changed = false
-  for form in cleanForms(s) {
-    if form.count >= cfg.min && !cfg.values.contains(form) {
-      cfg.values.append(form)
-      changed = true
-    }
-  }
-  if changed {
-    cfg.values.sort { $0.count > $1.count }
-  }
+  cfg.register(cleanForms(s))
 }
 
 // Every scalar under a sensitive name, at any depth and of any shape: a

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/ConcurrencyTest.swift

@@ -0,0 +1,214 @@
+// Requests in flight at once on one client. Each registers and cleans
+// secrets through the one registry the client holds. A context keeps its own
+// copy of the operation cache, so requests share no cache to race on.
+
+import Foundation
+import XCTest
+
+@testable import ProjectNameSdk
+
+final class ConcurrencyTest: XCTestCase {
+  private static let rounds = 200
+  private static let width = 8
+  private static let ops = 32
+  private static let masked = "a [redacted] b [redacted] c"
+
+  // What the racing threads report, under one lock.
+  private final class Outcome {
+    private let lock = NSLock()
+    private var notes: [String] = []
+    private var left: Int
+
+    init(registering: Int) {
+      left = registering
+    }
+
+    func note(_ what: String) {
+      lock.lock()
+      defer { lock.unlock() }
+      notes.append(what)
+    }
+
+    var first: String? {
+      lock.lock()
+      defer { lock.unlock() }
+      return notes.first
+    }
+
+    func registered() {
+      lock.lock()
+      defer { lock.unlock() }
+      left -= 1
+    }
+
+    var registering: Bool {
+      lock.lock()
+      defer { lock.unlock() }
+      return 0 < left
+    }
+  }
+
+  // A live client whose transport answers at once.
+  private static func liveClient() -> ProjectNameSDK {
+    let fetcher: FetcherFunc = { _, _, _ in
+      let res = VMap()
+      res.entries["status"] = .int(200)
+      res.entries["statusText"] = .string("OK")
+      res.entries["headers"] = .map(VMap())
+      res.entries["json"] = .nat({ () -> Value in .map(vm(("ok", .bool(true)))) } as NativeCall0)
+      return .map(res)
+    }
+    return ProjectNameSDK(vm(
+      ("base", .string("http://concurrency.test/api")),
+      ("allow", .map(vm(("op", .string("direct"))))),
+      ("utility", .map(vm(("fetcher", .nat(fetcher)))))))
+  }
+
+  // Runs body on width threads, released once every one is waiting; a
+  // thread's error is noted.
+  private static func atOnce(_ outcome: Outcome, _ body: @escaping (Int) throws -> Void) {
+    let ready = DispatchSemaphore(value: 0)
+    let start = DispatchSemaphore(value: 0)
+    let done = DispatchGroup()
+    for n in 0..<width {
+      done.enter()
+      let thread = Thread {
+        ready.signal()
+        start.wait()
+        do {
+          try body(n)
+        } catch {
+          outcome.note("threw: \(error)")
+        }
+        done.leave()
+      }
+      thread.start()
+    }
+    for _ in 0..<width {
+      ready.wait()
+    }
+    for _ in 0..<width {
+      start.signal()
+    }
+    done.wait()
+  }
+
+  private static func addedSecret(_ round: Int, _ n: Int, _ k: Int) -> String {
+    return "ADDED-SECRET-\(round)-\(n)-\(k)"
+  }
+
+  // Registers thread n's secrets, then counts the thread out.
+  private static func registerSecrets(
+    _ utility: Utility, _ root: Context, _ round: Int, _ n: Int, _ outcome: Outcome
+  ) {
+    defer { outcome.registered() }
+    for k in 0..<ops {
+      utility.cleanAdd(root, .string(addedSecret(round, n, k)))
+    }
+  }
+
+  // The first secret registered in the round that a clean leaves raw.
+  private static func unmaskedSecret(_ utility: Utility, _ root: Context, _ round: Int) -> String? {
+    for n in 0..<(width / 2) {
+      for k in 0..<ops {
+        let added = addedSecret(round, n, k)
+        if utility.clean(root, .string(added)).asString != "[redacted]" {
+          return added
+        }
+      }
+    }
+    return nil
+  }
+
+  func testConcurrentFirstRequestsSucceed() {
+    for round in 0..<ConcurrencyTest.rounds {
+      // A fresh client each round, so every request in it is a first request.
+      let client = ConcurrencyTest.liveClient()
+      let outcome = Outcome(registering: 0)
+      ConcurrencyTest.atOnce(outcome) { n in
+        let res = client.direct(vm(("path", .string("p\(n)"))))
+        if gp(res, "ok") != .bool(true) {
+          outcome.note("request \(n) failed: \(stringify(.map(res)))")
+        }
+      }
+      if let first = outcome.first {
+        XCTFail("round \(round): \(first)")
+        return
+      }
+    }
+  }
+
+  // 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.
+  func testConcurrentRegistrationKeepsEverySecretMasked() {
+    let half = ConcurrencyTest.width / 2
+    let masked = ConcurrencyTest.masked
+    for round in 0..<(ConcurrencyTest.rounds / 4) {
+      let client = ConcurrencyTest.liveClient()
+      let utility = client.getUtility()
+      let root = client.getRootCtx()
+      let inner = "INNER-SECRET-\(round)"
+      utility.cleanAdd(root, .string(inner))
+      utility.cleanAdd(root, .string("OUTER-\(inner)-TAIL"))
+      let text = "a \(inner) b OUTER-\(inner)-TAIL c"
+      XCTAssertEqual(utility.clean(root, .string(text)).asString, masked, "round \(round)")
+
+      let outcome = Outcome(registering: half)
+      ConcurrencyTest.atOnce(outcome) { n in
+        if n < half {
+          ConcurrencyTest.registerSecrets(utility, root, round, n, outcome)
+          return
+        }
+        while outcome.registering {
+          let got = utility.clean(root, .string(text)).asString ?? ""
+          if got != masked {
+            outcome.note("cleaned to: \(got)")
+            return
+          }
+        }
+      }
+      if let first = outcome.first {
+        XCTFail("round \(round) \(first)")
+        return
+      }
+      if let raw = ConcurrencyTest.unmaskedSecret(utility, root, round) {
+        XCTFail("round \(round): \(raw) was registered but not masked")
+        return
+      }
+    }
+  }
+
+  // Requests on one client while secrets register on it: each request copies
+  // the client's options, the registry among them.
+  func testConcurrentRequestsSurviveRegistration() {
+    let half = ConcurrencyTest.width / 2
+    for round in 0..<(ConcurrencyTest.rounds / 4) {
+      let client = ConcurrencyTest.liveClient()
+      let utility = client.getUtility()
+      let root = client.getRootCtx()
+      let outcome = Outcome(registering: half)
+      ConcurrencyTest.atOnce(outcome) { n in
+        if n < half {
+          ConcurrencyTest.registerSecrets(utility, root, round, n, outcome)
+          return
+        }
+        while outcome.registering {
+          let res = client.direct(vm(("path", .string("p\(n)"))))
+          if gp(res, "ok") != .bool(true) {
+            outcome.note("a request failed: \(stringify(.map(res)))")
+            return
+          }
+        }
+      }
+      if let first = outcome.first {
+        XCTFail("round \(round) \(first)")
+        return
+      }
+      if let raw = ConcurrencyTest.unmaskedSecret(utility, root, round) {
+        XCTFail("round \(round): \(raw) was registered but not masked")
+        return
+      }
+    }
+  }
+}

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/FeatureTest.swift

@@ -66,7 +66,7 @@ final class FhHarness {
   private static func defaultMethod(_ op: String) -> String {
     switch op {
     case "create": return "POST"
-    case "update": return "PATCH"
+    case "update", "patch": return "PATCH"
     case "remove": return "DELETE"
     default: return "GET"
     }
@@ -428,6 +428,36 @@ final class FeatureTimeoutTest: XCTestCase {
     XCTAssertEqual(f.count, 1)
   }
 
+  // The deadline runs from the request's start, not from the wait: a response
+  // that arrives after it is a timeout even when the caller only looks once it
+  // is complete. The clock stands at the start for the caller and 300 ms later
+  // for the worker.
+  func testLateResponseTimesOutHoweverLateTheCallerLooks() {
+    if Fh.skipWithout("timeout") { return }
+    let f = TimeoutFeature()
+    let h = Fh.make(nil, (f, vm(("ms", .int(20)), ("now", .nat(workerClock(300))))))
+    let res = h.op(FhOpSpec(op: "load"))
+    XCTAssertEqual(Fh.errCode(res.err), "timeout")
+    XCTAssertEqual(f.count, 1)
+  }
+
+  // A transport failure after the deadline is a timeout too, not the failure.
+  func testLateFailureTimesOut() {
+    if Fh.skipWithout("timeout") { return }
+    let f = TimeoutFeature()
+    let failing: FetcherFunc = { ctx, _, _ in throw ctx.makeError("socket_closed", "socket closed") }
+    let h = Fh.make(failing, (f, vm(("ms", .int(20)), ("now", .nat(workerClock(300))))))
+    let res = h.op(FhOpSpec(op: "load"))
+    XCTAssertEqual(Fh.errCode(res.err), "timeout")
+    XCTAssertEqual(f.count, 1)
+  }
+
+  // A clock standing at 0 for the calling thread and at `later` for any other.
+  private func workerClock(_ later: Int64) -> () -> Int64 {
+    let caller = Thread.current
+    return { Thread.current == caller ? 0 : later }
+  }
+
   func testFastRequestPasses() {
     if Fh.skipWithout("timeout") { return }
     let h = Fh.make(nil, (TimeoutFeature(), vm(("ms", .int(1000)))))

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/PrimaryUtilityTest.swift

@@ -347,7 +347,10 @@ final class PrimaryUtilityTest: XCTestCase {
       return .map(r)
     }
 
+    // Concrete base: a live construction must satisfy any server variables a
+    // templated base URL declares; a literal base sidesteps the requirement.
     let opts = VMap()
+    opts.entries["base"] = .string("http://localhost:8080")
     opts.entries["system"] = .map(vm(("fetch", .nat(fetch))))
     let liveClient = ProjectNameSDK(opts)
     let liveUtility = liveClient.getUtility()
@@ -367,7 +370,10 @@ final class PrimaryUtilityTest: XCTestCase {
     // Create a live SDK then set mode to test (not using testSDK, which
     // installs the test feature).
     let fetch: SystemFetch = { _, _ in .map(VMap()) }
+    // Concrete base: a live construction must satisfy any server variables a
+    // templated base URL declares; a literal base sidesteps the requirement.
     let opts = VMap()
+    opts.entries["base"] = .string("http://localhost:8080")
     opts.entries["system"] = .map(vm(("fetch", .nat(fetch))))
     let blockedClient = ProjectNameSDK(opts)
     blockedClient.mode = "test"

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/ServerVariableTest.swift

@@ -0,0 +1,42 @@
+// A templated base URL takes each {name} from the `server` option. A missing
+// or empty value is an error; test mode fills in test-<name>. Construction
+// traps on that error, which XCTest cannot observe, so the error case calls
+// the resolver that construction uses.
+
+import XCTest
+
+@testable import ProjectNameSdk
+
+final class ServerVariableTest: XCTestCase {
+  // A variable no API declares, so the API's own server defaults cannot fill it.
+  let base = "https://api.example.test/bot{zzvar}"
+
+  func testAMissingOrEmptyValueIsAnError() {
+    for server in [VMap(), vm(("zzvar", .string("")))] {
+      let opts = vm(("base", .string(base)), ("server", .map(server)))
+      XCTAssertThrowsError(try resolveServerBase(base, opts, VMap(), nil)) { error in
+        let err = error as? ProjectNameError
+        XCTAssertEqual(err?.code, "server_var_required")
+        XCTAssertTrue(err?.message.contains("the server variable 'zzvar' is required") ?? false)
+        XCTAssertTrue(err?.message.contains(self.base) ?? false)
+      }
+    }
+  }
+
+  func testAServerValueFillsTheBase() {
+    let client = ProjectNameSDK(vm(
+      ("base", .string(base)), ("server", .map(vm(("zzvar", .string("T1")))))))
+    XCTAssertEqual(client.optionsMap().entries["base"], Value.string("https://api.example.test/botT1"))
+  }
+
+  func testTestModeFillsTheBase() {
+    let client = ProjectNameSDK(vm(
+      ("base", .string(base)), ("test", .map(vm(("active", .bool(true)))))))
+    XCTAssertEqual(client.optionsMap().entries["base"],
+      Value.string("https://api.example.test/bottest-zzvar"))
+
+    let mock = ProjectNameSDK.testSDK(nil, vm(("base", .string(base))))
+    XCTAssertEqual(mock.optionsMap().entries["base"],
+      Value.string("https://api.example.test/bottest-zzvar"))
+  }
+}

package/project/.sdk/tm/ts/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/ts/src/Context.ts

@@ -98,7 +98,7 @@ class Context {
       const opcfg = getpath(this.config, ['entity', entname, 'op', opname])
       let input = 'match'
 
-      if ('update' === opname || 'create' === opname) {
+      if ('update' === opname || 'create' === opname || 'patch' === opname) {
         input = 'data'
       }