@voxgig/sdkgen 4.4.0 → 4.5.0

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

@@ -61,11 +61,21 @@ function TestFeature:init(ctx, options)
       if type(restf) ~= "string" then
         return data
       end
-      local key = string.match(restf, "^`body%.([^`%.]+)`$")
-      if key == nil then
+      local path = string.match(restf, "^`body%.(.+)`$")
+      if path == nil then
         return data
       end
-      return { [key] = data }
+      -- Multi-segment on purpose: GraphQL ops unwrap body.data.<field> (and
+      -- body.data.<field>.<entity> for mutations), not just one level.
+      local segs = {}
+      for seg in string.gmatch(path, "[^.]+") do
+        table.insert(segs, seg)
+      end
+      local out = data
+      for i = #segs, 1, -1 do
+        out = { [segs[i]] = out }
+      end
+      return out
     end
 
     local function respond(status, data, extra)
@@ -309,10 +319,14 @@ function TestFeature:build_args(ctx, op, args)
   local points = vs.getpath(ctx.config, "entity." .. ctx.entity:get_name() .. ".op." .. opname .. ".points")
   local point = vs.getelem(points, -1)
 
-  -- Get required params.
+  -- 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.
   local params_path = vs.getpath(point, "args.params")
   local reqd_params = vs.select(params_path, { reqd = true })
-  local reqd = vs.transform(reqd_params, { "`$EACH`", "", "`$KEY.name`" })
+  local reqd_from_params = vs.transform(reqd_params, { "`$EACH`", "", "`$KEY.name`" })
+  local query_path = vs.getpath(point, "args.query")
+  local reqd_query = vs.select(query_path, { reqd = true })
+  local reqd_from_query = vs.transform(reqd_query, { "`$EACH`", "", "`$KEY.name`" })
 
   local qand = {}
   local q = { ["`$AND`"] = qand }
@@ -322,8 +336,8 @@ function TestFeature:build_args(ctx, op, args)
     if keys ~= nil then
       for _, key in ipairs(keys) do
         local is_id = (key == "id")
-        local selected = vs.select(reqd, key)
-        local is_reqd = not vs.isempty(selected)
+        local is_reqd = not vs.isempty(vs.select(reqd_from_params, key))
+          or not vs.isempty(vs.select(reqd_from_query, key))
 
         if is_id or is_reqd then
           local v = ctx.utility.param(ctx, key)

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

@@ -441,7 +441,7 @@ describe("feature", function()
   -- retry ---------------------------------------------------------------
   if has_feature("retry") then describe("retry", function()
 
-    it("retries transient failures then succeeds", function()
+    if has_feature("netsim") then it("retries transient failures then succeeds", function()
       local clock = make_clock()
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 2, failStatus = 503 } },
@@ -450,9 +450,9 @@ describe("feature", function()
       } })
       assert.is_true(h.op({ op = "load" }).ok)
       assert.are.equal(2, h.client._retry.attempts)
-    end)
+    end) end
 
-    it("gives up after the budget", function()
+    if has_feature("netsim") then it("gives up after the budget", function()
       local clock = make_clock()
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 9, failStatus = 500 } },
@@ -460,7 +460,7 @@ describe("feature", function()
           retries = 2, minDelay = 1, jitter = false, sleep = clock.sleep } },
       } })
       assert.are.equal(500, h.op({ op = "load" }).result.status)
-    end)
+    end) end
 
     it("does not retry a non-retryable status", function()
       local rec = recording_server(function() return make_response(404) end)
@@ -487,7 +487,7 @@ describe("feature", function()
       assert.are.equal(3, n)
     end)
 
-    it("honours a server Retry-After", function()
+    if has_feature("netsim") then it("honours a server Retry-After", function()
       local clock = make_clock()
       local h = make_client({ features = {
         { name = "netsim", options = { rateLimitTimes = 1, retryAfter = 2 } },
@@ -497,15 +497,15 @@ describe("feature", function()
       } })
       assert.is_true(h.op({ op = "load" }).ok)
       assert.are.equal(2000, clock.time())
-    end)
+    end) end
 
-    it("default jitter path still succeeds", function()
+    if has_feature("netsim") then it("default jitter path still succeeds", function()
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 1 } },
         { name = "retry", options = { retries = 2, minDelay = 0 } },
       } })
       assert.is_true(h.op({ op = "load" }).ok)
