@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -28,6 +28,9 @@ class ProjectNameResponse:
 
         self.body = vs.getprop(resmap, "body")
 
+        # Set by a transport that could not read a non-blank body as JSON.
+        self.unreadable = vs.getprop(resmap, "unreadable") is True
+
         self.err = None
         e = vs.getprop(resmap, "err")
         if e is not None:

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

@@ -21,3 +21,6 @@ class ProjectNameSpec:
         self.body = specmap.get("body")
         self.url = specmap.get("url", "")
         self.path = specmap.get("path", "")
+        # The query parameters prepare_auth placed: the credential, which the
+        # request sends and the entity's match leaves out.
+        self.authquery = specmap.get("authquery", [])

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

@@ -13,6 +13,27 @@ from projectname_sdk.feature.base_feature import ProjectNameBaseFeature
 # payload in <key> so the transform can unwrap it again.
 ENVELOPE_RES_RE = re.compile(r"^`body\.(.+)`$")
 
+# The key a list's response transform
+# ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+ITEM_ENVELOPE_RE = re.compile(r"^`\.([^.`$]+)`$")
+
+
+def item_envelope_key(restf):
+    if not isinstance(restf, list) or 3 != len(restf) or \
+            "`$EACH`" != restf[0] or "body" != restf[1]:
+        return None
+    merge = restf[2].get("`$MERGE`") if isinstance(restf[2], dict) else None
+    m = ITEM_ENVELOPE_RE.match(merge) if isinstance(merge, str) else None
+    return None if m is None else m.group(1)
+
+
+# The record the mock keeps: the request data without `$body`, which only the
+# wire carries.
+def _record(reqdata):
+    if not isinstance(reqdata, dict):
+        return reqdata
+    return {k: v for k, v in reqdata.items() if k != "$body"}
+
 
 class ProjectNameTestFeature(ProjectNameBaseFeature):
     def __init__(self):
@@ -57,6 +78,9 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                 if not isinstance(transform, dict):
                     return data
                 restf = transform.get("res")
+                key = item_envelope_key(restf)
+                if key is not None and isinstance(data, list):
+                    return [{key: item} for item in data]
                 if not isinstance(restf, str):
                     return data
                 m = ENVELOPE_RES_RE.match(restf)
@@ -121,7 +145,7 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                 out = vs.clone(found)
                 return respond(200, out)
 
-            elif op.name == "update":
+            elif op.name == "update" or op.name == "patch":
                 # Match the existing entity by id only (or its alias). reqdata
                 # also contains the new field values, which would otherwise
                 # cause select to filter out the entity we want to update.
@@ -147,7 +171,7 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                     # update miss: 404, never another record
                     return respond(404, None, {"statusText": "Not found"})
                 if isinstance(ent, dict) and isinstance(fctx.reqdata, dict):
-                    vs.merge([ent, fctx.reqdata])
+                    vs.merge([ent, _record(fctx.reqdata)])
                 vs.delprop(ent, "$KEY")
                 out = vs.clone(ent)
                 return respond(200, out)
@@ -171,7 +195,7 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                         random.randint(0, 0xFFFF), random.randint(0, 0xFFFF),
                         random.randint(0, 0xFFFF), random.randint(0, 0xFFFF))
 
-                ent = vs.clone(fctx.reqdata)
+                ent = vs.clone(_record(fctx.reqdata))
                 if isinstance(ent, dict):
                     ent["id"] = eid
                     if isinstance(eid, str):

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

@@ -184,6 +184,8 @@ class ProjectNameValidateFeature(ProjectNameBaseFeature):
         # custom-action call would be rejected for the one key that made it
         # reachable.
         out.pop("$action", None)
+        # Nor is `$body`, the raw request body.
+        out.pop("$body", None)
 
         return out
 

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 import base64
 import json
+import threading
 from urllib.parse import quote
 
 from projectname_sdk.schema import OPTSPEC
@@ -113,20 +114,23 @@ def _forms(value):
     return out
 
 
+# Requests on other threads clean while one registers, so a registration
+# publishes a new list and never changes a published one.
+_REGISTERING = threading.Lock()
+
+
 # Register a secret value. Idempotent; shorter than `min` is not a secret
 # the SDK can mask without blanking ordinary text.
 def clean_add_util(ctx, value):
     cfg = _clean_config(ctx)
     if not isinstance(value, str) or len(value) < cfg["min"]:
         return
