@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/tm/rb/utility/make_fetch_def.rb

@@ -1,5 +1,5 @@
 # ProjectName SDK utility: make_fetch_def
-require_relative 'struct/voxgig_struct'
+require_relative 'media'
 require_relative '../core/result'
 module ProjectNameUtilities
   MakeFetchDef = ->(ctx) {
@@ -15,9 +15,7 @@ module ProjectNameUtilities
     spec.url = url
 
     fetchdef = { "url" => url, "method" => spec.method, "headers" => spec.headers }
-    if spec.body
-      fetchdef["body"] = spec.body.is_a?(Hash) ? VoxgigStruct.jsonify(spec.body) : spec.body
-    end
+    fetchdef["body"] = ProjectNameUtilities.request_body(ctx.point, spec.body) unless spec.body.nil?
 
     return fetchdef, nil
   }

package/project/.sdk/tm/rb/utility/make_point.rb

@@ -2,7 +2,20 @@
 require_relative 'struct/voxgig_struct'
 require_relative '../core/helpers'
 require_relative '../core/error'
+require_relative 'param'
+require_relative 'prepare_method'
 module ProjectNameUtilities
+  # The path parameters of a point that neither the call nor the entity gives
+  # a value for, looked up as prepare_params looks them up.
+  def self.unfilled_params(ctx, point)
+    parts = VoxgigStruct.getprop(point, "parts")
+    return [] unless parts.is_a?(Array)
+    parts.each_with_object([]) do |part, missing|
+      found = part.to_s.match(/\A\{([^{}\/]+)\}\z/)
+      missing << found[1] if found && param_value(ctx, point, found[1]).nil?
+    end
+  end
+
   MakePoint = ->(ctx) {
     if ctx.out["point"]
       preset = ctx.out["point"]
@@ -17,8 +30,8 @@ module ProjectNameUtilities
     op = ctx.op
     options = ctx.options
 
-    allow_op = VoxgigStruct.getpath(options, "allow.op") || ""
-    unless allow_op.include?(op.name)
+    allow_op = VoxgigStruct.getpath(options, "allow.op")
+    unless ProjectNameUtilities.allowed(allow_op, op.name)
       return nil, ctx.make_error("point_op_allow",
         "Operation \"#{op.name}\" not allowed by SDK option allow.op value: \"#{allow_op}\"")
     end
@@ -93,14 +106,37 @@ module ProjectNameUtilities
           parts = VoxgigStruct.getprop(p, "parts")
           parts.is_a?(Array) && parts.length > 0 && parts[-1].to_s.start_with?("{")
         }
-        point = op.points[0]
-        op.points.each do |p|
-          if terminal_param.call(p) != terminal_param.call(point)
-            point = p if terminal_param.call(p)
-          elsif parts_len.call(p) < parts_len.call(point)
-            point = p
+        own_point = ->(points) {
+          best = points[0]
+          points.each do |p|
+            if terminal_param.call(p) != terminal_param.call(best)
+              best = p if terminal_param.call(p)
+            elsif parts_len.call(p) < parts_len.call(best)
+              best = p
+            end
           end
+          best
+        }
+
+        # A call without an action falls back to a point without one, as
+        # generation does, and only to a route the call can fill.
+        plain = op.points.select { |p|
+          VoxgigStruct.getprop(ProjectNameHelpers.to_map(VoxgigStruct.getprop(p, "select")), "$action").nil?
+        }
+        if plain.empty?
+          return nil, ctx.make_error("point_action_required",
+            "Operation \"#{op.name}\" has only action endpoints; pass $action to choose one.")
         end
+
+        fillable = plain.select { |p| ProjectNameUtilities.unfilled_params(ctx, p).empty? }
+
+        if fillable.empty?
+          missing = ProjectNameUtilities.unfilled_params(ctx, own_point.call(plain)).join(", ")
+          return nil, ctx.make_error("point_no_match",
+            "Operation \"#{op.name}\" has no endpoint whose path parameters are all given (missing: #{missing}).")
+        end
+
+        point = own_point.call(fillable)
       end
 
       if reqselector

