@voxgig/sdkgen 4.22.0 → 4.24.0

package/project/.sdk/tm/kotlin/feature/TestFeature.kt

@@ -63,12 +63,16 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
     if (null == data || null == ctx) return data
     val tm = Struct.getprop(ctx.point, "transform")
     val restf = Struct.getprop(tm, "res") as? String ?: return data
-    // 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. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (!restf.startsWith("`body.") || !restf.endsWith("`") || restf.length < 8) return data
     val inner = restf.substring(6, restf.length - 1)
-    if (inner.isEmpty() || inner.contains(".")) return data
-    return linkedMapOf<String, Any?>(inner to data)
+    if (inner.isEmpty()) return data
+    var out: Any? = data
+    for (seg in inner.split(".").reversed()) {
+      out = linkedMapOf<String, Any?>(seg to out)
+    }
+    return out
   }
 
   private fun respond(ctx: Context?, status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {
@@ -156,20 +160,13 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
         }
         val args = buildArgs(ctx, op, updateMatch)
         val found = Struct.select(entmap, args)
-        var ent = Struct.getelem(found, 0, null)
-        if (ent == null) {
-          for (e in entmap.values) {
-            if (e is MutableMap<*, *>) {
-              ent = e
-              break
-            }
-          }
-        }
+        val ent = Struct.getelem(found, 0, null)
         if (ent == null) {
+          // update miss: 404, never another record
           return respond(ctx, 404, null, extra("statusText", "Not found"))
         }
         if (ent is MutableMap<*, *>) {
-          (ent as MutableMap<String, Any?>).putAll(reqdata)
+          Struct.merge(Struct.jt(ent, reqdata))
         }
         Struct.delprop(ent, "\$KEY")
         val out = Struct.clone(ent)
@@ -316,10 +313,14 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
       }
     }
 
-    // Get required params.
-    val paramsPath = Struct.getpath(point, listOf("args", "params"))
-    val reqdParams = Struct.select(paramsPath, Struct.jm("reqd", true))
-    val reqd = Struct.transform(reqdParams, Struct.jt("`\$EACH`", "", "`\$KEY.name`"))
+    // 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.
+    val reqdArgs = Struct.jt()
+    for (kind in listOf("params", "query")) {
+      val argsPath = Struct.getpath(point, listOf("args", kind))
+      reqdArgs.addAll(Struct.select(argsPath, Struct.jm("reqd", true)))
+    }
+    val reqd = Struct.transform(reqdArgs, Struct.jt("`\$EACH`", "", "`\$KEY.name`"))
 
     val qand = Struct.jt()
     val q = Struct.jm("`\$AND`", qand)

package/project/.sdk/tm/kotlin/utility/Fetcher.kt

@@ -6,12 +6,44 @@ import java.net.URI
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
+import java.util.concurrent.ConcurrentHashMap
 import java.util.function.BiFunction
 import java.util.function.Supplier
 
 import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.utility.struct.Struct
 
+// Clients keyed by redirect policy and proxy. Each HttpClient owns a
+// connection pool and a selector thread, so one per request reused
+// nothing; one per key pools across calls.
+private val clients = ConcurrentHashMap<String, HttpClient>()
+
+private fun clientFor(fetchdef: MutableMap<String, Any?>): HttpClient {
+  // "manual" (set by the station feature's middleware under a hosts
+  // policy) returns a 3xx like any other response: an automatic follow
+  // would carry injected credentials to a host no policy approved.
+  val redirectPolicy =
+    if ("manual" == fetchdef["redirect"]) HttpClient.Redirect.NEVER
+    else HttpClient.Redirect.NORMAL
+
+  val praw = fetchdef["proxy"]
+  val proxy = if (praw is String) praw else ""
+
+  return clients.computeIfAbsent("$redirectPolicy|$proxy") {
+    val clientb = HttpClient.newBuilder().followRedirects(redirectPolicy)
+    if ("" != proxy) {
+      try {
+        val proxyUri = URI.create(proxy)
+        val port = if (proxyUri.port < 0) 80 else proxyUri.port
+        clientb.proxy(ProxySelector.of(InetSocketAddress(proxyUri.host, port)))
+      } catch (e: RuntimeException) {
+        // Unparseable proxy target: direct connection, as the go transport.
+      }
+    }
+    clientb.build()
+  }
+}
+
 @Suppress("UNCHECKED_CAST")
 fun defaultHttpFetch(fullurl: String, fetchdef: MutableMap<String, Any?>): MutableMap<String, Any?> {
   var method = if (fetchdef["method"] is String) fetchdef["method"] as String else ""
@@ -50,32 +82,9 @@ fun defaultHttpFetch(fullurl: String, fetchdef: MutableMap<String, Any?>): Mutab
     reqb.setHeader("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)")
   }
 
