@voxgig/sdkgen 4.23.0 → 4.24.0

package/project/.sdk/tm/py/test/test_feature.py

@@ -724,6 +724,33 @@ class TestPagingFeature:
         assert res["result"].paging["cursor"] == "abc"
         assert res["result"].paging["hasMore"] is True
 
+    def test_snake_case_signals_and_ctrl_write_back(self):
+        server, calls = recording_server(lambda n, _fd: make_response(
+            200, {"has_more": True, "next_cursor": "c2"} if n == 1
+            else {"has_more": False}))
+        h = make_client([{"name": "paging"}], server=server)
+        pg = {}
+        ctrl = {"paging": pg}
+        res = h.op(op="list", path="/w", ctrl=ctrl)
+        assert res["result"].paging["hasMore"] is True
+        assert res["result"].paging["cursor"] == "c2"
+        assert pg["cursor"] == "c2" and pg["hasMore"] is True
+        h.op(op="list", path="/w", ctrl=ctrl)
+        assert re.search(r"[?&]cursor=c2(&|$)", calls[1]["url"])
+        assert pg["hasMore"] is False and pg["cursor"] is None
+
+    def test_continues_from_written_back_next_page(self):
+        server, calls = recording_server(lambda n, _fd: make_response(
+            200, {"next_page": 2} if n == 1 else {}, {"x-page": str(n)}))
+        h = make_client([{"name": "paging"}], server=server)
+        pg = {}
+        ctrl = {"paging": pg}
+        h.op(op="list", path="/w", ctrl=ctrl)
+        assert pg["page"] == 1 and pg["nextPage"] == 2 and pg["hasMore"] is True
+        h.op(op="list", path="/w", ctrl=ctrl)
+        assert re.search(r"[?&]page=2(&|$)", calls[1]["url"])
+        assert pg["hasMore"] is False
+
     def test_non_list_op_is_not_paged(self):
         server, calls = recording_server()
         h = make_client([{"name": "paging"}], server=server)

package/project/.sdk/tm/py/test/test_feature_corpus.py

@@ -240,6 +240,14 @@ def _subset(actual, expect, path):
         "{}: got {!r}, want {!r}".format(path, actual, expect)
 
 
+# Whether the SDK built the feature at all. The activity record is the
+# wrong probe: most features create theirs on first use, so an idle client
+# has none and every section but the eager ones read as inert.
+def _present(client, name):
+    return any(getattr(f, "name", None) == name
+               for f in (getattr(client, "features", None) or []))
+
+
 def _record(client, name):
     return getattr(client, "_" + name, None)
 
@@ -280,7 +288,9 @@ class TestFeatureCorpus:
         # Probed by ACTIVATING it: the feature defaults to inactive, so an
         # idle client never builds it and its absence says nothing.
         probe = _client({"feature": [{"name": name, "active": True}]})
-        if _record(probe, name) is None:
+        if not _present(probe, name):
+            # The one line every runner prints for an inert section.
+            print("feature.{}: inert (this SDK does not generate the feature)".format(name))
             pytest.skip("this SDK was generated without the {} feature".format(name))
 
         ops = _usable_ops(2)

package/project/.sdk/tm/rb/core/context.rb

@@ -30,7 +30,7 @@ class ProjectNameContext
       @ctrl.explain = ctrl_raw["explain"] if ctrl_raw["explain"].is_a?(Hash)
       @ctrl.actor = ctrl_raw["actor"] if ctrl_raw.key?("actor")
       @ctrl.paging = ctrl_raw["paging"] if ctrl_raw["paging"].is_a?(Hash)
-    elsif basectx&.ctrl
+    elsif basectx&.ctrl && ProjectNameHelpers.get_ctx_prop(ctxmap, "opname").nil?
       @ctrl = basectx.ctrl
     end
 

package/project/.sdk/tm/rb/feature/paging_feature.rb

@@ -4,8 +4,8 @@
 # stamps page/limit (or a cursor) into the request query; on the way back
 # (PreResult) it reads the server's pagination signals - a Link rel="next"
 # header, X-Page/X-Next-Page/X-Total-Count headers, or next/cursor/