package/project/.sdk/tm/rb/utility/make_spec.rb

@@ -1,10 +1,14 @@
 # ProjectName SDK utility: make_spec
 require_relative 'struct/voxgig_struct'
 require_relative 'graphql'
+require_relative 'prepare_method'
 require_relative '../core/spec'
 module ProjectNameUtilities
   MakeSpec = ->(ctx) {
     if ctx.out["spec"]
+      # A PreSpec hook (validate) rejects the operation by placing its error
+      # here; the pipeline raises it, and ctx.spec stays a request spec.
+      return nil, ctx.out["spec"] if ctx.out["spec"].is_a?(Exception)
       ctx.spec = ctx.out["spec"]
       return ctx.spec, nil
     end
@@ -28,8 +32,8 @@ module ProjectNameUtilities
 
     ctx.spec.method = utility.prepare_method.call(ctx)
 
-    allow_method = VoxgigStruct.getpath(options, "allow.method") || ""
-    unless allow_method.include?(ctx.spec.method)
+    allow_method = VoxgigStruct.getpath(options, "allow.method")
+    unless ProjectNameUtilities.allowed(allow_method, ctx.spec.method)
       return nil, ctx.make_error("spec_method_allow",
         "Method \"#{ctx.spec.method}\" not allowed by SDK option allow.method value: \"#{allow_method}\"")
     end
@@ -57,9 +61,17 @@ module ProjectNameUtilities
 
     ctx.ctrl.explain["spec"] = ctx.spec if ctx.ctrl.explain
 
+    # Whatever prepare_auth sets in the query, under whichever name, is the
+    # credential; a key it leaves as it was is the caller's.
+    query = (ctx.spec.query || {}).dup
+
     spec, err = utility.prepare_auth.call(ctx)
     return nil, err if err
 
+    spec.authquery = (spec.query || {}).keys.select { |k|
+      !query.key?(k) || query[k] != spec.query[k]
+    }
+
     ctx.spec = spec
     return spec, nil
   }

package/project/.sdk/tm/rb/utility/make_url.rb

@@ -11,6 +11,9 @@ module ProjectNameUtilities
     url = VoxgigStruct.join([spec.base, spec.prefix, spec.path, spec.suffix], "/", true)
     resmatch = {}
 
+    # Sent with the request, never recorded as the entity's match.
+    authquery = (spec.respond_to?(:authquery) ? spec.authquery : nil) || []
+
     # A route the definition ends with a slash keeps it: a server such as a
     # Django REST one redirects or refuses the route without it.
     orig = ctx.point ? VoxgigStruct.getprop(ctx.point, "orig") : nil
@@ -33,6 +36,15 @@ module ProjectNameUtilities
       end
     end
 
+    # 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.
+    base = spec.base.is_a?(String) ? spec.base.sub(%r{/+\z}, "") : ""
+    route = url.delete_prefix(base)
+    unfilled = route.scan(/\{[^{}\/]+\}/)
+    unless unfilled.empty?
+      return "", ctx.make_error("url_param_missing", "URL path has no value for #{unfilled.join(', ')}.")
+    end
+
     # Append query string from spec.query.
     qsep = "?"
     query_items = VoxgigStruct.items(spec.respond_to?(:query) ? spec.query : nil)
@@ -44,7 +56,7 @@ module ProjectNameUtilities
           val_str = val.is_a?(String) ? val : val.to_s
           url += qsep + VoxgigStruct.escurl(key) + "=" + VoxgigStruct.escurl(val_str)
           qsep = "&"
-          resmatch[key] = val
+          resmatch[key] = val unless authquery.include?(key)
         end
       end
     end

package/project/.sdk/tm/rb/utility/media.rb