-  // Honour a redirect annotation on the fetch definition (set by the
-  // station feature's middleware under a hosts policy): "manual" returns
-  // a 3xx like any other response instead of following it — the ts
-  // donor's fetch honours the same key natively, and an automatic follow
-  // would carry injected credentials to a host no policy approved.
-  val redirectPolicy =
-    if ("manual" == fetchdef["redirect"]) HttpClient.Redirect.NEVER
-    else HttpClient.Redirect.NORMAL
-
-  // Honour a proxy annotation on the fetch definition (set by the proxy
-  // feature): route the request through a proxied HttpClient.
-  val clientb = HttpClient.newBuilder().followRedirects(redirectPolicy)
-  val proxy = fetchdef["proxy"]
-  if (proxy is String && "" != proxy) {
-    try {
-      val proxyUri = URI.create(proxy)
-      val port = if (proxyUri.port < 0) 80 else proxyUri.port
-      clientb.proxy(ProxySelector.of(InetSocketAddress(proxyUri.host, port)))
-    } catch (e: RuntimeException) {
-      // Unparseable proxy target: fall through to a direct connection.
-    }
-  }
-
   val resp: HttpResponse<String>
   try {
-    resp = clientb.build().send(reqb.build(), HttpResponse.BodyHandlers.ofString())
+    resp = clientFor(fetchdef).send(reqb.build(), HttpResponse.BodyHandlers.ofString())
   } catch (e: Exception) {
     throw RuntimeException("fetch: " + e.message, e)
   }

package/project/.sdk/tm/kotlin/utility/Prepare.kt