-    values = cfg["values"]
-    changed = False
-    for form in _forms(value):
-        if len(form) >= cfg["min"] and form not in values:
-            values.append(form)
-            changed = True
-    if changed:
-        values.sort(key=len, reverse=True)
+    with _REGISTERING:
+        values = cfg["values"]
+        added = [form for form in _forms(value)
+                 if len(form) >= cfg["min"] and form not in values]
+        if added:
+            cfg["values"] = sorted(values + added, key=len, reverse=True)
 
 
 # Every scalar under a sensitive name, at any depth and of any shape: a

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

@@ -32,15 +32,22 @@ def _session():
     return _SESSION
 
 
+# Text as UTF-8, and bytes or a file object as they are.
+def _request_data(body):
+    if isinstance(body, str):
+        return body.encode("utf-8")
+    if isinstance(body, (bytearray, memoryview)):
+        return bytes(body)
+    if isinstance(body, bytes) or hasattr(body, "read"):
+        return body
+    return None
+
+
 def _default_http_fetch(fullurl, fetchdef):
     method = fetchdef.get("method", "GET")
-    body_str = fetchdef.get("body")
     headers = fetchdef.get("headers", {})
 
-    if not isinstance(body_str, str):
-        body_str = None
-
-    data = body_str.encode("utf-8") if body_str is not None else None
+    data = _request_data(fetchdef.get("body"))
 
     req_headers = {}
     has_ua = False
@@ -50,6 +57,7 @@ def _default_http_fetch(fullurl, fetchdef):
         req_headers[k] = v
     if not has_ua:
         req_headers["User-Agent"] = _DEFAULT_USER_AGENT
+        headers["user-agent"] = _DEFAULT_USER_AGENT
 
     # Manual redirects: fetchdef["redirect"] == "manual" surfaces a 3xx as
     # an ordinary response instead of auto-following it, which would replay
@@ -77,11 +85,12 @@ def _default_http_fetch(fullurl, fetchdef):
         resp_headers[k.lower()] = v
 
     json_body = None
-    if len(body) > 0:
+    unreadable = False
+    if body.strip():
         try:
             json_body = json.loads(body)
         except Exception:
-            pass
+            unreadable = True
 
     status = resp.status_code
     status_text = resp.reason or ("OK" if status < 400 else "Error")
@@ -92,6 +101,7 @@ def _default_http_fetch(fullurl, fetchdef):
         "headers": resp_headers,
         "json": lambda: json_body,
         "body": body,
+        "unreadable": unreadable,
     }, None
 
 

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

@@ -1,7 +1,7 @@
 # ProjectName SDK utility: make_fetch_def
 
 from __future__ import annotations
-from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
+from projectname_sdk.utility.media import request_body
 
 
 def make_fetch_def_util(ctx):
@@ -29,9 +29,6 @@ def make_fetch_def_util(ctx):
     }
 
     if spec.body is not None:
-        if isinstance(spec.body, dict):
-            fetchdef["body"] = vs.jsonify(spec.body)
-        else:
-            fetchdef["body"] = spec.body
+        fetchdef["body"] = request_body(ctx.point, spec.body)
 
     return fetchdef, None

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

@@ -248,20 +248,26 @@ def make_options_util(ctx):
 
 # A feature's name is not a field name: only the sensitive names inside its
 # settings count, so `secrets` does not make every setting a secret. Entity
-# blocks (per-entity settings, seeded records) hold no credential.
+# blocks (per-entity settings, seeded records) hold no credential, and nor do
+# rbac's rules, keyed by entity and operation names.
 def _clean_add_options(cleanctx, opts):
     top = {k: v for k, v in opts.items() if k not in ("feature", "entity")}
     if "test" in top:
-        top["test"] = _no_entity(top["test"])
+        top["test"] = _plain(top["test"], None)
     clean_add_sensitive(cleanctx, top)
     feature = opts.get("feature")
-    blocks = feature.values() if isinstance(feature, dict) else (
-        feature if isinstance(feature, list) else [feature])
-    for fopts in blocks:
-        clean_add_sensitive(cleanctx, _no_entity(fopts))
+    if isinstance(feature, dict):
+        blocks = list(feature.items())
+    elif isinstance(feature, list):
+        blocks = [(b.get("name") if isinstance(b, dict) else None, b) for b in feature]
+    else:
+        blocks = [(None, feature)]
+    for name, fopts in blocks:
+        clean_add_sensitive(cleanctx, _plain(fopts, name))
 
 
-def _no_entity(block):
+def _plain(block, name):
     if isinstance(block, dict):
