@voxgig/sdkgen 4.22.0 → 4.24.0

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

@@ -34,11 +34,15 @@ fn envelope(ctx: &Rc<Context>, data: Value) -> Value {
     }
     let restf = crate::core::helpers::getpath(&["transform", "res"], &ctx.point.borrow());
     if let Value::Str(spec) = restf {
-        // Exactly `body.<key>` — a deeper path is not an envelope this mock
-        // can synthesise, so it is left alone rather than guessed at.
+        // Rebuild whatever nesting the transform unwraps: a GraphQL op unwraps
+        // `body.data.<field>`, not just one envelope property.
         if let Some(inner) = spec.strip_prefix("`body.").and_then(|r| r.strip_suffix('`')) {
-            if !inner.is_empty() && !inner.contains('.') {
-                return jo(vec![(inner, data)]);
+            if !inner.is_empty() {
+                let mut out = data;
+                for seg in inner.split('.').rev() {
+                    out = jo(vec![(seg, out)]);
+                }
+                return out;
             }
         }
     }
@@ -76,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();
@@ -84,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())]);
@@ -112,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()));
@@ -211,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
     }