@voxgig/sdkgen 4.23.0 → 4.24.1

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

@@ -533,7 +533,24 @@ class PrimaryUtilityTest < Minitest::Test
       unwrap(@utility.prepare_auth.call(ctx))
     end
 
-    runsection("prepareAuth", subject)
+    # The corpus writes the credential as `headers.authorization`: a
+    # PLACEHOLDER each runner points at the container and name this API
+    # actually uses.
+    cred = auth_credential(auth_client)
+    refute_nil cred, "prepare_auth placed no credential in headers or query"
+
+    # An absent section is runsection's report to make.
+    section = @spec.is_a?(Hash) ? @spec["prepareAuth"] : nil
+    swap = section.is_a?(Hash) &&
+      !("headers" == cred["where"] && "authorization" == cred["name"])
+    original = swap ? section["basic"] : nil
+    section["basic"] = retarget_auth(original, cred) if swap
+
+    begin
+      runsection("prepareAuth", subject)
+    ensure
+      section["basic"] = original if swap
+    end
   end
 
 
@@ -650,6 +667,47 @@ class PrimaryUtilityTest < Minitest::Test
     utility.make_context.call(ctxmap, client.get_root_ctx)
   end
 
+  # Where this SDK's prepare_auth actually puts the credential: the name is
+  # the API's OWN scheme name, not always `authorization`, so it is
+  # discovered by running prepare_auth once.
+  def auth_credential(client)
+    utility = client.get_utility
+    ctx = make_test_ctx(client, utility, nil)
+    ctx.spec = ProjectNameSpec.new({ "headers" => {}, "query" => {}, "step" => "s" })
+    _, err = utility.prepare_auth.call(ctx)
+    return nil unless err.nil?
+    ["headers", "query"].each do |where|
+      # A cookie credential rides the header bag, because a cookie IS a header.
+      bag = "query" == where ? ctx.spec.query : ctx.spec.headers
+      bag.each { |name, _value| return { "where" => where, "name" => name } }
+    end
+    nil
+  end
+
+  # Rename the corpus's `headers` bag to the real container, and the
+  # `authorization` key inside it to the real credential name. Applied only
+  # to the prepareAuth section, so real header assertions elsewhere are
+  # untouched.
+  def retarget_auth(node, cred)
+    return node.map { |child| retarget_auth(child, cred) } if node.is_a?(Array)
+    return node unless node.is_a?(Hash)
+
+    out = {}
+    node.each do |key, value|
+      if "headers" == key
+        bag = {}
+        (value.is_a?(Hash) ? value : {}).each do |bagkey, bagvalue|
+          name = "authorization" == bagkey ? cred["name"] : bagkey
+          bag[name] = retarget_auth(bagvalue, cred)
+        end
+        out[cred["where"]] = bag
+      else
+        out[key] = retarget_auth(value, cred)
+      end
+    end
+    out
+  end
+
   # === Helper: make_test_full_ctx ===
   def make_test_full_ctx(client, utility)
     ctx = make_test_ctx(client, utility, nil)

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![]))

package/project/.sdk/tm/rust/utility/fetcher.rs

@@ -1,29 +1,56 @@
+use std::collections::HashMap;
 use std::rc::Rc;
+use std::sync::{Mutex, OnceLock};
 
 use crate::core::context::Context;
 use crate::core::error::ProjectNameError;
 use crate::core::helpers::{call_vfn, get_str, getp, getpath, ja, jo, json_thunk, setp};
 use crate::utility::voxgigstruct::Value;
 