-    end)
+    end) end
 
     it("inactive retry does not wrap", function()
       local rec = recording_server(function() return make_response(503) end)
@@ -551,7 +551,7 @@ describe("feature", function()
   -- shared virtual clock stands in for elapsed transport time.
   if has_feature("timeout") then describe("timeout", function()
 
-    it("a slow request times out", function()
+    if has_feature("netsim") then it("a slow request times out", function()
       local clock = make_clock()
       local h = make_client({ features = {
         { name = "netsim", options = { latency = 80, sleep = clock.sleep } },
@@ -560,7 +560,7 @@ describe("feature", function()
       local res = h.op({ op = "load" })
       assert.are.equal("timeout", res.error.code)
       assert.are.equal(1, h.client._timeout.count)
-    end)
+    end) end
 
     it("a fast request passes through", function()
       local clock = make_clock()
@@ -819,7 +819,7 @@ describe("feature", function()
   -- metrics ---------------------------------------------------------------
   if has_feature("metrics") then describe("metrics", function()
 
-    it("counts ok and err per op", function()
+    if has_feature("netsim") then it("counts ok and err per op", function()
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 1, failStatus = 500 } },
         { name = "metrics", options = {} },
@@ -832,7 +832,7 @@ describe("feature", function()
       assert.are.equal(2, m.total.ok)
       assert.are.equal(1, m.total.err)
       assert.are.equal(2, m.ops["widget.load"].count)
-    end)
+    end) end
 
     it("injected clock accumulates durations", function()
       local t = 0
@@ -872,14 +872,14 @@ describe("feature", function()
       assert.is_truthy(string.match(sent["traceparent"], "^00%-.+%-.+%-01$"))
     end)
 
-    it("records a failed span on error", function()
+    if has_feature("netsim") then it("records a failed span on error", function()
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 1, failStatus = 500 } },
         { name = "telemetry", options = {} },
       } })
       h.op({ op = "load" })
       assert.is_false(h.client._telemetry.spans[1].ok)
-    end)
+    end) end
 
     it("default id generation and no exporter", function()
       local h = make_client({ features = { { name = "telemetry" } } })
@@ -925,14 +925,14 @@ describe("feature", function()
       assert.are.equal("<redacted>", seen[1].headers.authorization)
     end)
 
-    it("captures failures", function()
+    if has_feature("netsim") then it("captures failures", function()
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 1, failStatus = 500 } },
         { name = "debug", options = {} },
       } })
       h.op({ op = "load" })
       assert.is_false(h.client._debug.entries[1].ok)
-    end)
+    end) end
 
     it("injected clock + custom redact", function()
       local h = make_client({ features = {
@@ -957,7 +957,7 @@ describe("feature", function()
   -- audit -----------------------------------------------------------------
   if has_feature("audit") then describe("audit", function()
 
-    it("one record per op with sink + actor", function()
+    if has_feature("netsim") then it("one record per op with sink + actor", function()
       local sink = {}
       local h = make_client({ features = {
         { name = "netsim", options = { failTimes = 1, failStatus = 500 } },
@@ -972,7 +972,7 @@ describe("feature", function()
       assert.are.equal("svc", recs[1].actor)
       assert.are.equal("per-call", recs[2].actor)
       assert.are.equal(2, #sink)
-    end)
+    end) end
 
     it("default actor is anonymous", function()
       local h = make_client({ features = { { name = "audit" } } })

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

@@ -75,11 +75,13 @@ local function make_options_util(ctx)
 
   local optspec = {
     apikey = "",
+    secret = "",
     base = "http://localhost:8000",
     prefix = "",
     suffix = "",
     auth = {
       prefix = "",
+      basic = false,
     },
     headers = {
       ["`$CHILD`"] = "`$STRING`",

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

@@ -592,6 +592,235 @@ let audit_feature () : feature =
         | _ -> ());
   f
 
+(* ------------------------------------------------------------------ *)
+(* cost                                                                *)
+(* ------------------------------------------------------------------ *)
+(* Prices every transport ATTEMPT and commits the spend once per
+   OPERATION. Mirrors tm/ts/src/feature/cost/CostFeature.ts; the corpus
+   cases are .sdk/test/feature/cost.aon.
+
+   ORDER MATTERS. Cost must sit INSIDE the cache, or a response served from
+   cache is charged for money that was never spent. Activate in array form
+   with cost first: [{ name: 'cost' }, { name: 'cache' }]. *)
+
+let cost_feature () : feature =
+  let options = ref (empty_map ()) in
+  (* Per-context accumulation: attempts are priced as they happen and the
+     total is committed once, at PreDone. *)
+  let pending : (string, value) Hashtbl.t = Hashtbl.create 8 in
+  let seq = ref 0 in
+  let f = { f_name = "cost"; f_version = "0.0.1"; f_active = true; f_options = Noval;
+            f_init = (fun _ _ -> ()); f_hook = (fun _ _ -> ()) } in
+
+  let per_unit () = opt_num !options "perUnit" ~default:0. in
+  let limit () = opt_num !options "budget" ~default:0. in
+
+  let record ctx =
+    let cl = cc ctx in
+    track_bucket cl "cost" (fun () ->
+        jo [("currency", Str (opt_str !options "currency" ~default:"USD"));
+            ("total", jo [("calls", Num 0.); ("attempts", Num 0.); ("amount", Num 0.);
+                          ("reported", Num 0.); ("estimated", Num 0.)]);
+            ("ops", empty_map ()); ("actors", empty_map ());
+            ("budget", jo [("limit", Num (limit ())); ("spent", Num 0.);
+                           ("remaining", Num (limit ())); ("exceeded", Bool false)]);
+            ("last", Noval)]) in
+
+  let new_pending () =
+    jo [("attempts", Num 0.); ("amount", Num 0.); ("reported", Num 0.);
+        ("estimated", Num 0.); ("source", Str "none"); ("piped", Bool false)] in
+
+  let pending_for ctx =
+    match Hashtbl.find_opt pending ctx.c_id with
+    | Some p -> p
+    | None -> let p = new_pending () in Hashtbl.replace pending ctx.c_id p; p in
+
+  (* A header figure is server-stated, so it beats the table and the unit. *)
+  let price_header res =
+    let name = opt_str !options "header" ~default:"" in
+    if name = "" then None
+    else match header_ci (getp res "headers") name with
+      | Noval | Null -> None
+      | v -> (match float_of_string_opt (vstr_of v) with
+          | Some n -> Some (n *. per_unit (), "header")
+          | None -> None) in
+
+  (* Same lookup grammar as rbac's rules: '<entity>.<op>', then '<op>',
+     then '*'. *)
+  let price_rate ctx =
+    let rates = match getp !options "rates" with Map _ as m -> m | _ -> empty_map () in
+    let entity = match ctx.c_entity with
+      | Some e -> e.e_name
+      | None -> ctx.c_op.op_entity in
+    let opname = ctx.c_op.op_name in
+    let pick k = match getp rates k with Num n -> Some n | _ -> None in
+    match pick (entity ^ "." ^ opname) with
+    | Some n -> Some (n, "table")
+    | None -> (match pick opname with
+        | Some n -> Some (n, "table")
+        | None -> (match pick "*" with Some n -> Some (n, "table") | None -> None)) in
+
+  let price ctx res =
+    match price_header res with
+    | Some p -> p
+    | None ->
+      match price_rate ctx with
+      | Some p -> p
+      | None ->
+        let unit = opt_num !options "unit" ~default:0. in
+        if unit <> 0. then (unit, "unit") else (0., "none") in
+
+  (* A usage figure from the parsed result body, priced by perUnit. Read at
+     commit, not at the transport seam, because the body is one-shot. *)
+  let price_body ctx =
+    let path = opt_str !options "path" ~default:"" in
+    if path = "" then None
+    else match ctx.c_result with
+      | None -> None
+      | Some rt ->
+        (match rt.rt_body with
+         | Map _ ->
+           (match getpath_s rt.rt_body path with
+            | Num n -> Some (n *. per_unit ())
+            | Str s -> (match float_of_string_opt s with
+                | Some n -> Some (n *. per_unit ()) | None -> None)
+            | _ -> None)
+         | _ -> None) in
+
+  let spend rec_ amount reported estimated =
+    let total = getp rec_ "total" in
+    bump_num total "amount" amount;
+    bump_num total "reported" reported;
+    bump_num total "estimated" estimated;
+    let budget = getp rec_ "budget" in
+    let lim = match getp budget "limit" with Num n -> n | _ -> 0. in
+    let spent = match getp total "amount" with Num n -> n | _ -> 0. in
+    setp budget "spent" (Num spent);
+    setp budget "remaining" (Num (if lim > 0. then max 0. (lim -. spent) else 0.));
+    if lim > 0. && spent >= lim then setp budget "exceeded" (Bool true) in
+
+  let bump bucket key amount =
+    let b = match getp bucket key with
+      | Map _ as m -> m
+      | _ -> let m = jo [("calls", Num 0.); ("amount", Num 0.)] in setp bucket key m; m in
+    bump_num b "calls" 1.;
+    bump_num b "amount" amount in
+
+  let commit ctx p entity opname =
+    let rec_ = record ctx in
+    let amount = ref (match getp p "amount" with Num n -> n | _ -> 0.) in
+    let reported = ref (match getp p "reported" with Num n -> n | _ -> 0.) in
+    let estimated = ref (match getp p "estimated" with Num n -> n | _ -> 0.) in
+    let source = ref (vstr_of (getp p "source")) in
+
+    (* A body figure prices the whole call, so it REPLACES the per-attempt
+       estimate rather than adding to it - and, being server-stated, the
+       whole amount counts as reported. *)
+    (match price_body ctx with
+     | Some b -> amount := b; reported := b; estimated := 0.; source := "body"
+     | None -> ());
+
+    spend rec_ !amount !reported !estimated;
+
+    let actor = match ctx.c_ctrl.ctrl_actor with
+      | Str a when a <> "" -> a
+      | _ -> opt_str !options "actor" ~default:"anonymous" in
+
+    bump_num (getp rec_ "total") "calls" 1.;
+    bump (getp rec_ "ops") (entity ^ "." ^ opname) !amount;
+    bump (getp rec_ "actors") actor !amount;
+
+    incr seq;
+    setp rec_ "last"
+      (jo [("seq", Num (float_of_int !seq)); ("entity", Str entity); ("op", Str opname);
+           ("actor", Str actor); ("amount", Num !amount);
+           ("currency", getp rec_ "currency"); ("source", Str !source);
+           ("attempts", getp p "attempts")]) in
+
+  let finish ctx done_ =
+    if f.f_active then
+      match Hashtbl.find_opt pending ctx.c_id with
+      | None -> ()
+      | Some p ->
+        Hashtbl.remove pending ctx.c_id;
+        let attempts = match getp p "attempts" with Num n -> n | _ -> 0. in
+        (* A FAILED operation that made no attempt never reached the network:
+           the budget gate (or rbac, or an unresolvable endpoint) refused it.
+           Committing would count a call that never happened.
+
+           A SUCCEEDED operation that made no attempt is the opposite case: it
+           was served from the cache. That is a real call, and the fact that it
+           cost nothing is the whole point of ordering cost inside the cache. *)
+        if done_ || attempts > 0. then begin
+          let entity = if ctx.c_op.op_entity <> "" then ctx.c_op.op_entity else "_" in
+          let opname = if ctx.c_op.op_name <> "" then ctx.c_op.op_name else "_" in
+          commit ctx p entity opname
+        end in
+
+  let charge ctx url fetchdef inner =
+    (* A rejecting transport still costs an attempt: without this a run of
+       connection-level failures under `retry` would be charged nothing, and
+       an onBudget: 'deny' ceiling could never stop it. *)
+    let (res, err) = inner ctx url fetchdef in
+    let (amount, source) = price ctx res in
+    let p = pending_for ctx in
+    bump_num p "attempts" 1.;
+    bump_num p "amount" amount;
+    bump_num p (if source = "header" || source = "body" then "reported" else "estimated") amount;
+    setp p "source" (Str source);
+    bump_num (getp (record ctx) "total") "attempts" 1.;
+
+    (* direct() and graphql() dispatch no pipeline hooks at all - no PrePoint
+       to gate on and no PreDone to commit - so their spend is committed here
+       or never. `piped` is set by PrePoint, so its absence is the signal. *)
+    if getp p "piped" <> Bool true then begin
+      Hashtbl.remove pending ctx.c_id;
+      commit ctx p "_" "direct"
+    end;
+    (res, err) in
+
+  f.f_init <- (fun ctx opts ->
+      options := (match to_map opts with Map _ -> opts | _ -> empty_map ());
+      f.f_active <- opt_active opts;
+      if f.f_active then begin
+        Hashtbl.reset pending;
+        seq := 0;
+        ignore (record ctx);
+        let u = cu ctx in
+        let inner = u.u_fetcher in
+        u.u_fetcher <- (fun fctx url fd -> charge fctx url fd inner)
+      end);
+
+  f.f_hook <- (fun name ctx ->
+      if f.f_active then
+        match name with
+        | "PrePoint" ->
+          (* Mark the context as piped, so charge knows a PreDone is coming. *)
+          let p = pending_for ctx in
+          setp p "piped" (Bool true);
+          let lim = limit () in
+          if lim > 0. then begin
+            let rec_ = record ctx in
+            let spent = match getp (getp rec_ "total") "amount" with Num n -> n | _ -> 0. in
+            if spent >= lim then begin
+              setp (getp rec_ "budget") "exceeded" (Bool true);
+              if opt_str !options "onBudget" ~default:"warn" = "deny" then begin
+                let err = ctx_make_error ctx "cost_budget"
+                    ("Cost budget of " ^ js_string (Num lim) ^ " " ^ vstr_of (getp rec_ "currency")
+                     ^ " is spent (" ^ js_string (Num spent) ^ " used)") in
+                Hashtbl.replace ctx.c_out "point" (OErr err)
+              end
+            end
+          end
+        | "PreDone" -> finish ctx true
+        (* A failed operation never reaches PreDone - make_error dispatches
+           PreUnexpected - so its attempts would be priced and discarded, and
+           repeated failures could slip past an onBudget "deny" ceiling.
+           `false` keeps a call that made NO attempt from being counted. *)
+        | "PreUnexpected" -> finish ctx false
+        | _ -> ());
+  f
+
 (* ------------------------------------------------------------------ *)
 (* clienttrack                                                         *)
 (* ------------------------------------------------------------------ *)

package/project/.sdk/tm/perl/t/feature_corpus.t

@@ -29,9 +29,10 @@ unless (defined $TEST_JSON && -e $TEST_JSON) {
   plan skip_all => 'test.json corpus not found';
 }
 
-# Features with a corpus section. A name here with no section is a skip, not
-# a failure: an SDK generated without the feature has nothing to run.
-my @FEATURE_CORPUS_NAMES = ('cost');
+# Features with a corpus section are read from the corpus itself (see the
+# loop below), so a project-authored section - a custom feature added under
+# .sdk/test/feature/ - runs without editing this file. An SDK generated
+# without a listed feature still skips, not fails.
 
 # The standard operation names, in the order the runner prefers them.
 my @FEATURE_CORPUS_OPS = qw(load list create update remove);
@@ -144,7 +145,15 @@ sub candidates {
       };
     }
   }
-  return @out;
+
+  # SAFE OPS FIRST - see the ts harness for the reasoning: the cache stores
+  # only successful GETs, so an SDK whose first usable op is a `create`
+  # (POST) can never satisfy "a hit served from cache costs nothing".
+  my %safe = (list => 0, load => 1);
+  return sort {
+    ($safe{ $a->{op} } // 2) <=> ($safe{ $b->{op} } // 2)
+      || $a->{key} cmp $b->{key}
+  } @out;
 }
 
 
@@ -274,7 +283,7 @@ ok(scalar(@ops) > 0,
   exit 0;
 };
 
-for my $name (@FEATURE_CORPUS_NAMES) {
+for my $name (sort keys %{ $CORPUS->{feature} || {} }) {
   my $section = ($CORPUS->{feature} || {})->{$name};
   next unless defined $section;
 

package/project/.sdk/tm/php/feature/TestFeature.php

@@ -69,10 +69,16 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                 if (!is_string($restf)) {
                     return $data;
                 }
-                if (!preg_match('/^`body\.([^`.]+)`$/', $restf, $m)) {
+                if (!preg_match('/^`body\.(.+)`$/', $restf, $m)) {
                     return $data;
                 }
-                return [$m[1] => $data];
+                // Multi-segment on purpose: GraphQL ops unwrap body.data.<field>
+                // (and body.data.<field>.<entity> for mutations), not just one level.
+                $out = $data;
+                foreach (array_reverse(explode('.', $m[1])) as $seg) {
+                    $out = [$seg => $out];
+                }
+                return $out;
             };
 
             $respond = function (int $status, mixed $data, ?array $extra = null) use ($envelope): array {
@@ -433,13 +439,18 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                     }
                 }
             }
+            // Path AND query: a path-only read misses a query-addressed
+            // record (e.g. GET /result?trace_id=), which has no path param.
             $params = is_array($point) ? ($point['args']['params'] ?? null) : null;
-            if (is_array($params)) {
-                foreach ($params as $p) {
-                    if (is_array($p) && (($p['reqd'] ?? false) === true)) {
-                        $n = $p['name'] ?? null;
-                        if ($n !== null) {
-                            $reqd_names[] = $n;
+            $query = is_array($point) ? ($point['args']['query'] ?? null) : null;
+            foreach ([$params, $query] as $arglist) {
+                if (is_array($arglist)) {
+                    foreach ($arglist as $p) {
+                        if (is_array($p) && (($p['reqd'] ?? false) === true)) {
+                            $n = $p['name'] ?? null;
+                            if ($n !== null) {
+                                $reqd_names[] = $n;
+                            }
                         }
                     }
                 }

package/project/.sdk/tm/php/test/FeatureCorpusTest.php

@@ -23,9 +23,10 @@ use PHPUnit\Framework\TestCase;
 
 class FeatureCorpusTest extends TestCase
 {
-    // Features with a corpus section. A name here with no section is a skip,
-    // not a failure: an SDK generated without the feature has nothing to run.
-    private const FEATURE_CORPUS_NAMES = ['cost'];
+    // Features with a corpus section are read from the corpus itself (see
+    // testFeatureCorpus), so a project-authored section - a custom feature
+    // added under .sdk/test/feature/ - runs without editing this file. An
+    // SDK generated without a listed feature still skips, not fails.
 
     // The standard operation names, in the order the runner prefers them.
     private const FEATURE_CORPUS_OPS = ['load', 'list', 'create', 'update', 'remove'];
@@ -145,6 +146,17 @@ class FeatureCorpusTest extends TestCase
                 }
             }
         }
+
+        // SAFE OPS FIRST — see the ts harness for the reasoning: the cache
+        // stores only successful GETs, so an SDK whose first usable op is a
+        // `create` (POST) can never satisfy "a hit served from cache costs
+        // nothing".
+        $safe = ['list' => 0, 'load' => 1];
+        usort($out, function ($a, $b) use ($safe) {
+            $ra = $safe[$a['op']] ?? 2;
+            $rb = $safe[$b['op']] ?? 2;
+            return $ra === $rb ? strcmp($a['key'], $b['key']) : $ra - $rb;
+        });
         return $out;
     }
 
@@ -289,7 +301,9 @@ class FeatureCorpusTest extends TestCase
                 . 'the corpus (create-sdkgen .sdk/test/feature/) to run these cases');
         }
 
-        foreach (self::FEATURE_CORPUS_NAMES as $name) {
+        $names = array_keys(self::corpus()['feature'] ?? []);
+        sort($names);
+        foreach ($names as $name) {
             $section = self::corpus()['feature'][$name] ?? null;
             if (null === $section) {
                 continue;

package/project/.sdk/tm/php/utility/MakeOptions.php

@@ -130,10 +130,11 @@ class ProjectNameMakeOptions
 
         $optspec = [
             'apikey' => '',
+            'secret' => '',
             'base' => 'http://localhost:8000',
             'prefix' => '',
             'suffix' => '',
-            'auth' => ['prefix' => ''],
+            'auth' => ['prefix' => '', 'basic' => false],
             'headers' => ['`$CHILD`' => '`$STRING`'],
             'allow' => [
                 'method' => 'GET,PUT,POST,PATCH,DELETE,OPTIONS',

package/project/.sdk/tm/py/pkg/feature/test_feature.py

@@ -11,7 +11,7 @@ from projectname_sdk.feature.base_feature import ProjectNameBaseFeature
 
 # The `body.<key>` form of an op's response transform: the mock wraps its
 # payload in <key> so the transform can unwrap it again.
-ENVELOPE_RES_RE = re.compile(r"^`body\.([^`.]+)`$")
+ENVELOPE_RES_RE = re.compile(r"^`body\.(.+)`$")
 
 
 class ProjectNameTestFeature(ProjectNameBaseFeature):
@@ -60,7 +60,14 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                 if not isinstance(restf, str):
                     return data
                 m = ENVELOPE_RES_RE.match(restf)
-                return data if m is None else {m.group(1): data}
+                if m is None:
+                    return data
+                # Multi-segment on purpose: GraphQL ops unwrap body.data.<field>
+                # (and body.data.<field>.<entity> for mutations), not just one level.
+                out = data
+                for seg in reversed(m.group(1).split(".")):
+                    out = {seg: out}
+                return out
 
             def respond(status, data, extra=None):
                 payload = envelope(data)
@@ -260,10 +267,14 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
         points = vs.getpath(ctx.config, "entity." + ctx.entity.get_name() + ".op." + opname + ".points")
         point = vs.getelem(points, -1)
 
-        # Get required params.
+        # 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 = vs.getpath(point, "args.params")
         reqd_params = vs.select(params_path, {"reqd": True})
-        reqd = vs.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"])
+        query_path = vs.getpath(point, "args.query")
+        reqd_query = vs.select(query_path, {"reqd": True})
+        reqd = (vs.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"]) or []) + \
+            (vs.transform(reqd_query, ["`$EACH`", "", "`$KEY.name`"]) or [])
 
         qand = []
         q = {"`$AND`": qand}

package/project/.sdk/tm/py/pkg/utility/make_options.py

@@ -97,11 +97,13 @@ def make_options_util(ctx):
 
     optspec = {
         "apikey": "",
+        "secret": "",
         "base": "http://localhost:8000",
         "prefix": "",
         "suffix": "",
         "auth": {
             "prefix": "",
+            "basic": False,
         },
         "headers": {
             "`$CHILD`": "`$STRING`",

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

@@ -165,6 +165,12 @@ class _Ctx:
         self.meta = {}
         self.op = op
         self.entity = entity
+        # The pipeline always resolves a point before a feature sees the ctx,
+        # so features read ctx.point freely — paging checks `point.kind` for
+        # graphql. This stub had no such attribute, so every paging test died
+        # with AttributeError before reaching the transport. Those tests were
+        # SKIPPED until an SDK activated paging, which is why it went unseen.
+        self.point = {}
         self.spec = None
         self.response = None
         self.result = None