-        return {k: v for k, v in block.items() if k != "entity"}
+        omit = ("entity", "rules") if "rbac" == name else ("entity",)
+        return {k: v for k, v in block.items() if k not in omit}
     return block

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

@@ -1,8 +1,15 @@
 # ProjectName SDK utility: make_point
 
 from __future__ import annotations
+import re
+
 from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 from projectname_sdk.core.helpers import to_map
+from projectname_sdk.utility.param import param_value
+from projectname_sdk.utility.prepare_method import allowed
+
+
+_PATH_PARAM = re.compile(r"\{([^{}/]+)\}")
 
 
 def _parts_len(point):
@@ -37,6 +44,18 @@ def _own_point(points):
     return best
 
 
+def _unfilled(ctx, point):
+    # The path parameters of a point that neither the call nor the entity
+    # gives a value for, looked up as prepare_params looks them up.
+    missing = []
+    parts = vs.getprop(point, "parts")
+    for part in (parts if isinstance(parts, list) else []):
+        found = _PATH_PARAM.fullmatch(str(part))
+        if found is not None and param_value(ctx, point, found.group(1)) is None:
+            missing.append(found.group(1))
+    return missing
+
+
 def make_point_util(ctx):
     pre = ctx.out.get("point")
     if pre is not None:
@@ -51,11 +70,11 @@ def make_point_util(ctx):
     op = ctx.op
     options = ctx.options
 
-    allow_op = vs.getpath(options, "allow.op") or ""
-    if isinstance(allow_op, str) and op.name not in allow_op:
+    allow_op = vs.getpath(options, "allow.op")
+    if not allowed(allow_op, op.name):
         return None, ctx.make_error("point_op_allow",
             'Operation "' + op.name +
-            '" not allowed by SDK option allow.op value: "' + allow_op + '"')
+            '" not allowed by SDK option allow.op value: "' + str(allow_op) + '"')
 
     if len(op.points) == 0:
         return None, ctx.make_error("point_no_points",
@@ -117,7 +136,24 @@ def make_point_util(ctx):
                     'Operation "' + op.name + '" action "' +
                     vs.stringify(req_action) + '" is not valid.')
 
-            point = _own_point(op.points)
+            # A call without an action falls back to a point without one, as
+            # generation does, and only to a route the call can fill.
+            plain = [cand for cand in op.points
+                     if vs.getprop(to_map(vs.getprop(cand, "select")), "$action") is None]
+            if 0 == len(plain):
+                return None, ctx.make_error("point_action_required",
+                    'Operation "' + op.name +
+                    '" has only action endpoints; pass $action to choose one.')
+
+            fillable = [cand for cand in plain if 0 == len(_unfilled(ctx, cand))]
+
+            if 0 == len(fillable):
+                return None, ctx.make_error("point_no_match",
+                    'Operation "' + op.name +
+                    '" has no endpoint whose path parameters are all given (missing: ' +
+                    ", ".join(_unfilled(ctx, _own_point(plain))) + ').')
+
+            point = _own_point(fillable)
 
         if reqselector is not None:
             req_action = vs.getprop(reqselector, "$action")

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 from projectname_sdk.core.spec import ProjectNameSpec
 from projectname_sdk.utility.graphql import GRAPHQL_CONTENT_TYPE
+from projectname_sdk.utility.prepare_method import allowed
 
 
 def make_spec_util(ctx):
@@ -50,11 +51,11 @@ def make_spec_util(ctx):
 
     ctx.spec.method = utility.prepare_method(ctx)
 
-    allow_method = vs.getpath(options, "allow.method") or ""
-    if isinstance(allow_method, str) and ctx.spec.method not in allow_method:
+    allow_method = vs.getpath(options, "allow.method")
+    if not allowed(allow_method, ctx.spec.method):
         return None, ctx.make_error("spec_method_allow",
-            'Method "' + ctx.spec.method +
-            '" not allowed by SDK option allow.method value: "' + allow_method + '"')
+            'Method "' + str(ctx.spec.method) +
+            '" not allowed by SDK option allow.method value: "' + str(allow_method) + '"')
 
     ctx.spec.params = utility.prepare_params(ctx)
     ctx.spec.query = utility.prepare_query(ctx)
@@ -79,9 +80,16 @@ def make_spec_util(ctx):
     if ctx.ctrl.explain is not None:
         ctx.ctrl.explain["spec"] = ctx.spec
 