@@ -0,0 +1,75 @@
+# ProjectName SDK utility: media
+require_relative 'struct/voxgig_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.
+module ProjectNameUtilities
+  # The data key holding a raw request body. Like `$action`, it can never be
+  # a declared argument name.
+  RAW_BODY = "$body"
+
+  def self.json_media?(media)
+    m = media.to_s.split(";").first.to_s.strip.downcase
+    m == "application/json" || m == "text/json" || m.end_with?("+json")
+  end
+
+  # The declared JSON type alone, else every declared type in the model's
+  # order; nil when no success response declares a body.
+  def self.accept_of(point)
+    res = VoxgigStruct.getprop(point, "response")
+    media = VoxgigStruct.getprop(res, "media")
+    return nil unless media.is_a?(String) && !media.empty?
+    return media if VoxgigStruct.getprop(res, "kind") == "json"
+    alts = VoxgigStruct.getprop(res, "alternatives")
+    types = [media]
+    (alts.is_a?(Array) ? alts : []).each do |alt|
+      m = VoxgigStruct.getprop(alt, "media")
+      types << m if m.is_a?(String) && !m.empty?
+    end
+    types.join(", ")
+  end
+
+  def self.raw_request?(point)
+    VoxgigStruct.getpath(point, "body.kind") == "raw"
+  end
+
+  def self.json_request?(point)
+    VoxgigStruct.getpath(point, "body.kind") == "json"
+  end
+
+  # Bytes or a stream go as given. A hash or an array is JSON, and so is a
+  # scalar on a point that declares a JSON body.
+  def self.request_body(point, body)
+    return body if body.respond_to?(:read) || (body.is_a?(String) && body.encoding == Encoding::BINARY)
+    return VoxgigStruct.jsonify(body) if VoxgigStruct.isnode(body) || json_request?(point)
+    body
+  end
+
+  def self.header?(headers, name)
+    headers.keys.any? { |k| k.is_a?(String) && k.downcase == name }
+  end
+
+  # 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 self.media_headers(point, headers)
+    accept = accept_of(point)
+    headers["accept"] = accept if accept && !header?(headers, "accept")
+
+    body = VoxgigStruct.getprop(point, "body")
+    kind = VoxgigStruct.getprop(body, "kind")
+    media = VoxgigStruct.getprop(body, "media")
+    if (kind == "raw" || kind == "json") && media.is_a?(String) && !media.empty?
+      headers.delete_if { |k, v| k.is_a?(String) && k.downcase == "content-type" && json_media?(v) }
+      headers["content-type"] = media unless header?(headers, "content-type")
+    end
+    headers
+  end
+
+  # A String, of bytes or text, or an IO, sent as it is. An IO can be read
+  # once, so it is read here, before the first attempt, and a retry sends the
+  # same bytes again.
+  def self.raw_body(reqdata)
+    body = reqdata.is_a?(Hash) ? reqdata[RAW_BODY] : nil
+    body.respond_to?(:read) ? body.read : body
+  end
+end

package/project/.sdk/tm/rb/utility/param.rb

@@ -3,13 +3,6 @@ require_relative 'struct/voxgig_struct'
 require_relative '../core/helpers'
 module ProjectNameUtilities
   Param = ->(ctx, paramdef) {
-    point = ctx.point
-    spec = ctx.spec
-    match_val = ctx.match
-    reqmatch = ctx.reqmatch
-    data = ctx.data
-    reqdata = ctx.reqdata
-
     pt = VoxgigStruct.typify(paramdef)
     key = if (VoxgigStruct::T_string & pt) > 0
             paramdef
@@ -18,31 +11,57 @@ module ProjectNameUtilities
             k.is_a?(String) ? k : ""
           end
 
-    akey = ""
-    if point
-      alias_map = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "alias"))
-      if alias_map
-        ak = VoxgigStruct.getprop(alias_map, key)
-        akey = ak if ak.is_a?(String)
-      end
+    akey = ProjectNameUtilities.param_alias(ctx.point, key)
+    if ctx.spec && !akey.empty? &&
+       VoxgigStruct.getprop(ctx.reqmatch, key).nil? && VoxgigStruct.getprop(ctx.match, key).nil?
+      ctx.spec.alias_map[akey] = key
     end
 