-# nextCursor/hasMore fields in the body - and records them on
-# result.paging. A per-call ctrl paging value (page or cursor) takes
+# nextCursor/hasMore fields in the body (snake_case forms too) - and records
+# them on result.paging and the caller's ctrl paging. A per-call ctrl paging value (page or cursor) takes
 # priority. Parameter names ("pageParam", "limitParam", "cursorParam"),
 # "startPage" (default 1) and page size ("limit") are configurable.
 
@@ -56,8 +56,10 @@ class ProjectNamePagingFeature < ProjectNameBaseFeature
     if !paging["cursor"].nil?
       spec.query[cursor_param] = paging["cursor"]
     elsif spec.query[page_param].nil?
-      spec.query[page_param] =
-        paging["page"].nil? ? (@options["startPage"] || 1) : paging["page"]
+      # A record written back by PreResult holds the page just fetched as
+      # "page" and the one to fetch as "nextPage", so nextPage wins.
+      page = paging["nextPage"].nil? ? paging["page"] : paging["nextPage"]
+      spec.query[page_param] = page.nil? ? (@options["startPage"] || 1) : page
     end
 
     if !@options["limit"].nil? && spec.query[limit_param].nil?
@@ -158,11 +160,20 @@ class ProjectNamePagingFeature < ProjectNameBaseFeature
       paging["next"] = m[1] if m
     end
 
-    # Body-level cursors.
+    # Body-level signals; snake_case forms are read first so camelCase wins.
     if body.is_a?(Hash)
       paging["next"] = paging["next"] || body["next"] unless body["next"].nil?
+      paging["cursor"] = body["next_cursor"] unless body["next_cursor"].nil?
       paging["cursor"] = body["cursor"] unless body["cursor"].nil?
       paging["cursor"] = body["nextCursor"] unless body["nextCursor"].nil?
+      if paging["nextPage"].nil?
+        np = body["nextPage"].nil? ? body["next_page"] : body["nextPage"]
+        paging["nextPage"] = np if np.is_a?(Numeric) || np.is_a?(String)
+      end
+      if body["has_more"] == true || body["has_more"] == false
+        paging["hasMore"] = body["has_more"]
+        explicit_more = true
+      end
       if body["hasMore"] == true || body["hasMore"] == false
         paging["hasMore"] = body["hasMore"]
         explicit_more = true
@@ -181,6 +192,17 @@ class ProjectNamePagingFeature < ProjectNameBaseFeature
 
     result.paging = paging
 
+    if ctx.ctrl && ctx.ctrl.respond_to?(:paging=)
+      # The Context shares the caller's paging hash by reference, so refill
+      # it in place; a fresh hash on ctrl never reaches the caller.
+      if ctx.ctrl.paging.is_a?(Hash)
+        ctx.ctrl.paging.clear
+        ctx.ctrl.paging.merge!(paging)
+      else
+        ctx.ctrl.paging = paging
+      end
+    end
+
     @client.instance_variable_set(:@_paging, { "last" => paging })
   end
 

package/project/.sdk/tm/rb/feature/test_feature.rb

@@ -127,12 +127,10 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         args = test_self.build_args(fctx, op, update_match)
         found = VoxgigStruct.select(entmap, args)
         ent = VoxgigStruct.getelem(found, 0)
-        if ent.nil? && entmap.is_a?(Hash) && !entmap.empty?
-          ent = entmap.values.find { |e| e.is_a?(Hash) }
-        end
+        # update miss: 404, never another record
         return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
-        if ent.is_a?(Hash) && fctx.reqdata
-          fctx.reqdata.each { |k, v| ent[k] = v }
+        if ent.is_a?(Hash) && fctx.reqdata.is_a?(Hash)
+          VoxgigStruct.merge([ent, fctx.reqdata])
         end
         VoxgigStruct.delprop(ent, "$KEY")
         out = VoxgigStruct.clone(ent)
@@ -237,14 +235,42 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
     }
   end
 
