@voxgig/sdkgen 4.23.0 → 4.24.1

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

@@ -12,6 +12,22 @@ class ProjectNameFetcher
     // Users can override by passing a User-Agent header in fetchdef.
     public const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)';
 
+    // One cURL handle per process, reset between calls rather than closed:
+    // curl_reset keeps the connection cache, so the next request to the
+    // same host reuses the open connection.
+    private static $curl = null;
+
+    private static function curlHandle(string $fullurl)
+    {
+        if (self::$curl === null) {
+            self::$curl = curl_init();
+        } else {
+            curl_reset(self::$curl);
+        }
+        curl_setopt(self::$curl, CURLOPT_URL, $fullurl);
+        return self::$curl;
+    }
+
     public static function defaultHttpFetch(string $fullurl, array $fetchdef): array
     {
         $method_str = strtoupper($fetchdef['method'] ?? 'GET');
@@ -130,7 +146,7 @@ class ProjectNameFetcher
             ];
         }
 
-        $ch = curl_init($fullurl);
+        $ch = self::curlHandle($fullurl);
         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
         curl_setopt($ch, CURLOPT_HEADER, false);
         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
@@ -157,7 +173,6 @@ class ProjectNameFetcher
         $response_body = curl_exec($ch);
         if ($response_body === false) {
             $err = curl_error($ch) ?: 'curl_exec failed';
-            curl_close($ch);
             return [
                 [
                     'status' => 0,
@@ -169,7 +184,6 @@ class ProjectNameFetcher
                 $err,
             ];
         }
-        curl_close($ch);
 
         $status = 0;
         $status_text = '';

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

@@ -22,7 +22,7 @@ class ProjectNamePrepareQuery
             foreach ($items as $item) {
                 $key = $item[0];
                 $val = $item[1];
-                if ($val !== null && is_string($key) && !in_array($key, $params, true)) {
+                if ($val !== null && is_string($key) && '$action' !== $key && !in_array($key, $params, true)) {
                     $out[$key] = $val;
                 }
             }

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

@@ -16,12 +16,24 @@ class ProjectNameTransformRequest
         }
         $transform = ProjectNameHelpers::to_map(\Voxgig\Struct\Struct::getprop($point, 'transform'));
         if (!$transform) {
-            return $ctx->reqdata;
+            return self::strip_action($ctx->reqdata);
         }
         $reqform = \Voxgig\Struct\Struct::getprop($transform, 'req');
         if (!$reqform) {
-            return $ctx->reqdata;
+            return self::strip_action($ctx->reqdata);
         }
-        return \Voxgig\Struct\Struct::transform(['reqdata' => $ctx->reqdata], $reqform);
+        return self::strip_action(\Voxgig\Struct\Struct::transform(['reqdata' => $ctx->reqdata], $reqform));
+    }
+
+    // `$action` selects the point (see MakePoint); it is never an API field,
+    // so the body is a copy without it. Arrays are values, so the unset
+    // never reaches the caller's copy.
+    private static function strip_action(mixed $reqdata): mixed
+    {
+        if (!is_array($reqdata) || !array_key_exists('$action', $reqdata)) {
+            return $reqdata;
+        }
+        unset($reqdata['$action']);
+        return $reqdata;
     }
 }

package/project/.sdk/tm/py/pkg/core/context.py

@@ -53,7 +53,8 @@ class ProjectNameContext:
                 self.ctrl.actor = ctrl_raw["actor"]
             if isinstance(ctrl_raw.get("paging"), dict):
                 self.ctrl.paging = ctrl_raw["paging"]
-        elif basectx is not None and basectx.ctrl is not None:
+        elif (basectx is not None and basectx.ctrl is not None
+              and get_ctx_prop(ctxmap, "opname") is None):
             self.ctrl = basectx.ctrl
 
         # Meta

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