-    val = VoxgigStruct.getprop(reqmatch, key)
-    val = VoxgigStruct.getprop(match_val, key) if val.nil?
+    ProjectNameUtilities.param_value(ctx, ctx.point, key)
+  }
 
-    if val.nil? && !akey.empty?
-      spec.alias_map[akey] = key if spec
-      val = VoxgigStruct.getprop(reqmatch, akey)
-    end
+  # The name a point gives a parameter in the call, if it renames it.
+  def self.param_alias(point, key)
+    return "" unless point
+    alias_map = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "alias"))
+    ak = alias_map ? VoxgigStruct.getprop(alias_map, key) : nil
+    ak.is_a?(String) ? ak : ""
+  end
 
-    val = VoxgigStruct.getprop(reqdata, key) if val.nil?
-    val = VoxgigStruct.getprop(data, key) if val.nil?
+  # The value the call or its entity gives a point's parameter, under its name
+  # or the point's alias for it.
+  def self.param_value(ctx, point, key)
+    akey = param_alias(point, key)
+
+    val = VoxgigStruct.getprop(ctx.reqmatch, key)
+    val = VoxgigStruct.getprop(ctx.match, key) if val.nil?
+    val = VoxgigStruct.getprop(ctx.reqmatch, akey) if val.nil? && !akey.empty?
+    val = VoxgigStruct.getprop(ctx.reqdata, key) if val.nil?
+    val = VoxgigStruct.getprop(ctx.data, key) if val.nil?
 
     if val.nil? && !akey.empty?
-      val = VoxgigStruct.getprop(reqdata, akey)
-      val = VoxgigStruct.getprop(data, akey) if val.nil?
+      val = VoxgigStruct.getprop(ctx.reqdata, akey)
+      val = VoxgigStruct.getprop(ctx.data, akey) if val.nil?
     end
 
     val
-  }
+  end
+
+  # 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.
+  def self.call_args(ctx, kind)
+    defs = ctx.point ? VoxgigStruct.getpath(ctx.point, "args.#{kind}") : nil
+    return [] unless defs.is_a?(Array)
+    defs.each_with_object([]) do |ad, out|
+      name = VoxgigStruct.getprop(ad, "name")
+      next unless name.is_a?(String) && !name.empty?
+      wire = VoxgigStruct.getprop(ad, "orig")
+      wire = name unless wire.is_a?(String) && !wire.empty?
+      val = VoxgigStruct.getprop(ctx.reqmatch || {}, name)
+      val = VoxgigStruct.getprop(ctx.reqdata || {}, name) if val.nil?
+      out << [name, wire, val]
+    end
+  end
 end

package/project/.sdk/tm/rb/utility/prepare_body.rb

@@ -1,6 +1,9 @@
 # ProjectName SDK utility: prepare_body
+require_relative 'media'
 module ProjectNameUtilities
   PrepareBody = ->(ctx) {
-    ctx.op.input == "data" ? ctx.utility.transform_request.call(ctx) : nil
+    return nil unless ctx.op.input == "data"
+    return ProjectNameUtilities.raw_body(ctx.reqdata) if ProjectNameUtilities.raw_request?(ctx.point)
+    ctx.utility.transform_request.call(ctx)
   }
 end

package/project/.sdk/tm/rb/utility/prepare_headers.rb

@@ -1,29 +1,63 @@
 # ProjectName SDK utility: prepare_headers
 require_relative 'struct/voxgig_struct'
+require_relative 'param'
+require_relative 'media'
 module ProjectNameUtilities