@@ -194,7 +194,7 @@ fun prepareQuery(ctx: Context): MutableMap<String, Any?> {
   for (item in Struct.items(reqmatch)) {
     val key = if (item[0] is String) item[0] as String else ""
     val v = item[1]
-    if (v != null && !containsStr(params, key)) {
+    if (v != null && "\$action" != key && !containsStr(params, key)) {
       out[key] = v
     }
   }

package/project/.sdk/tm/kotlin/utility/ResultTransform.kt

@@ -58,21 +58,36 @@ fun resultHeaders(ctx: Context): KOTLINPACKAGE.core.Result {
   return result!!
 }
 
+// `$action` selects the point (see makePoint); it is never an API field, so
+// the body is a copy without it. The caller's map is left untouched.
+private fun stripAction(reqdata: Any?): Any? {
+  if (reqdata !is Map<*, *> || !reqdata.containsKey("\$action")) {
+    return reqdata
+  }
+  val body = linkedMapOf<String, Any?>()
+  for ((k, v) in reqdata) {
+    if ("\$action" != k) {
+      body[k.toString()] = v
+    }
+  }
+  return body
+}
+
 fun transformRequest(ctx: Context): Any? {
   if (ctx.spec != null) {
     ctx.spec!!.step = "reqform"
   }
 
   val transform = Helpers.toMapAny(Struct.getprop(ctx.point, "transform"))
-    ?: return ctx.reqdata
+    ?: return stripAction(ctx.reqdata)
 
   val reqform = Struct.getprop(transform, "req", null)
-    ?: return ctx.reqdata
+    ?: return stripAction(ctx.reqdata)
 
   val data = linkedMapOf<String, Any?>()
   data["reqdata"] = ctx.reqdata
 
-  return Struct.transform(data, reqform)
+  return stripAction(Struct.transform(data, reqform))
 }
 
 fun transformResponse(ctx: Context): Any? {

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

@@ -49,7 +49,14 @@ function Context.new(ctxmap, basectx)
     if type(ctrl_raw.explain) == "table" then
       self.ctrl.explain = ctrl_raw.explain
     end
-  elseif basectx ~= nil and basectx.ctrl ~= nil then
+    if ctrl_raw.actor ~= nil then
+      self.ctrl.actor = ctrl_raw.actor
+    end
+    if type(ctrl_raw.paging) == "table" then
+      self.ctrl.paging = ctrl_raw.paging
+    end
+  elseif basectx ~= nil and basectx.ctrl ~= nil
+      and helpers.get_ctx_prop(ctxmap, "opname") == nil then
     self.ctrl = basectx.ctrl
   end
 

package/project/.sdk/tm/lua/core/control.lua

@@ -10,6 +10,9 @@ function Control.new(opts)
   self.throw_err = opts.throw_err
   self.err = nil
   self.explain = opts.explain
+  -- Per-call feature inputs (audit actor, paging cursor/page).
+  self.actor = opts.actor
+  self.paging = opts.paging
   return self
 end
 

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

@@ -5,8 +5,9 @@
 -- (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 `ctx.result.paging`. A
--- per-call `ctrl.paging` (cursor or page) wins over the option defaults,
+-- fields in the body (snake_case forms too) — and records them on
+-- `ctx.result.paging` and the caller's `ctrl.paging`. A per-call
+-- `ctrl.paging` (cursor or page) wins over the option defaults,
 -- so auto-iteration can advance the cursor/page and re-issue the list
 -- call until `hasMore` is false. Parameter names (`pageParam`,
 -- `limitParam`, `cursorParam`), `startPage` (default 1) and `limit` are
@@ -95,8 +96,14 @@ function PagingFeature:PreRequest(ctx)
   if paging["cursor"] ~= nil then
     spec.query[cursor_param] = paging["cursor"]
   elseif spec.query[page_param] == nil then
-    if paging["page"] ~= nil then
-      spec.query[page_param] = 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.
+    local page = paging["nextPage"]
+    if page == nil then
+      page = paging["page"]
+    end
+    if page ~= nil then
+      spec.query[page_param] = page
     else
       spec.query[page_param] = self.options["startPage"] or 1
     end
@@ -218,17 +225,33 @@ function PagingFeature:PreResult(ctx)
     end
   end
 
-  -- Body-level cursors.
+  -- Body-level signals; snake_case forms are read first so camelCase wins.
   if type(body) == "table" then
     if body["next"] ~= nil and paging.next == nil then
       paging.next = body["next"]
     end
+    if body["next_cursor"] ~= nil then
+      paging.cursor = body["next_cursor"]
+    end
     if body["cursor"] ~= nil then
       paging.cursor = body["cursor"]
     end
     if body["nextCursor"] ~= nil then
       paging.cursor = body["nextCursor"]
     end
+    if paging.nextPage == nil then
+      local np = body["nextPage"]
+      if np == nil then
+        np = body["next_page"]
+      end
+      if type(np) == "number" or type(np) == "string" then
+        paging.nextPage = np
+      end
+    end
+    if type(body["has_more"]) == "boolean" then
+      paging.hasMore = body["has_more"]
+      explicit_more = true
+    end
     if type(body["hasMore"]) == "boolean" then
       paging.hasMore = body["hasMore"]
       explicit_more = true
@@ -247,6 +270,22 @@ function PagingFeature:PreResult(ctx)
 
   result.paging = paging
 
+  if ctx.ctrl ~= nil then
+    -- The Context shares the caller's paging table by reference, so refill
+    -- it in place; a fresh table on ctrl never reaches the caller.
+    if type(ctx.ctrl.paging) == "table" then
+      local shared = ctx.ctrl.paging
+      for k in pairs(shared) do
+        shared[k] = nil
+      end
+      for k, v in pairs(paging) do
+        shared[k] = v
+      end
+    else
+      ctx.ctrl.paging = paging
+    end
+  end
+
   local client = self.client
   client._paging = { last = paging }
 end

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

@@ -167,21 +167,12 @@ function TestFeature:init(ctx, options)
       local args = test_self:build_args(fctx, op, update_match)
       local found = vs.select(entmap, args)
       local ent = vs.getelem(found, 0)
-      if ent == nil and type(entmap) == "table" then
-        for _, e in pairs(entmap) do
-          if type(e) == "table" then ent = e; break end
-        end
-      end
       if ent == nil then
+        -- update miss: 404, never another record
         return respond(404, nil, { statusText = "Not found" })
       end
-      if type(ent) == "table" then
-        local reqdata = fctx.reqdata
-        if reqdata ~= nil then
-          for k, v in pairs(reqdata) do
-            ent[k] = v
-          end
-        end
+      if type(ent) == "table" and type(fctx.reqdata) == "table" then
+        vs.merge({ ent, fctx.reqdata })
       end
       vs.delprop(ent, "$KEY")
       local out = vs.clone(ent)
@@ -312,12 +303,39 @@ function TestFeature:make_netsim(net, inner)
 end
 
 
+local function point_terminal(p)
+  local parts = vs.getprop(p, "parts")
+  if type(parts) ~= "table" or #parts == 0 then return false end
+  local last = parts[#parts]
+  return type(last) == "string" and last:sub(1, 1) == "{"
+end
+
+local function point_depth(p)
+  local parts = vs.getprop(p, "parts")
+  return type(parts) == "table" and #parts or 0
+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).
+local function pick_point(points)
+  if type(points) ~= "table" or #points == 0 then return nil end
+  local point = points[1]
+  for i = 2, #points do
+    local cand = points[i]
+    if point_terminal(cand) ~= point_terminal(point) then
+      if point_terminal(cand) then point = cand end
+    elseif point_depth(cand) < point_depth(point) then
+      point = cand
+    end
+  end
+  return point
+end
+
 function TestFeature:build_args(ctx, op, args)
   local opname = op.name
 
-  -- Get last point from config.
   local points = vs.getpath(ctx.config, "entity." .. ctx.entity:get_name() .. ".op." .. opname .. ".points")
-  local point = vs.getelem(points, -1)
+  local 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.

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

@@ -29,7 +29,8 @@ local function prepare_query_util(ctx)
     for _, item in ipairs(reqmatch_items) do
       local key = item[1]
       local val = item[2]
-      if val ~= nil and type(key) == "string" and not contains_param(params, key) then
+      if val ~= nil and type(key) == "string" and key ~= "$action"
+          and not contains_param(params, key) then
         out[key] = val
       end
     end

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

@@ -3,6 +3,22 @@
 local vs = require("utility.struct.struct")
 local helpers = require("core.helpers")
 
+-- `$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 table is left
+-- untouched.
+local function strip_action(reqdata)
+  if not vs.ismap(reqdata) or reqdata["$action"] == nil then
+    return reqdata
+  end
+  local body = {}
+  for k, v in pairs(reqdata) do
+    if k ~= "$action" then
+      body[k] = v
+    end
+  end
+  return body
+end
+
 local function transform_request_util(ctx)
   local spec = ctx.spec
   local point = ctx.point
@@ -13,19 +29,19 @@ local function transform_request_util(ctx)
 
   local transform = helpers.to_map(vs.getprop(point, "transform"))
   if transform == nil then
-    return ctx.reqdata
+    return strip_action(ctx.reqdata)
   end
 
   local reqform = vs.getprop(transform, "req")
   if reqform == nil then
-    return ctx.reqdata
+    return strip_action(ctx.reqdata)
   end
 
   local reqdata = vs.transform({
     reqdata = ctx.reqdata,
   }, reqform)
 
-  return reqdata
+  return strip_action(reqdata)
 end
 
 return transform_request_util

package/project/.sdk/tm/ocaml/sdk_features.ml

@@ -1121,9 +1121,15 @@ let paging_feature () : feature =
                 | Noval | Null ->
                   (match getp q page_param with
                    | Noval ->
-                     let page = (match getp paging "page" with
-                         | Noval | Null -> (match getp !options "startPage" with Num n -> Num n | _ -> Num 1.)
-                         | p -> p) in
+                     (* A record written back by PreResult holds the page just
+                      * fetched as `page` and the one to fetch as `nextPage`,
+                      * so nextPage wins. *)
+                     let page = (match getp paging "nextPage" with
+                         | Noval | Null ->
+                           (match getp paging "page" with
+                            | Noval | Null -> (match getp !options "startPage" with Num n -> Num n | _ -> Num 1.)
+                            | p -> p)
+                         | np -> np) in
                      setp q page_param page
                    | _ -> ())
                 | c -> setp q cursor_param c);
@@ -1176,11 +1182,20 @@ let paging_feature () : feature =
              (match body with
               | Map _ ->
                 (match getp body "next" with Noval | Null -> () | n -> if is_nullish (getp paging "next") then setp paging "next" n);
+                (* Both spellings, camelCase last so it wins when a body
+                 * carries the two. *)
+                (match getp body "next_cursor" with Noval | Null -> () | c -> setp paging "cursor" c);
                 (match getp body "cursor" with Noval | Null -> () | c -> setp paging "cursor" c);
                 (match getp body "nextCursor" with Noval | Null -> () | c -> setp paging "cursor" c);
-                (match getp body "hasMore" with
-                 | Bool b -> setp paging "hasMore" (Bool b); explicit_more := true
-                 | _ -> ())
+                if is_nullish (getp paging "nextPage") then begin
+                  let np = (match getp body "nextPage" with
+                      | Noval | Null -> getp body "next_page"
+                      | v -> v) in
+                  (match np with Num _ | Str _ -> setp paging "nextPage" np | _ -> ())
+                end;
+                List.iter (fun k -> match getp body k with
+                    | Bool b -> setp paging "hasMore" (Bool b); explicit_more := true
+                    | _ -> ()) ["has_more"; "hasMore"]
               | _ -> ());
              (* Cursor presence only INFERS another page. When the server
               * stated the answer outright — relay's `hasNextPage: false`, or
@@ -1196,6 +1211,16 @@ let paging_feature () : feature =
                setp paging "hasMore" (Bool hm)
              end;
              result.rt_paging <- paging;
+             (* The record reached the caller through ctrl in every other typed
+              * port and through nothing here, so a caller who asked for paging
+              * got the pages and never the signals to continue. *)
+             (match ctx.c_ctrl.ctrl_paging with
+              | Map _ as held ->
+                (* The caller holds this map: refill it in place. Every key of
+                 * the record is written, so no key of an earlier page lives on. *)
+                List.iter (fun k -> setp held k (getp paging k))
+                  ["page"; "totalCount"; "nextPage"; "next"; "cursor"; "hasMore"]
+              | _ -> ctx.c_ctrl.ctrl_paging <- paging);
              track_set (cc ctx) "paging" (jo [("last", paging)]))
         | _ -> ());
   f
@@ -1394,33 +1419,57 @@ let test_feature () : feature =
       match getp (getp ctx.c_point "transform") "res" with
       | Str spec ->
         let n = String.length spec in
-        (* 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. Multi-segment on
+           purpose: GraphQL ops unwrap `body.data.<field>`. *)
         if n > 7 && String.sub spec 0 6 = "`body." && spec.[n - 1] = '`' then
           let inner = String.sub spec 6 (n - 7) in
-          if String.length inner = 0 || String.contains inner '.' then data
-          else jo [(inner, data)]
+          if String.length inner = 0 then data
+          else
+            List.fold_left (fun out seg -> jo [(seg, out)]) data
+              (List.rev (String.split_on_char '.' inner))
         else data
       | _ -> data in
   let respond ctx status data extra =
     let out = jo [("status", vint_of status); ("statusText", Str "OK"); ("json", json_thunk (envelope ctx data)); ("body", Str "not-used")] in
     (match extra with Some (Map _ as e) -> List.iter (fun k -> setp out k (getp e k)) (keysof e) | _ -> ());
     (out, None) in
+  let point_terminal p =
+    match getp p "parts" with
+    | List r -> (match List.rev !r with Str s :: _ -> String.length s > 0 && s.[0] = '{' | _ -> false)
+    | _ -> false in
+  let point_depth p = match getp p "parts" with List r -> List.length !r | _ -> 0 in
+  (* 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). *)
+  let pick_point points =
+    match points with
+    | List r ->
+      (match !r with
+       | [] -> Noval
+       | first :: rest ->
+         List.fold_left (fun point cand ->
+             if point_terminal cand <> point_terminal point then (if point_terminal cand then cand else point)
+             else if point_depth cand < point_depth point then cand
+             else point) first rest)
+    | _ -> Noval in
+  let reqd_names point kind =
+    let reqd_args = select (getpath_s point ("args." ^ kind)) (jo [("reqd", Bool true)]) in
+    transform reqd_args (ja [Str "`$EACH`"; Str ""; Str "`$KEY.name`"]) in
   let build_args ctx (op : operation) args =
     let opname = op.op_name in
     let entname = match ctx.c_entity with Some e -> e.e_name | None -> "_" in
     let points = getpath_s ctx.c_config ("entity." ^ entname ^ ".op." ^ opname ^ ".points") in
-    let point = getelem points (Num (-1.0)) in
-    let params_path = getpath_s point "args.params" in
-    let reqd_params = select params_path (jo [("reqd", Bool true)]) in
-    let reqd = transform reqd_params (ja [Str "`$EACH`"; Str ""; Str "`$KEY.name`"]) in
+    let point = pick_point points in
+    (* 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" in
+    let reqd_query = reqd_names point "query" in
     let qand = ref [] in
     (match args with
      | Map _ ->
        List.iter (fun key ->
            let is_id = key = "id" in
-           let selected = select reqd (Str key) in
-           let is_reqd = not (isempty selected) in
+           let is_reqd = not (isempty (select reqd_params (Str key)))
+                         || not (isempty (select reqd_query (Str key))) in
            if is_id || is_reqd then begin
              let v = (cu ctx).u_param ctx (Str key) in
              let ka = (match op.op_alias with Map _ -> (match getp op.op_alias key with Str s -> Some s | _ -> None) | _ -> None) in
@@ -1461,18 +1510,22 @@ let test_feature () : feature =
          end
        | "update" ->
          let update_match = empty_map () in
-         (match fctx.c_reqdata with Map _ -> (match getp fctx.c_reqdata "id" with Noval -> () | v -> setp update_match "id" v) | _ -> ());
+         (match fctx.c_reqdata with
+          | Map _ ->
+            (match getp fctx.c_reqdata "id" with Noval -> () | v -> setp update_match "id" v);
+            (match getp op.op_alias "id" with
+             | Str alias_id -> (match getp fctx.c_reqdata alias_id with Noval -> () | v -> setp update_match alias_id v)
+             | _ -> ())
+          | _ -> ());
          let update_match = if size update_match > 0 then update_match else resolve_match fctx (empty_map ()) in
          let args = build_args fctx op update_match in
-         let ent = ref (getelem (select entmap args) (Num 0.0)) in
-         (if is_nullish !ent then match entmap with
-           | Map m -> (try (match List.find (fun (_, v) -> match v with Map _ -> true | _ -> false) m.entries with (_, v) -> ent := v) with Not_found -> ())
-           | _ -> ());
-         if is_nullish !ent then respond fctx 404 Noval (Some (jo [("statusText", Str "Not found")]))
+         let ent = getelem (select entmap args) (Num 0.0) in
+         (* update miss: 404, never another record *)
+         if is_nullish ent then respond fctx 404 Noval (Some (jo [("statusText", Str "Not found")]))
          else begin
-           (match !ent with Map _ -> (match fctx.c_reqdata with Map _ -> List.iter (fun k -> setp !ent k (getp fctx.c_reqdata k)) (keysof fctx.c_reqdata) | _ -> ()) | _ -> ());
-           ignore (delprop !ent (Str "$KEY"));
-           respond fctx 200 (clone !ent) None
+           (match ent, fctx.c_reqdata with Map _, Map _ -> ignore (merge (ja [ent; fctx.c_reqdata])) | _ -> ());
+           ignore (delprop ent (Str "$KEY"));
+           respond fctx 200 (clone ent) None
          end
        | "remove" ->
          let args = build_args fctx op (resolve_match fctx fctx.c_reqmatch) in

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -189,7 +189,9 @@ let make_context_impl (cs : ctxspec) (basectx : ctx option) : ctx =
       (match getp cr "actor" with Noval -> () | a -> c.ctrl_actor <- a);
       (match getp cr "paging" with Map _ as m -> c.ctrl_paging <- m | _ -> ());
       c
-    | _ -> (match basectx with Some b -> b.c_ctrl | None -> new_control ())
+    | _ -> (match basectx with
+        | Some b when cs.cs_opname = None -> b.c_ctrl
+        | _ -> new_control ())
   in
   let meta =
     match cs.cs_meta with Some (Map _ as m) -> m
@@ -413,7 +415,7 @@ let prepare_query_util (ctx : ctx) : value =
   let out = empty_map () in
   List.iter (fun k ->
       let v = getp reqmatch k in
-      if not (is_noval v) && not (contains_param k) then setp out k v)
+      if not (is_noval v) && k <> "$action" && not (contains_param k) then setp out k v)
     (keysof reqmatch);
   out
 
@@ -555,14 +557,27 @@ let prepare_auth_util = Sdk_prepare_auth.prepare_auth_util
 
 (* ----- transforms / result helpers ----- *)
 
+(* `$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. *)
+let strip_action (reqdata : value) : value =
+  match reqdata with
+  | Map _ when List.mem "$action" (keysof reqdata) ->
+    let body = empty_map () in
+    List.iter (fun k -> if k <> "$action" then setp body k (getp reqdata k))
+      (keysof reqdata);
+    body
+  | _ -> reqdata
+
 let transform_request_util (ctx : ctx) : value =
   (match ctx.c_spec with Some s -> s.sp_step <- "reqform" | None -> ());
-  match to_map (getp ctx.c_point "transform") with
-  | Map _ as tr ->
-    (match getp tr "req" with
-     | Noval -> ctx.c_reqdata
-     | reqform -> transform (jo [("reqdata", ctx.c_reqdata)]) reqform)
-  | _ -> ctx.c_reqdata
+  strip_action
+    (match to_map (getp ctx.c_point "transform") with
+     | Map _ as tr ->
+       (match getp tr "req" with
+        | Noval -> ctx.c_reqdata
+        | reqform -> transform (jo [("reqdata", ctx.c_reqdata)]) reqform)
+     | _ -> ctx.c_reqdata)
 
 let transform_response_util (ctx : ctx) : value =
   (match ctx.c_spec with Some s -> s.sp_step <- "resform" | None -> ());

package/project/.sdk/tm/perl/core/context.pm

@@ -45,7 +45,8 @@ sub new {
     $self->{ctrl}{actor} = $ctrl_raw->{actor} if exists $ctrl_raw->{actor};
     $self->{ctrl}{paging} = $ctrl_raw->{paging} if Voxgig::Struct::ismap($ctrl_raw->{paging});
   }
-  elsif ($basectx && $basectx->{ctrl}) {
+  elsif ($basectx && $basectx->{ctrl}
+      && !defined ProjectNameHelpers::get_ctx_prop($ctxmap, 'opname')) {
     $self->{ctrl} = $basectx->{ctrl};
   }