+  # The entity's own endpoint: a terminal `{param}` marks a record route,
+  # and among equals the shallower path wins (the same rule as make_point).
+  def pick_point(points)
+    return nil unless points.is_a?(Array) && !points.empty?
+    terminal = ->(p) {
+      parts = VoxgigStruct.getprop(p, "parts")
+      parts.is_a?(Array) && !parts.empty? && parts[-1].is_a?(String) && parts[-1].start_with?("{")
+    }
+    depth = ->(p) {
+      parts = VoxgigStruct.getprop(p, "parts")
+      parts.is_a?(Array) ? parts.length : 0
+    }
+    point = points[0]
+    points[1..].each do |cand|
+      if terminal.call(cand) != terminal.call(point)
+        point = cand if terminal.call(cand)
+      elsif depth.call(cand) < depth.call(point)
+        point = cand
+      end
+    end
+    point
+  end
+
   def build_args(ctx, op, args)
     opname = op.name
     points = VoxgigStruct.getpath(ctx.config, "entity.#{ctx.entity.get_name}.op.#{opname}.points")
-    point = VoxgigStruct.getelem(points, -1)
+    point = pick_point(points)
 
+    # Path AND query: a path-only read misses a query-addressed record
+    # (e.g. GET /result?trace_id=), which has no path param at all.
     params_path = VoxgigStruct.getpath(point, "args.params")
     reqd_params = VoxgigStruct.select(params_path, { "reqd" => true })