+  # The form style of a cookie parameter: a list repeats the name, a map sends
+  # its own keys, and every value is percent-encoded.
+  def self.cookie_pair(wire, val)
+    esc = ->(v) { VoxgigStruct.escurl(VoxgigStruct.stringify(v)) }
+    pairs = if VoxgigStruct.islist(val)
+      val.map { |item| "#{wire}=#{esc.call(item)}" }
+    elsif VoxgigStruct.ismap(val)
+      VoxgigStruct.keysof(val).map { |key| "#{VoxgigStruct.escurl(key)}=#{esc.call(val[key])}" }
+    else
+      ["#{wire}=#{esc.call(val)}"]
+    end
+    pairs.join("; ")
+  end
   PrepareHeaders = ->(ctx) {
     options = ctx.client.options_map
     headers = VoxgigStruct.getprop(options, "headers")
     out = headers ? VoxgigStruct.clone(headers) : {}
     out = {} unless out.is_a?(Hash)
-    # 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.
-    hl = ctx.point ? VoxgigStruct.getpath(ctx.point, "args.header") : nil
-    if hl.is_a?(Array)
-      hl.each do |hd|
-        name = VoxgigStruct.getprop(hd, "name")
-        next unless name.is_a?(String) && !name.empty?
-        orig = VoxgigStruct.getprop(hd, "orig")
-        orig = name unless orig.is_a?(String) && !orig.empty?
-        val = VoxgigStruct.getprop(ctx.reqmatch || {}, name)
-        val = VoxgigStruct.getprop(ctx.reqdata || {}, name) if val.nil?
-        next if val.nil?
-        wire = orig.downcase
-        out.delete_if { |k, _| k.is_a?(String) && k.downcase == wire }
-        out[wire] = VoxgigStruct.stringify(val)
+    out = ProjectNameUtilities.media_headers(ctx.point, out)
+    # A header argument replaces a default of the same name, whatever its case.
+    ProjectNameUtilities.call_args(ctx, "header").each do |_name, orig, val|
+      next if val.nil?
+      wire = orig.downcase
+      out.delete_if { |k, _| k.is_a?(String) && k.downcase == wire }
+      out[wire] = VoxgigStruct.stringify(val)
+    end
+    # 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.
+    sent = ProjectNameUtilities.call_args(ctx, "cookie").reject { |_name, _orig, val| val.nil? }
+    unless sent.empty?
+      names = sent.flat_map do |_name, orig, val|
+        VoxgigStruct.ismap(val) ? VoxgigStruct.keysof(val).map { |k| VoxgigStruct.escurl(k) } : [orig]
+      end
+      kept = []
+      out.keys.select { |k| k.is_a?(String) && k.downcase == "cookie" }.each do |k|
+        given = out.delete(k)
+        next unless given.is_a?(String)
+        kept.concat(ProjectNameUtilities.cookie_keep(given, names))
       end
+      sent.each do |_name, orig, val|
+        pair = ProjectNameUtilities.cookie_pair(orig, val)
+        kept << pair unless pair.empty?
+      end
+      out["cookie"] = kept.join("; ") unless kept.empty?
     end
     out
   }
+
+  # The caller's cookie pieces with the named cookies removed: a cookie is one
+  # ;-delimited piece, whatever its value holds.
+  def self.cookie_keep(header, names)
+    header.split(";").each_with_object([]) do |piece, kept|
+      cookie = piece.strip
+      kept << cookie unless cookie.empty? || names.include?(cookie.split("=", 2)[0].to_s.strip)
+    end
+  end
 end

package/project/.sdk/tm/rb/utility/prepare_method.rb

@@ -15,4 +15,10 @@ module ProjectNameUtilities
     # shared corpus (prepareMethod, opname "bad" -> null) pins it now.
     METHOD_MAP[ctx.op.name]
   }
+
+  # Whether a comma-separated allow option names the item: whole names, any case.
+  def self.allowed(names, item)
+    want = item.is_a?(String) ? item.upcase : ""
+    "" != want && names.is_a?(String) && names.split(",").any? { |name| name.strip.upcase == want }
+  end
 end