@@ -12,8 +12,8 @@ from projectname_sdk.feature.base_feature import ProjectNameBaseFeature
 # stamps page/limit (or a cursor) into the request query; on the way back
 # (PreResult) it reads the server's pagination signals — a `Link:
 # rel="next"` header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-# `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records
-# them on `ctx.result.paging`. A per-call cursor/page supplied via ctrl
+# `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case forms
+# too) — and records them on `ctx.result.paging` and the caller's ctrl paging. A per-call cursor/page supplied via ctrl
 # paging takes priority (used by auto-iteration). Parameter names
 # (`pageParam`/`limitParam`/`cursorParam`), `startPage` and page size
 # (`limit`) are configurable.
@@ -66,7 +66,11 @@ class ProjectNamePagingFeature(ProjectNameBaseFeature):
         if paging.get("cursor") is not None:
             spec.query[cursor_param] = paging["cursor"]
         elif spec.query.get(page_param) is None:
-            page = paging.get("page")
+            # A record written back by PreResult holds the page just fetched
+            # as "page" and the one to fetch as "nextPage", so nextPage wins.
+            page = paging.get("nextPage")
+            if page is None:
+                page = paging.get("page")
             if page is None:
                 page = self.options.get("startPage") or 1
             spec.query[page_param] = page
@@ -166,14 +170,25 @@ class ProjectNamePagingFeature(ProjectNameBaseFeature):
                     paging["hasMore"] = more
                     explicit_more = True
 
-        # Body-level cursors.
+        # Body-level signals; snake_case forms are read first so camelCase wins.
         if isinstance(body, dict):
             if body.get("next") is not None:
                 paging["next"] = paging["next"] or body["next"]
+            if body.get("next_cursor") is not None:
+                paging["cursor"] = body["next_cursor"]
             if body.get("cursor") is not None:
                 paging["cursor"] = body["cursor"]
             if body.get("nextCursor") is not None:
                 paging["cursor"] = body["nextCursor"]
+            if paging["nextPage"] is None:
+                np = body.get("nextPage")
+                if np is None:
+                    np = body.get("next_page")
+                if isinstance(np, (int, float, str)) and not isinstance(np, bool):
+                    paging["nextPage"] = np
+            if isinstance(body.get("has_more"), bool):
+                paging["hasMore"] = body["has_more"]
+                explicit_more = True
             if isinstance(body.get("hasMore"), bool):
                 paging["hasMore"] = body["hasMore"]
                 explicit_more = True
@@ -191,6 +206,16 @@ class ProjectNamePagingFeature(ProjectNameBaseFeature):
 
         result.paging = paging
 
+        ctrl = ctx.ctrl
+        if ctrl is not None:
+            # The Context shares the caller's paging dict by reference, so
+            # refill it in place; a fresh dict on ctrl never reaches the caller.
+            if isinstance(getattr(ctrl, "paging", None), dict):
+                ctrl.paging.clear()
+                ctrl.paging.update(paging)
+            else:
+                ctrl.paging = paging
+
         self.client._paging = {"last": paging}
 
     def _is_list(self, ctx):

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

@@ -143,18 +143,11 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                 args = test_self.build_args(fctx, op, update_match)
                 found = vs.select(entmap, args)
                 ent = vs.getelem(found, 0)
-                if ent is None and isinstance(entmap, dict):
-                    for e in entmap.values():
-                        if isinstance(e, dict):
-                            ent = e
-                            break
                 if ent is None:
+                    # update miss: 404, never another record
                     return respond(404, None, {"statusText": "Not found"})
-                if isinstance(ent, dict):
-                    reqdata = fctx.reqdata
-                    if reqdata is not None:
-                        for k, v in reqdata.items():
-                            ent[k] = v
+                if isinstance(ent, dict) and isinstance(fctx.reqdata, dict):
+                    vs.merge([ent, fctx.reqdata])
                 vs.delprop(ent, "$KEY")
                 out = vs.clone(ent)
                 return respond(200, out)
@@ -260,12 +253,36 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
 
         return netsim_fetcher
 