-    reqd = VoxgigStruct.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"])
+    query_path = VoxgigStruct.getpath(point, "args.query")
+    reqd_query = VoxgigStruct.select(query_path, { "reqd" => true })
+    reqd = (VoxgigStruct.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"]) || []) +
+      (VoxgigStruct.transform(reqd_query, ["`$EACH`", "", "`$KEY.name`"]) || [])
 
     qand = []
     q = { "`$AND`" => qand }

package/project/.sdk/tm/rb/test/feature_corpus_test.rb

@@ -200,6 +200,13 @@ class FeatureCorpusTest < Minitest::Test
     assert_equal expect, actual, path
   end
 
+  # Whether the SDK built the feature at all. The activity record is the
+  # wrong probe: most features create theirs on first use, so an idle
+  # client has none and every section but the eager ones read as inert.
+  def present?(client, name)
+    (client.features || []).any? { |f| f.respond_to?(:name) && f.name == name }
+  end
+
   def record(client, name)
     # A corpus key is any manifest item name, so it may carry characters
     # (foo-bar, foo.2) that cannot form a Ruby instance-variable name. The
@@ -246,7 +253,11 @@ class FeatureCorpusTest < Minitest::Test
       # Probed by ACTIVATING it: the feature defaults to inactive, so an idle
       # client never builds it and its absence says nothing.
       probe = build_client({ "feature" => [{ "name" => name, "active" => true }] })
-      next if record(probe, name).nil?
+      unless present?(probe, name)
+        # The one line every runner prints for an inert section.
+        puts "feature.#{name}: inert (this SDK does not generate the feature)"
+        next
+      end
 
       ops = usable_ops(2)
       by_key = ops.each_with_object({}) { |o, h| h[o["key"]] = o }

package/project/.sdk/tm/rb/test/feature_test.rb

@@ -911,6 +911,44 @@ class FeatureTest < Minitest::Test
     assert_equal true, res["result"].paging["hasMore"]
   end
 
+  def test_paging_snake_case_signals_and_ctrl_write_back
+    skip_unless_feature("paging")
+    server, calls = H.recording_server { |n, _fd|
+      body = 1 == n ? { "has_more" => true, "next_cursor" => "c2" } : { "has_more" => false }
+      [H.make_response(200, body), nil]
+    }
+    h = harness([fspec("paging")], server: server)
+    pg = {}
+    ctrl = { "paging" => pg }
+    res = h.op(opname: "list", path: "/w", ctrl: ctrl)
+    assert_equal true, res["result"].paging["hasMore"]
+    assert_equal "c2", res["result"].paging["cursor"]
+    assert_equal "c2", pg["cursor"], "record written back into ctrl"
+    assert_equal true, pg["hasMore"]
+    h.op(opname: "list", path: "/w", ctrl: ctrl)
+    assert_match(/[?&]cursor=c2(&|\z)/, calls[1]["url"])
+    assert_equal false, pg["hasMore"]
+    assert_nil pg["cursor"]
+  end
+
+  def test_paging_continues_from_written_back_next_page
+    skip_unless_feature("paging")
+    server, calls = H.recording_server { |n, _fd|
+      body = 1 == n ? { "next_page" => 2 } : {}
+      [H.make_response(200, body, "x-page" => n.to_s), nil]
+    }
+    h = harness([fspec("paging")], server: server)
+    pg = {}
+    ctrl = { "paging" => pg }
+    h.op(opname: "list", path: "/w", ctrl: ctrl)
+    assert_equal 1, pg["page"]
+    assert_equal 2, pg["nextPage"]
+    assert_equal true, pg["hasMore"]
+    h.op(opname: "list", path: "/w", ctrl: ctrl)
+    assert_match(/[?&]page=2(&|\z)/, calls[1]["url"])
+    assert_equal false, pg["hasMore"]
+  end
+
   def test_paging_non_list_op_is_not_paged
     skip_unless_feature("paging")
     server, calls = H.recording_server

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

@@ -5,6 +5,42 @@ require 'uri'
 require 'json'
 
 module ProjectNameUtilities
+  # Started Net::HTTP connections keyed by scheme, host, port and proxy,
+  # checked out for one request and returned. A Net::HTTP serves one
+  # request at a time, so the pool holds idle ones rather than sharing one.
+  HTTP_POOL = Hash.new { |h, k| h[k] = [] }
+  HTTP_POOL_LOCK = Mutex.new
+  HTTP_POOL_IDLE_MAX = 4
+
+  def self.http_checkout(key, uri, proxy)
+    http = HTTP_POOL_LOCK.synchronize { HTTP_POOL[key].pop }
+    return http if http && http.started?
+
+    if proxy
+      purl = URI.parse(proxy)
+      http = Net::HTTP.new(uri.host, uri.port, purl.host, purl.port, purl.user, purl.password)
+    else
+      http = Net::HTTP.new(uri.host, uri.port)
+    end
+    http.use_ssl = (uri.scheme == "https")
+    http.start
+  end
+
+  def self.http_checkin(key, http)
+    kept = HTTP_POOL_LOCK.synchronize do
+      HTTP_POOL[key].size < HTTP_POOL_IDLE_MAX && HTTP_POOL[key].push(http)
+    end
+    http.finish unless kept
+  rescue IOError
+    nil
+  end
+
+  def self.http_discard(http)
+    http.finish if http.started?
+  rescue IOError
+    nil
+  end
+
   DefaultHttpFetch = ->(fullurl, fetchdef) {
     method_str = fetchdef["method"] || "GET"
     body_str = fetchdef["body"]
@@ -12,8 +48,9 @@ module ProjectNameUtilities
 
     begin
       uri = URI.parse(fullurl)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
+      proxy = fetchdef["proxy"]
+      proxy = nil unless proxy.is_a?(String) && !proxy.empty?
+      key = [uri.scheme, uri.host, uri.port, proxy]
 
       klass = case method_str.upcase
               when "POST" then Net::HTTP::Post
@@ -35,7 +72,16 @@ module ProjectNameUtilities
       request['User-Agent'] = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)' unless has_ua
       request.body = body_str if body_str.is_a?(String)
 
-      resp = http.request(request)
+      http = ProjectNameUtilities.http_checkout(key, uri, proxy)
+      begin
+        # Net::HTTP retries idempotent requests; an EOF can follow a committed POST.
+        resp = http.request(request)
+      rescue StandardError
+        ProjectNameUtilities.http_discard(http)
+        raise
+      end
+      ProjectNameUtilities.http_checkin(key, http)
+
       resp_headers = {}
       resp.each_header { |k, v| resp_headers[k.downcase] = v }
 

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

@@ -14,7 +14,7 @@ module ProjectNameUtilities
     if items
       items.each do |item|
         key, val = item[0], item[1]
-        out[key] = val if val && key.is_a?(String) && !params.include?(key)
+        out[key] = val if val && key.is_a?(String) && key != "$action" && !params.include?(key)
       end
     end
     out

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

@@ -2,14 +2,21 @@
 require_relative 'struct/voxgig_struct'
 require_relative '../core/helpers'
 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.
+  def self.strip_action(reqdata)
+    return reqdata unless reqdata.is_a?(Hash) && reqdata.key?("$action")
+    reqdata.reject { |k, _| k == "$action" }
+  end
+
   TransformRequest = ->(ctx) {
     spec = ctx.spec
     point = ctx.point
     spec.step = "reqform" if spec
     transform = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "transform"))