+    # Whatever prepare_auth sets in the query, under whichever name, is the
+    # credential; a key it leaves as it was is the caller's.
+    query = dict(ctx.spec.query or {})
+
     spec, err = utility.prepare_auth(ctx)
     if err is not None:
         return None, err
 
+    spec.authquery = [k for k, v in (spec.query or {}).items()
+                      if k not in query or query[k] != v]
+
     ctx.spec = spec
     return spec, None

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

@@ -1,9 +1,14 @@
 # ProjectName SDK utility: make_url
 
 from __future__ import annotations
+import re
+
 from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 
 
+_PLACEHOLDER = re.compile(r"\{[^{}/]+\}")
+
+
 def make_url_util(ctx):
     spec = ctx.spec
     result = ctx.result
@@ -18,6 +23,9 @@ def make_url_util(ctx):
     url = vs.join([spec.base, spec.prefix, spec.path, spec.suffix], "/", True)
     resmatch = {}
 
+    # Sent with the request, never recorded as the entity's match.
+    authquery = getattr(spec, "authquery", None) or []
+
     # A route the definition ends with a slash keeps it: a server such as a
     # Django REST one redirects or refuses the route without it.
     orig = vs.getprop(ctx.point, "orig") if ctx.point is not None else None
@@ -36,6 +44,15 @@ def make_url_util(ctx):
                 url = url.replace("{" + key + "}", encoded)
                 resmatch[key] = val
 
+    # A placeholder left in the route would send the request to the wrong route.
+    # The base's own placeholders are server variables, resolved with the options.
+    base = spec.base.rstrip("/") if isinstance(spec.base, str) else ""
+    route = url[len(base):] if url.startswith(base) else url
+    unfilled = _PLACEHOLDER.findall(route)
+    if 0 < len(unfilled):
+        return "", ctx.make_error("url_param_missing",
+            "URL path has no value for " + ", ".join(unfilled) + ".")
+
     # Append query string from spec.query.
     qsep = "?"
     query_items = vs.items(getattr(spec, "query", None))
@@ -47,7 +64,8 @@ def make_url_util(ctx):
                 val_str = val if isinstance(val, str) else str(val)
                 url += qsep + vs.escurl(key) + "=" + vs.escurl(val_str)
                 qsep = "&"
-                resmatch[key] = val
+                if key not in authquery:
+                    resmatch[key] = val
 
     result.resmatch = resmatch
 

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

@@ -0,0 +1,88 @@
+# ProjectName SDK utility: media
+
+# The media types a point declares: `response` (the model's `rs`) for the
+# Accept header, and `body` (the model's `rb`) for the request body.
+
+from __future__ import annotations
+from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
+
+
+# The data key holding a raw request body. Like `$action`, it can never be a
+# declared argument name.
+RAW_BODY = "$body"
+
+
+def is_json_media(media):
+    m = str(media if media is not None else "").split(";")[0].strip().lower()
+    return m == "application/json" or m == "text/json" or m.endswith("+json")
+
+
+# The declared JSON type alone, else every declared type in the model's
+# order; None when no success response declares a body.
+def accept_of(point):
+    res = vs.getprop(point, "response")
+    media = vs.getprop(res, "media")
+    if not isinstance(media, str) or media == "":
+        return None
+    if vs.getprop(res, "kind") == "json":
+        return media
+    types = [media]
+    alts = vs.getprop(res, "alternatives")
+    if isinstance(alts, list):
+        for alt in alts:
+            m = vs.getprop(alt, "media")
+            if isinstance(m, str) and m != "":
+                types.append(m)
+    return ", ".join(types)
+
+
+def is_raw_request(point):
+    return vs.getpath(point, "body.kind") == "raw"
+
+
+def is_json_request(point):
+    return vs.getpath(point, "body.kind") == "json"
+
+
+# Bytes or a file object go as given. A dict or a list is JSON, and so is a
+# scalar on a point that declares a JSON body.
+def request_body(point, body):
+    if isinstance(body, (bytes, bytearray, memoryview)) or callable(getattr(body, "read", None)):
+        return body
+    if vs.isnode(body) or is_json_request(point):
+        return vs.jsonify(body)
+    return body
+
+
+def _has_header(headers, name):
+    return any(isinstance(k, str) and k.lower() == name for k in headers)
+
+
+# A caller's accept wins. A declared request type replaces each JSON
+# content-type, the SDK default, and leaves any other the caller set.
+def media_headers(point, headers):
+    accept = accept_of(point)
+    if accept is not None and not _has_header(headers, "accept"):
+        headers["accept"] = accept
+
+    body = vs.getprop(point, "body")
+    kind = vs.getprop(body, "kind")
+    media = vs.getprop(body, "media")
+    if kind in ("raw", "json") and isinstance(media, str) and media != "":
+        for key in [k for k in headers if isinstance(k, str) and k.lower() == "content-type"
+                    and is_json_media(headers[k])]:
+            del headers[key]
+        if not _has_header(headers, "content-type"):
+            headers["content-type"] = media
+
+    return headers
+
+
+# Bytes, a file object or a string, sent as they are. A file object can be read
+# once, so it is read here, before the first attempt, and a retry sends the
+# same bytes again.
+def raw_body(reqdata):
+    body = reqdata.get(RAW_BODY) if isinstance(reqdata, dict) else None
+    if body is not None and callable(getattr(body, "read", None)):
+        return body.read()
+    return body

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