+    # 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).
+    @staticmethod
+    def pick_point(points):
+        if not isinstance(points, list) or len(points) == 0:
+            return None
+
+        def terminal(p):
+            parts = vs.getprop(p, "parts")
+            return isinstance(parts, list) and len(parts) > 0 and \
+                isinstance(parts[-1], str) and parts[-1].startswith("{")
+
+        def depth(p):
+            parts = vs.getprop(p, "parts")
+            return len(parts) if isinstance(parts, list) else 0
+
+        point = points[0]
+        for cand in points[1:]:
+            if terminal(cand) != terminal(point):
+                if terminal(cand):
+                    point = cand
+            elif depth(cand) < depth(point):
+                point = cand
+        return point
+
     def build_args(self, ctx, op, args):
         opname = op.name
 
-        # Get last point from config.
         points = vs.getpath(ctx.config, "entity." + ctx.entity.get_name() + ".op." + opname + ".points")
-        point = vs.getelem(points, -1)
+        point = self.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/py/pkg/utility/fetcher.py

@@ -2,21 +2,37 @@
 
 from __future__ import annotations
 import json
+import threading
+from http.cookiejar import DefaultCookiePolicy
 from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 
 
 # Default User-Agent — many CDNs (notably Cloudflare) reject requests with
-# Python's default urllib UA ("Python-urllib/3.x"), returning 403 before
-# the request even reaches the origin. Set a Mozilla-shaped UA so the SDK
-# behaves like every other HTTP client by default. Users can still override
-# by passing a User-Agent header in fetchdef.
+# a library's default UA, returning 403 before the request even reaches
+# the origin. Set a Mozilla-shaped UA so the SDK behaves like every other
+# HTTP client by default. Users can still override by passing a User-Agent
+# header in fetchdef.
 _DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)"
 
 
-def _default_http_fetch(fullurl, fetchdef):
-    import urllib.request
-    import urllib.error
+_SESSION = None
+_SESSION_LOCK = threading.Lock()
+
+
+def _session():
+    # Pool connections without retaining response cookies between calls.
+    global _SESSION
+    if _SESSION is None:
+        import requests
+        with _SESSION_LOCK:
+            if _SESSION is None:
+                session = requests.Session()
+                session.cookies.set_policy(DefaultCookiePolicy(allowed_domains=[]))
+                _SESSION = session
+    return _SESSION
+
 
+def _default_http_fetch(fullurl, fetchdef):
     method = fetchdef.get("method", "GET")
     body_str = fetchdef.get("body")
     headers = fetchdef.get("headers", {})
@@ -26,76 +42,58 @@ def _default_http_fetch(fullurl, fetchdef):
 
     data = body_str.encode("utf-8") if body_str is not None else None
 
-    req = urllib.request.Request(fullurl, data=data, method=method)
+    req_headers = {}
     has_ua = False
     for k, v in headers.items():
         if k.lower() == "user-agent":
             has_ua = True
-        req.add_header(k, v)
+        req_headers[k] = v
     if not has_ua:
-        req.add_header("User-Agent", _DEFAULT_USER_AGENT)
+        req_headers["User-Agent"] = _DEFAULT_USER_AGENT
 
     # Manual redirects: fetchdef["redirect"] == "manual" surfaces a 3xx as
-    # an ordinary response instead of auto-following it — urllib would
-    # otherwise replay the request, headers included, against whatever host
-    # Location names. Set by the station feature's transport middleware
-    # under an egress hosts policy (mirrors the ts fetch option).
-    opener = None
-    if fetchdef.get("redirect") == "manual":
-        class _NoRedirect(urllib.request.HTTPRedirectHandler):
-            def redirect_request(self, req, fp, code, msg, headers, newurl):
-                return None
-        opener = urllib.request.build_opener(_NoRedirect)
+    # an ordinary response instead of auto-following it, which would replay
+    # the request, headers included, against whatever host Location names.
+    # Set by the station feature's transport middleware under an egress
+    # hosts policy (mirrors the ts fetch option).
+    kwargs = {"allow_redirects": fetchdef.get("redirect") != "manual"}
+
+    proxy = fetchdef.get("proxy")
+    if isinstance(proxy, str) and proxy:
+        kwargs["proxies"] = {"http": proxy, "https": proxy}
+
+    timeout = fetchdef.get("timeout")
+    if isinstance(timeout, (int, float)) and timeout > 0:
+        kwargs["timeout"] = timeout
 
     try:
-        resp = opener.open(req) if opener is not None else urllib.request.urlopen(req)
-        body = resp.read().decode("utf-8")
-        resp_headers = {}
-        for k, v in resp.getheaders():
-            resp_headers[k.lower()] = v
-
-        json_body = None
-        if len(body) > 0:
-            try:
-                json_body = json.loads(body)
-            except Exception:
-                pass
-
-        status = resp.getcode()
-        status_text = "OK" if status < 400 else "Error"
-
-        return {
-            "status": status,
-            "statusText": status_text,
-            "headers": resp_headers,
-            "json": lambda: json_body,
-            "body": body,
-        }, None
-    except urllib.error.HTTPError as e:
-        body = e.read().decode("utf-8")
-        resp_headers = {}
-        for k, v in e.headers.items():
-            resp_headers[k.lower()] = v
-
-        json_body = None
-        if len(body) > 0:
-            try:
-                json_body = json.loads(body)
-            except Exception:
-                pass
-
-        status_text = "OK" if e.code < 400 else "Error"
-
-        return {
-            "status": e.code,
-            "statusText": status_text,
-            "headers": resp_headers,
-            "json": lambda: json_body,
-            "body": body,
-        }, None
+        resp = _session().request(method, fullurl, data=data, headers=req_headers, **kwargs)
+        body = resp.content.decode("utf-8")
     except Exception as e:
         return None, str(e)
 
+    resp_headers = {}
+    for k, v in resp.headers.items():
+        resp_headers[k.lower()] = v
+
+    json_body = None
+    if len(body) > 0:
+        try:
+            json_body = json.loads(body)
+        except Exception:
+            pass
+
+    status = resp.status_code
+    status_text = resp.reason or ("OK" if status < 400 else "Error")
+
+    return {
+        "status": status,
+        "statusText": status_text,
+        "headers": resp_headers,
+        "json": lambda: json_body,
+        "body": body,
+    }, None
+
 
 def fetcher_util(ctx, fullurl, fetchdef):
     if ctx.client.mode != "live":

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

@@ -27,7 +27,8 @@ def prepare_query_util(ctx):
         for item in reqmatch_items:
             key = item[0]
             val = item[1]
-            if val is not None and isinstance(key, str) and not _contains_param(params, key):
+            if val is not None and isinstance(key, str) and key != "$action" \
+                    and not _contains_param(params, key):
                 out[key] = val
 
     return out

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

@@ -5,6 +5,14 @@ from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 from projectname_sdk.core.helpers import to_map
 
 
+# `$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 dict is left untouched.
+def _strip_action(reqdata):
+    if not isinstance(reqdata, dict) or "$action" not in reqdata:
+        return reqdata
+    return {k: v for k, v in reqdata.items() if k != "$action"}
+
+
 def transform_request_util(ctx):
     spec = ctx.spec
     point = ctx.point
@@ -14,14 +22,14 @@ def transform_request_util(ctx):
 
     transform = to_map(vs.getprop(point, "transform"))
     if transform is None:
-        return ctx.reqdata
+        return _strip_action(ctx.reqdata)
 
     reqform = vs.getprop(transform, "req")
     if reqform is None:
-        return ctx.reqdata
+        return _strip_action(ctx.reqdata)
 
     reqdata = vs.transform({
         "reqdata": ctx.reqdata,
     }, reqform)
 
-    return reqdata
+    return _strip_action(reqdata)

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

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

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

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