-    return ctx.reqdata unless transform
+    return ProjectNameUtilities.strip_action(ctx.reqdata) unless transform
     reqform = VoxgigStruct.getprop(transform, "req")
-    return ctx.reqdata unless reqform
-    VoxgigStruct.transform({ "reqdata" => ctx.reqdata }, reqform)
+    return ProjectNameUtilities.strip_action(ctx.reqdata) unless reqform
+    ProjectNameUtilities.strip_action(VoxgigStruct.transform({ "reqdata" => ctx.reqdata }, reqform))
   }
 end

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

@@ -1,4 +1,3 @@
-
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -101,7 +100,7 @@ impl Context {
             Rc::new(RefCell::new(c))
         } else if let Some(co) = ctxspec.ctrl_obj {
             co
-        } else if let Some(b) = basectx {
+        } else if let Some(b) = basectx.filter(|_| ctxspec.opname.is_none()) {
             b.ctrl.borrow().clone()
         } else {
             Rc::new(RefCell::new(Control::new()))
@@ -249,10 +248,7 @@ impl Context {
             return Rc::new(Operation::new(&Value::empty_map()));
         }
 
-        let opcfg = getpath(
-            &["entity", &entname, "op", opname],
-            &self.config.borrow(),
-        );
+        let opcfg = getpath(&["entity", &entname, "op", opname], &self.config.borrow());
 
         let input = if opname == "update" || opname == "create" {
             "data"

package/project/.sdk/tm/rust/feature/paging.rs

@@ -7,6 +7,7 @@ use crate::core::spec::Spec;
 use crate::core::helpers::{get_bool, getp, getpath, setp};
 use crate::core::types::Feature;
 use crate::feature::support::*;
+use crate::utility::voxgigstruct::ordered_map::OrderedMap;
 use crate::utility::voxgigstruct::Value;
 
 pub struct PagingFeature {
@@ -193,7 +194,12 @@ impl Feature for PagingFeature {
         if !cursor.is_noval() && !cursor.is_null() {
             setp(&query, &cursor_param, cursor);
         } else if getp(&query, &page_param).is_noval() {
-            let page = getp(&paging, "page");
+            // A record written back by pre_result holds the page just fetched
+            // as "page" and the one to fetch as "nextPage", so nextPage wins.
+            let mut page = getp(&paging, "nextPage");
+            if page.is_noval() || page.is_null() {
+                page = getp(&paging, "page");
+            }
             if !page.is_noval() && !page.is_null() {
                 setp(&query, &page_param, page);
             } else {
@@ -281,12 +287,16 @@ impl Feature for PagingFeature {
             }
         }
 
-        // Body-level cursors.
+        // Body-level signals; snake_case forms are read first so camelCase wins.
         if let Value::Map(_) = body {
             let next = getp(&body, "next");
             if !next.is_noval() && !next.is_null() && getp(&paging, "next").is_noval() {
                 setp(&paging, "next", next);
             }
+            let snake_cursor = getp(&body, "next_cursor");
+            if !snake_cursor.is_noval() && !snake_cursor.is_null() {
+                setp(&paging, "cursor", snake_cursor);
+            }
             let cursor = getp(&body, "cursor");
             if !cursor.is_noval() && !cursor.is_null() {
                 setp(&paging, "cursor", cursor);
@@ -295,6 +305,19 @@ impl Feature for PagingFeature {
             if !next_cursor.is_noval() && !next_cursor.is_null() {
                 setp(&paging, "cursor", next_cursor);
             }
+            if getp(&paging, "nextPage").is_noval() {
+                let mut np = getp(&body, "nextPage");
+                if np.is_noval() || np.is_null() {
+                    np = getp(&body, "next_page");
+                }
+                if matches!(np, Value::Num(_) | Value::Str(_)) {
+                    setp(&paging, "nextPage", np);
+                }
+            }
+            if let Some(has_more) = get_bool(&body, "has_more") {
+                setp(&paging, "hasMore", Value::Bool(has_more));
+                explicit_more = true;
+            }
             if let Some(has_more) = get_bool(&body, "hasMore") {
                 setp(&paging, "hasMore", Value::Bool(has_more));
                 explicit_more = true;
@@ -316,6 +339,24 @@ impl Feature for PagingFeature {
         }
 
         result.borrow_mut().paging = paging.clone();
-        self.last = paging;
+        self.last = paging.clone();
+
+        // Value::Map is Rc-shared, so the caller's map is refilled in place;
+        // a fresh map on ctrl never reaches the caller.
+        let ctrl = ctx.ctrl.borrow().clone();
+        let shared = ctrl.borrow().paging.clone();
+        if let Value::Map(m) = &shared {
+            let entries: Vec<(String, Value)> = match &paging {
+                Value::Map(pm) => pm.borrow().iter().map(|(k, v)| (k.clone(), v.clone())).collect(),
+                _ => Vec::new(),
+            };
+            let mut mm = m.borrow_mut();
+            *mm = OrderedMap::new();
+            for (k, v) in entries {
+                mm.insert(k, v);
+            }
+        } else {
+            ctrl.borrow_mut().paging = paging;
+        }
     }
 }

package/project/.sdk/tm/rust/feature/secrets.rs

@@ -754,7 +754,7 @@ fn raw_exchange_fetch(fullurl: &str, fetchdef: &Value) -> Result<Value, ProjectN
         .filter(|m| !m.is_empty())
         .unwrap_or_else(|| "POST".to_string());
 
-    let agent = ureq::AgentBuilder::new().build();
+    let agent = crate::utility::fetcher::default_agent();
     let mut req = agent.request(&method, fullurl);
 
     if let Value::Map(m) = getp(fetchdef, "headers") {

package/project/.sdk/tm/rust/feature/test.rs

@@ -80,6 +80,61 @@ fn resolve_match(ctx: &Rc<Context>, explicit: &Value) -> Value {
     Value::empty_map()
 }
 
+fn point_terminal(p: &Value) -> bool {
+    match getp(p, "parts") {
+        Value::List(l) => match l.borrow().last() {
+            Some(Value::Str(s)) => s.starts_with('{'),
+            _ => false,
+        },
+        _ => false,
+    }
+}
+
+fn point_depth(p: &Value) -> usize {
+    match getp(p, "parts") {
+        Value::List(l) => l.borrow().len(),
+        _ => 0,
+    }
+}
+
+// The entity's own endpoint: a terminal `{param}` marks a record route, and
+// among equals the shallower path wins (the same rule as make_point).
+fn pick_point(points: &Value) -> Value {
+    let list: Vec<Value> = match points {
+        Value::List(l) => l.borrow().clone(),
+        _ => return Value::Noval,
+    };
+    let mut point = match list.first() {
+        Some(p) => p.clone(),
+        None => return Value::Noval,
+    };
+    for cand in list.iter().skip(1) {
+        if point_terminal(cand) != point_terminal(&point) {
+            if point_terminal(cand) {
+                point = cand.clone();
+            }
+        } else if point_depth(cand) < point_depth(&point) {
+            point = cand.clone();
+        }
+    }
+    point
+}
+
+fn reqd_names(point: &Value, kind: &str) -> Value {
+    let args_path = crate::core::helpers::getpath(&["args", kind], point);
+    let reqd_args = vs::select(&args_path, &jo(vec![("reqd", Value::Bool(true))]));
+    vs::transform(
+        &reqd_args,
+        &ja(vec![
+            Value::str("`$EACH`"),
+            Value::str(""),
+            Value::str("`$KEY.name`"),
+        ]),
+        None,
+    )
+    .unwrap_or_else(|_| Value::empty_list())
+}
+
 fn build_args(ctx: &Rc<Context>, args: &Value) -> Value {
     let op = ctx.op.borrow().clone();
     let opname = op.name.clone();
@@ -88,26 +143,16 @@ fn build_args(ctx: &Rc<Context>, args: &Value) -> Value {
         None => op.entity.clone(),
     };
 
-    // Get last point from config.
     let points = crate::core::helpers::getpath(
         &["entity", &entname, "op", &opname, "points"],
         &ctx.config.borrow(),
     );
-    let point = vs::get_elem(&points, &Value::Num(-1.0), Value::Noval);
+    let point = pick_point(&points);
 
-    // Get required params.
-    let params_path = crate::core::helpers::getpath(&["args", "params"], &point);
-    let reqd_params = vs::select(&params_path, &jo(vec![("reqd", Value::Bool(true))]));
-    let reqd = vs::transform(
-        &reqd_params,
-        &ja(vec![
-            Value::str("`$EACH`"),
-            Value::str(""),
-            Value::str("`$KEY.name`"),
-        ]),
-        None,
-    )
-    .unwrap_or_else(|_| Value::empty_list());
+    // Path AND query: a path-only read misses a query-addressed record
+    // (e.g. GET /result?trace_id=), which has no path param at all.
+    let reqd_params = reqd_names(&point, "params");
+    let reqd_query = reqd_names(&point, "query");
 
     let qand = Value::empty_list();
     let q = jo(vec![("`$AND`", qand.clone())]);
@@ -116,8 +161,8 @@ fn build_args(ctx: &Rc<Context>, args: &Value) -> Value {
         let keys = vs::keysof_vec(args);
         for key in keys {
             let is_id = key == "id";
-            let selected = vs::select(&reqd, &Value::str(key.clone()));
-            let is_reqd = !vs::is_empty(&selected);
+            let is_reqd = !vs::is_empty(&vs::select(&reqd_params, &Value::str(key.clone())))
+                || !vs::is_empty(&vs::select(&reqd_query, &Value::str(key.clone())));
 
             if is_id || is_reqd {
                 let v = ctx.util().param(ctx, &Value::str(key.clone()));
@@ -215,28 +260,16 @@ fn test_fetch(
             };
             let args = build_args(ctx, &update_match);
             let found = vs::select(&entmap, &args);
-            let mut ent = vs::get_elem(&found, &Value::Num(0.0), Value::Noval);
-            if (ent.is_noval() || ent.is_null()) && vs::size(&entmap) > 0 {
-                // Fall back to any entity in the fixture.
-                for (_k, e) in vs::items_vec(&entmap) {
-                    if let Value::Map(_) = e {
-                        ent = e;
-                        break;
-                    }
-                }
-            }
+            let ent = vs::get_elem(&found, &Value::Num(0.0), Value::Noval);
             if ent.is_noval() || ent.is_null() {
+                // update miss: 404, never another record
                 return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
             }
-            if let Value::Map(_) = &ent {
-                if let Value::Map(rm) = &reqdata {
-                    for (k, v) in rm.borrow().iter() {
-                        setp(&ent, k, v.clone());
-                    }
-                }
+            if let (Value::Map(_), Value::Map(_)) = (&ent, &reqdata) {
+                vs::merge(&Value::list(vec![ent.clone(), reqdata.clone()]), None);
             }
             vs::del_prop(ent.clone(), &Value::str("$KEY"));
             Ok(respond(ctx, 200, vs::clone(&ent), vec![]))