@@ -6,13 +6,6 @@ from projectname_sdk.core.helpers import to_map
 
 
 def param_util(ctx, paramdef):
-    point = ctx.point
-    spec = ctx.spec
-    match = ctx.match
-    reqmatch = ctx.reqmatch
-    data = ctx.data
-    reqdata = ctx.reqdata
-
     pt = vs.typify(paramdef)
     key = ""
 
@@ -23,33 +16,69 @@ def param_util(ctx, paramdef):
         if isinstance(k, str):
             key = k
 
-    akey = ""
+    akey = _param_alias(ctx.point, key)
+    if ctx.spec is not None and akey != "" and \
+            vs.getprop(ctx.reqmatch, key) is None and vs.getprop(ctx.match, key) is None:
+        ctx.spec.alias[akey] = key
+
+    return param_value(ctx, ctx.point, key)
+
+
+def _param_alias(point, key):
+    # The name a point gives a parameter in the call, if it renames it.
     if point is not None:
         alias = to_map(vs.getprop(point, "alias"))
         if alias is not None:
             ak = vs.getprop(alias, key)
             if isinstance(ak, str):
-                akey = ak
+                return ak
+    return ""
 
-    val = vs.getprop(reqmatch, key)
+
+# The value the call or its entity gives a point's parameter, under its name
+# or the point's alias for it.
+def param_value(ctx, point, key):
+    akey = _param_alias(point, key)
+
+    val = vs.getprop(ctx.reqmatch, key)
 
     if val is None:
-        val = vs.getprop(match, key)
+        val = vs.getprop(ctx.match, key)
 
     if val is None and akey != "":
-        if spec is not None:
-            spec.alias[akey] = key
-        val = vs.getprop(reqmatch, akey)
+        val = vs.getprop(ctx.reqmatch, akey)
 
     if val is None:
-        val = vs.getprop(reqdata, key)
+        val = vs.getprop(ctx.reqdata, key)
 
     if val is None:
-        val = vs.getprop(data, key)
+        val = vs.getprop(ctx.data, key)
 
     if val is None and akey != "":
-        val = vs.getprop(reqdata, akey)
+        val = vs.getprop(ctx.reqdata, akey)
         if val is None:
-            val = vs.getprop(data, akey)
+            val = vs.getprop(ctx.data, akey)
 
     return val
+
+
+# The arguments a point declares in one location, query or header, each with
+# the name it travels under and the value this call passes in its match or
+# else its data. Unlike a path parameter, the entity's stored match and data
+# never supply one.
+def call_args(ctx, kind):
+    out = []
+    defs = vs.getpath(ctx.point, "args." + kind) if ctx.point is not None else None
+    if isinstance(defs, list):
+        for ad in defs:
+            name = vs.getprop(ad, "name")
+            if not isinstance(name, str) or name == "":
+                continue
+            wire = vs.getprop(ad, "orig")
+            if not isinstance(wire, str) or wire == "":
+                wire = name
+            val = vs.getprop(ctx.reqmatch or {}, name)
+            if val is None:
+                val = vs.getprop(ctx.reqdata or {}, name)
+            out.append((name, wire, val))
+    return out

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

@@ -1,10 +1,14 @@
 # ProjectName SDK utility: prepare_body
 
+from projectname_sdk.utility.media import is_raw_request, raw_body
+
 
 def prepare_body_util(ctx):
     op = ctx.op
 
     if op.input == "data":
+        if is_raw_request(ctx.point):
+            return raw_body(ctx.reqdata)
         body = ctx.utility.transform_request(ctx)
         return body