-// Default live transport: ureq (blocking, minimal). Honours a `proxy`
-// annotation on the fetch definition (set by the proxy feature) by routing
-// the request through an agent configured with that proxy.
+// One agent per process: ureq pools keep-alive connections per agent, so
+// an agent per request reused nothing. Cloning shares the pool.
+pub(crate) fn default_agent() -> ureq::Agent {
+    static AGENT: OnceLock<ureq::Agent> = OnceLock::new();
+    AGENT.get_or_init(|| ureq::AgentBuilder::new().build()).clone()
+}
+
+// Agents keyed by the `proxy` annotation (set by the proxy feature) and
+// manual redirects, for requests the default agent cannot serve.
+fn agent_for(fetchdef: &Value) -> ureq::Agent {
+    let proxy = get_str(fetchdef, "proxy").filter(|p| !p.is_empty());
+    let manual = get_str(fetchdef, "redirect").as_deref() == Some("manual");
+    if proxy.is_none() && !manual {
+        return default_agent();
+    }
+
+    static AGENTS: OnceLock<Mutex<HashMap<(Option<String>, bool), ureq::Agent>>> =
+        OnceLock::new();
+    let mut agents = AGENTS
+        .get_or_init(|| Mutex::new(HashMap::new()))
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
+    agents
+        .entry((proxy.clone(), manual))
+        .or_insert_with(|| {
+            let mut builder = ureq::AgentBuilder::new();
+            if let Some(p) = proxy.as_deref().and_then(|p| ureq::Proxy::new(p).ok()) {
+                builder = builder.proxy(p);
+            }
+            if manual {
+                builder = builder.redirects(0);
+            }
+            builder.build()
+        })
+        .clone()
+}
+
+// Default live transport: ureq (blocking, minimal).
 fn default_http_fetch(fullurl: &str, fetchdef: &Value) -> Result<Value, ProjectNameError> {
     let method = get_str(fetchdef, "method")
         .filter(|m| !m.is_empty())
         .unwrap_or_else(|| "GET".to_string());
 
-    let mut builder = ureq::AgentBuilder::new();
-    if let Some(proxy) = get_str(fetchdef, "proxy").filter(|p| !p.is_empty()) {
-        if let Ok(p) = ureq::Proxy::new(&proxy) {
-            builder = builder.proxy(p);
-        }
-    }
-    if get_str(fetchdef, "redirect").as_deref() == Some("manual") {
-        builder = builder.redirects(0);
-    }
-    let agent = builder.build();
-
+    let agent = agent_for(fetchdef);
     let mut req = agent.request(&method, fullurl);
 
     let mut has_ua = false;

package/project/.sdk/tm/rust/utility/prepare_query.rs

@@ -37,7 +37,7 @@ pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect();
         for (key, val) in entries {
-            if !val.is_noval() && !val.is_null() && !contains(&key) {
+            if !val.is_noval() && !val.is_null() && "$action" != key && !contains(&key) {
                 setp(&out, &key, val);
             }
         }

package/project/.sdk/tm/rust/utility/transform_request.rs

@@ -1,10 +1,36 @@
 use std::rc::Rc;
 
 use crate::core::context::Context;
-use crate::core::helpers::{getp, jo, to_map};
+use crate::core::helpers::{getp, jo, setp, to_map};
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
+// `$action` selects the point (see make_point_util); it is never an API
+// field, so the body is a copy without it. The caller's map is left untouched.
+fn strip_action(reqdata: Value) -> Value {
+    let has = match &reqdata {
+        Value::Map(src) => src.borrow().contains_key("$action"),
+        _ => false,
+    };
+    if !has {
+        return reqdata;
+    }
+    let body = Value::empty_map();
+    if let Value::Map(src) = &reqdata {
+        let entries: Vec<(String, Value)> = src
+            .borrow()
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect();
+        for (k, v) in entries {
+            if "$action" != k {
+                setp(&body, &k, v);
+            }
+        }
+    }
+    body
+}
+
 pub fn transform_request_util(ctx: &Rc<Context>) -> Value {
     let spec = ctx.spec.borrow().clone();
     let point = ctx.point.borrow().clone();
@@ -15,17 +41,17 @@ pub fn transform_request_util(ctx: &Rc<Context>) -> Value {
 
     let transform = to_map(&getp(&point, "transform"));
     if transform.is_noval() {
-        return ctx.reqdata.borrow().clone();
+        return strip_action(ctx.reqdata.borrow().clone());
     }
 
     let reqform = getp(&transform, "req");
     if reqform.is_noval() || reqform.is_null() {
-        return ctx.reqdata.borrow().clone();
+        return strip_action(ctx.reqdata.borrow().clone());
     }
 
     let store = jo(vec![("reqdata", ctx.reqdata.borrow().clone())]);
-    match vs::transform(&store, &reqform, None) {
+    strip_action(match vs::transform(&store, &reqform, None) {
         Ok(reqdata) => reqdata,
         Err(_) => ctx.reqdata.borrow().clone(),
-    }
+    })
 }

package/project/.sdk/tm/scala/core/Context.scala

@@ -51,7 +51,8 @@ class Context(ctxmap: JMap[String, Object], basectx: Context) {
         case c: Control => ctrl = c
         case _ =>
       }
-    } else if (basectx != null && basectx.ctrl != null) {
+    } else if (basectx != null && basectx.ctrl != null
+        && Helpers.getCtxProp(ctxmap, "opname") == null) {
       ctrl = basectx.ctrl
     }