package/project/.sdk/tm/rb/utility/prepare_query.rb

@@ -1,5 +1,6 @@
 # ProjectName SDK utility: prepare_query
 require_relative 'struct/voxgig_struct'
+require_relative 'param'
 module ProjectNameUtilities
   PrepareQuery = ->(ctx) {
     point = ctx.point
@@ -17,12 +18,15 @@ module ProjectNameUtilities
           params << name if name.is_a?(String)
         end
       end
-      # A header parameter travels in the headers, which prepare_headers fills.
-      hl = VoxgigStruct.getpath(point, "args.header")
-      if hl.is_a?(Array)
+      # A header or cookie parameter travels in the headers, which prepare_headers
+      # fills, unless a query parameter shares its name: then both are sent.
+      ql = VoxgigStruct.getpath(point, "args.query")
+      declared = ql.is_a?(Array) ? ql.map { |qd| VoxgigStruct.getprop(qd, "name") } : []
+      [VoxgigStruct.getpath(point, "args.header"), VoxgigStruct.getpath(point, "args.cookie")].each do |hl|
+        next unless hl.is_a?(Array)
         hl.each do |hd|
           name = VoxgigStruct.getprop(hd, "name")
-          params << name if name.is_a?(String)
+          params << name if name.is_a?(String) && !declared.include?(name)
         end
       end
     end
@@ -47,6 +51,10 @@ module ProjectNameUtilities
         out[wire.fetch(key, key)] = val if val && key.is_a?(String) && key != "$action" && !params.include?(key)
       end
     end
+    # A create or update passes its query arguments in its data.
+    ProjectNameUtilities.call_args(ctx, "query").each do |name, orig, val|
+      out[orig] = val if !val.nil? && !params.include?(name)
+    end
     out
   }
 end

package/project/.sdk/tm/rb/utility/result_body.rb

@@ -6,6 +6,51 @@ module ProjectNameUtilities
     if result && response && response.json_func && response.body
       result.body = response.json_func.call
     end
+    if result && response && response.unreadable
+      sent = ctx.spec ? ctx.spec.headers : nil
+      result.err = UnreadableBody.call(ctx, result.status, result.headers, response.body,
+                                       sent, result.err)
+    end
     result
   }
+
+  BODY_PREVIEW_LENGTH = 160
+
+  # A body that is not JSON. An HTTP failure keeps its own error, with the
+  # response described; otherwise the code tells a wrong content type from
+  # malformed JSON.
+  UnreadableBody = ->(ctx, status, headers, text, sent, failed) {
+    ctype = BodyHeader.call(headers, "content-type")
+    agent = ctx.utility.clean.call(ctx, BodyHeader.call(sent, "user-agent")).to_s
+    agent = "transport default" if agent.empty?
+    detail = "HTTP #{status}, content-type #{ctype.empty? ? 'none' : ctype}, user-agent #{agent}"
+    detail += ", body: " + BodyPreview.call(ctx, text) unless text.nil?
+
+    if failed
+      return "#{failed} (#{detail})" if failed.is_a?(String)
+      message = "#{failed.message} (#{detail})"
+      return RuntimeError.new(message) unless failed.is_a?(ProjectNameError)
+      failed.msg = message
+      return failed
+    end
+
+    if ctype.empty? || ctype.downcase.include?("json")
+      ctx.make_error("response_json_invalid", "response: body is not valid JSON (#{detail})")
+    else
+      ctx.make_error("response_content_type", "response: expected JSON, got #{ctype} (#{detail})")
+    end
+  }
+
+  BodyHeader = ->(headers, name) {
+    return "" unless headers.is_a?(Hash)
+    pair = headers.find { |key, _| key.to_s.downcase == name }
+    pair ? pair[1].to_s : ""
+  }
+
+  # Cleaned whole: a secret the bound would split could leave its prefix.
+  BodyPreview = ->(ctx, text) {
+    raw = text.to_s.dup.force_encoding(Encoding::UTF_8).scrub("?")
+    flat = ctx.utility.clean.call(ctx, raw.gsub(/\s+/, " ").strip).to_s
+    flat.length > BODY_PREVIEW_LENGTH ? flat[0, BODY_PREVIEW_LENGTH] + "..." : flat
+  }
 end

package/project/.sdk/tm/rb/utility/transform_request.rb

@@ -1,6 +1,7 @@
 # ProjectName SDK utility: transform_request
 require_relative 'struct/voxgig_struct'
 require_relative '../core/helpers'
+require_relative 'param'
 module ProjectNameUtilities
   # `$action` selects the point (see MakePoint); it is never an API field, so
   # the body is a copy without it. The caller's hash is left untouched.
@@ -8,12 +9,21 @@ module ProjectNameUtilities
     omit_keys(reqdata, ["$action"])
   end
 
-  # A header argument travels as a header, which PrepareHeaders sends, so the
-  # body is built from the request data without it.
-  def self.header_arg_names(point)
-    hl = point ? VoxgigStruct.getpath(point, "args.header") : nil
-    return [] unless hl.is_a?(Array)
-    hl.map { |hd| VoxgigStruct.getprop(hd, "name") }.select { |n| n.is_a?(String) && !n.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 entity declares it as a field too.
+  def self.routed_arg_names(ctx)
+    (call_args(ctx, "header") + call_args(ctx, "cookie") + call_args(ctx, "query")).map(&:first)
+      .reject { |name| field_arg?(ctx, name) }
+  end
+
+  def self.field_arg?(ctx, name)
+    ["header", "cookie", "query"].any? do |kind|
+      defs = ctx.point ? VoxgigStruct.getpath(ctx.point, "args.#{kind}") : nil
+      defs.is_a?(Array) && defs.any? do |ad|
+        VoxgigStruct.getprop(ad, "name") == name && true == VoxgigStruct.getprop(ad, "field")
+      end
+    end
   end
 
   def self.omit_keys(reqdata, names)
@@ -25,7 +35,7 @@ module ProjectNameUtilities
     spec = ctx.spec
     point = ctx.point
     spec.step = "reqform" if spec
-    data = ProjectNameUtilities.omit_keys(ctx.reqdata, ProjectNameUtilities.header_arg_names(point))
+    data = ProjectNameUtilities.omit_keys(ctx.reqdata, ProjectNameUtilities.routed_arg_names(ctx))
     transform = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "transform"))
     return ProjectNameUtilities.strip_action(data) unless transform
     reqform = VoxgigStruct.getprop(transform, "req")

package/project/.sdk/tm/rust/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/rust/core/context.rs

@@ -251,7 +251,7 @@ impl Context {
 
         let opcfg = getpath(&["entity", &entname, "op", opname], &self.config.borrow());
 
-        let input = if opname == "update" || opname == "create" {
+        let input = if opname == "update" || opname == "create" || opname == "patch" {
             "data"
         } else {
             "match"

package/project/.sdk/tm/rust/core/helpers.rs

@@ -30,6 +30,16 @@ pub fn getp(val: &Value, key: &str) -> Value {
     vs::get_prop(val, &Value::str(key), Value::Noval)
 }
 
+// Whether a comma-separated allow option names the item: whole names, any case.
+pub fn allowed(names: &Value, item: &str) -> bool {
+    match names {
+        Value::Str(list) if !item.is_empty() => list
+            .split(',')
+            .any(|name| name.trim().eq_ignore_ascii_case(item)),
+        _ => false,
+    }
+}
+
 pub fn getpath(path: &[&str], store: &Value) -> Value {
     let p = Value::list(path.iter().map(|s| Value::str(*s)).collect());
     vs::get_path(store, &p, None)