@voxgig/sdkgen 4.34.0 → 4.34.1

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

@@ -3,6 +3,9 @@ declare(strict_types=1);
 
 // ProjectName SDK utility: prepare_headers
 
+require_once __DIR__ . '/Param.php';
+require_once __DIR__ . '/Media.php';
+
 class ProjectNamePrepareHeaders
 {
     public static function call(ProjectNameContext $ctx): array
@@ -13,35 +16,92 @@ class ProjectNamePrepareHeaders
         if (!is_array($out)) {
             $out = [];
         }
-        // A header parameter travels as a header, under the name the
-        // definition gives it, and only from this call's own arguments. It
-        // replaces a default of the same name, whatever its case.
-        $hl = $ctx->point ? \Voxgig\Struct\Struct::getpath($ctx->point, 'args.header') : null;
-        if (is_array($hl)) {
-            foreach ($hl as $hd) {
-                $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
-                if (!is_string($name) || '' === $name) {
-                    continue;
+        $out = ProjectNameMedia::headers($ctx->point, $out);
+        // A header argument replaces a default of the same name, whatever its
+        // case.
+        foreach (ProjectNameParam::callArgs($ctx, 'header') as [$name, $orig, $val]) {
+            if (null !== $val) {
+                $wire = strtolower($orig);
+                foreach (array_keys($out) as $key) {
+                    if (is_string($key) && strtolower($key) === $wire) {
+                        unset($out[$key]);
+                    }
                 }
-                $orig = \Voxgig\Struct\Struct::getprop($hd, 'orig');
-                if (!is_string($orig) || '' === $orig) {
-                    $orig = $name;
+                $out[$wire] = \Voxgig\Struct\Struct::stringify($val);
+            }
+        }
+        // A cookie argument travels in the cookie header, form serialized and
+        // percent-encoded, replacing a cookie of the same name among those the
+        // caller's headers already send.
+        $sent = [];
+        foreach (ProjectNameParam::callArgs($ctx, 'cookie') as [$name, $orig, $val]) {
+            if (null !== $val) {
+                $sent[] = [$orig, $val];
+            }
+        }
+        if (0 < count($sent)) {
+            $names = array_merge(...array_map(
+                fn($arg) => \Voxgig\Struct\Struct::ismap($arg[1])
+                    ? array_map(fn($key) => \Voxgig\Struct\Struct::escurl((string) $key),
+                        \Voxgig\Struct\Struct::keysof($arg[1]))
+                    : [$arg[0]],
+                $sent
+            ));
+            $kept = [];
+            foreach (array_keys($out) as $key) {
+                if (!is_string($key) || 'cookie' !== strtolower($key)) {
+                    continue;
                 }
-                $val = \Voxgig\Struct\Struct::getprop($ctx->reqmatch ?? [], $name);
-                if (null === $val) {
-                    $val = \Voxgig\Struct\Struct::getprop($ctx->reqdata ?? [], $name);
+                $given = $out[$key];
+                unset($out[$key]);
+                if (!is_string($given)) {
+                    continue;
                 }
-                if (null !== $val) {
-                    $wire = strtolower($orig);
-                    foreach (array_keys($out) as $key) {
-                        if (is_string($key) && strtolower($key) === $wire) {
-                            unset($out[$key]);
-                        }
-                    }
-                    $out[$wire] = \Voxgig\Struct\Struct::stringify($val);
+                $kept = array_merge($kept, self::cookieKeep($given, $names));
+            }
+            foreach ($sent as [$orig, $val]) {
+                $pair = self::cookiePair($orig, $val);
+                if ('' !== $pair) {
+                    $kept[] = $pair;
                 }
             }
+            if (0 < count($kept)) {
+                $out['cookie'] = implode('; ', $kept);
+            }
         }
         return $out;
     }
+
+    // The form style of a cookie parameter: a list repeats the name, a map
+    // sends its own keys, and every value is percent-encoded.
+    private static function cookiePair(string $wire, mixed $val): string
+    {
+        $esc = fn($v) => \Voxgig\Struct\Struct::escurl(\Voxgig\Struct\Struct::stringify($v));
+        if (\Voxgig\Struct\Struct::islist($val)) {
+            $pairs = array_map(fn($item) => $wire . '=' . $esc($item), $val);
+        } elseif (\Voxgig\Struct\Struct::ismap($val)) {
+            $pairs = array_map(
+                fn($key) => \Voxgig\Struct\Struct::escurl((string) $key) . '='
+                    . $esc(\Voxgig\Struct\Struct::getprop($val, $key)),
+                \Voxgig\Struct\Struct::keysof($val)
+            );
+        } else {
+            $pairs = [$wire . '=' . $esc($val)];
+        }
+        return implode('; ', $pairs);
+    }
+
+    // The caller's cookie pieces with the named cookies removed: a cookie is
+    // one ;-delimited piece, whatever its value holds.
+    public static function cookieKeep(string $header, array $names): array
+    {
+        $kept = [];
+        foreach (explode(';', $header) as $piece) {
+            $cookie = trim($piece);
+            if ('' !== $cookie && !in_array(trim(explode('=', $cookie, 2)[0]), $names, true)) {
+                $kept[] = $cookie;
+            }
+        }
+        return $kept;
+    }
 }

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

@@ -33,4 +33,19 @@ class ProjectNamePrepareMethod
         // shared corpus (prepareMethod, opname "bad" -> null) pins it now.
         return self::METHOD_MAP[$ctx->op->name] ?? null;
     }
+
+    // Whether a comma-separated allow option names the item: whole names, any case.
+    public static function allowed(mixed $names, mixed $item): bool
+    {
+        $want = is_string($item) ? strtoupper($item) : '';
+        if ('' === $want || !is_string($names)) {
+            return false;
+        }
+        foreach (explode(',', $names) as $name) {
+            if (strtoupper(trim($name)) === $want) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

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

@@ -3,6 +3,8 @@ declare(strict_types=1);
 
 // ProjectName SDK utility: prepare_query
 
+require_once __DIR__ . '/Param.php';
+
 class ProjectNamePrepareQuery
 {
     public static function call(ProjectNameContext $ctx): array
@@ -27,14 +29,20 @@ class ProjectNamePrepareQuery
                     }
                 }
             }
-            // A header parameter travels in the headers, which prepareHeaders
-            // fills.
-            $hl = \Voxgig\Struct\Struct::getpath($point, 'args.header');
-            if (is_array($hl)) {
-                foreach ($hl as $hd) {
-                    $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
-                    if (is_string($name)) {
-                        $params[] = $name;
+            // A header or cookie parameter travels in the headers, which
+            // prepareHeaders fills, unless a query parameter shares its name:
+            // then both are sent.
+            $ql = \Voxgig\Struct\Struct::getpath($point, 'args.query');
+            $declared = is_array($ql)
+                ? array_map(fn($qd) => \Voxgig\Struct\Struct::getprop($qd, 'name'), $ql) : [];
+            foreach ([\Voxgig\Struct\Struct::getpath($point, 'args.header'),
+                \Voxgig\Struct\Struct::getpath($point, 'args.cookie')] as $hl) {
+                if (is_array($hl)) {
+                    foreach ($hl as $hd) {
+                        $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
+                        if (is_string($name) && !in_array($name, $declared, true)) {
+                            $params[] = $name;
+                        }
                     }
                 }
             }
@@ -65,6 +73,12 @@ class ProjectNamePrepareQuery
                 }
             }
         }
+        // A create or update passes its query arguments in its data.
+        foreach (ProjectNameParam::callArgs($ctx, 'query') as [$name, $orig, $val]) {
+            if (null !== $val && !in_array($name, $params, true)) {
+                $out[$orig] = $val;
+            }
+        }
         return $out;
     }
 }

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

@@ -5,6 +5,8 @@ declare(strict_types=1);
 
 class ProjectNameResultBody
 {
+    public const PREVIEW_LENGTH = 160;
+
     public static function call(ProjectNameContext $ctx): ?ProjectNameResult
     {
         $response = $ctx->response;
@@ -12,6 +14,75 @@ class ProjectNameResultBody
         if ($result && $response && $response->json_func && $response->body) {
             $result->body = ($response->json_func)();
         }
+        if ($result && $response && $response->unreadable) {
+            $sent = null !== $ctx->spec ? $ctx->spec->headers : null;
+            $result->err = self::unreadable($ctx, $result->status, $result->headers,
+                $response->body, $sent, $result->err);
+        }
         return $result;
     }
+
+    // A body that is not JSON. An HTTP failure keeps its own error, with the
+    // response described; otherwise the code tells a wrong content type from
+    // malformed JSON.
+    public static function unreadable(ProjectNameContext $ctx, int $status, mixed $headers,
+        mixed $text, mixed $sent, mixed $failed): mixed
+    {
+        $type = self::header($headers, 'content-type');
+        $agent = (string)($ctx->utility->clean)($ctx, self::header($sent, 'user-agent'));
+        if ('' === $agent) {
+            $agent = 'transport default';
+        }
+        $detail = "HTTP {$status}, content-type " . ('' === $type ? 'none' : $type) .
+            ", user-agent {$agent}";
+        if (null !== $text) {
+            $detail .= ', body: ' . self::preview($ctx, $text);
+        }
+
+        if (null !== $failed) {
+            if (is_string($failed)) {
+                return "{$failed} ({$detail})";
+            }
+            if ($failed instanceof ProjectNameError) {
+                return $ctx->make_error($failed->sdk_code, "{$failed->msg} ({$detail})");
+            }
+            if ($failed instanceof \Throwable) {
+                return new \RuntimeException("{$failed->getMessage()} ({$detail})", 0, $failed);
+            }
+            return $failed;
+        }
+
+        if ('' === $type || false !== stripos($type, 'json')) {
+            return $ctx->make_error('response_json_invalid',
+                "response: body is not valid JSON ({$detail})");
+        }
+        return $ctx->make_error('response_content_type',
+            "response: expected JSON, got {$type} ({$detail})");
+    }
+
+    private static function header(mixed $headers, string $name): string
+    {
+        if (!is_array($headers)) {
+            return '';
+        }
+        foreach ($headers as $key => $val) {
+            if (strtolower((string)$key) === $name) {
+                return (string)$val;
+            }
+        }
+        return '';
+    }
+
+    // Cleaned whole: a secret the bound would split could leave its prefix.
+    private static function preview(ProjectNameContext $ctx, mixed $text): string
+    {
+        $flat = trim((string)preg_replace('/\s+/', ' ', (string)$text));
+        $flat = (string)($ctx->utility->clean)($ctx, $flat);
+        $chars = preg_split('//u', $flat, -1, PREG_SPLIT_NO_EMPTY);
+        if (false === $chars) {
+            $chars = str_split($flat);
+        }
+        return count($chars) > self::PREVIEW_LENGTH
+            ? implode('', array_slice($chars, 0, self::PREVIEW_LENGTH)) . '...' : $flat;
+    }
 }

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

@@ -4,6 +4,7 @@ declare(strict_types=1);
 // ProjectName SDK utility: transform_request
 
 require_once __DIR__ . '/../core/Helpers.php';
+require_once __DIR__ . '/Param.php';
 
 class ProjectNameTransformRequest
 {
@@ -14,7 +15,7 @@ class ProjectNameTransformRequest
         if ($spec) {
             $spec->step = 'reqform';
         }
-        $data = self::omit($ctx->reqdata, self::header_arg_names($point));
+        $data = self::omit($ctx->reqdata, self::routed_arg_names($ctx));
         $transform = ProjectNameHelpers::to_map(\Voxgig\Struct\Struct::getprop($point, 'transform'));
         if (!$transform) {
             return self::strip_action($data);
@@ -34,19 +35,29 @@ class ProjectNameTransformRequest
         return self::omit($reqdata, ['$action']);
     }
 
-    // A header argument travels as a header, which PrepareHeaders sends, so
-    // the body is built from the request data without it.
-    private static function header_arg_names(mixed $point): array
+    // A header, cookie or query argument travels where PrepareHeaders or
+    // PrepareQuery sends it, so the body is built from the request data
+    // without it, unless the entity declares it as a field too.
+    private static function routed_arg_names(ProjectNameContext $ctx): array
     {
-        $hl = $point ? \Voxgig\Struct\Struct::getpath($point, 'args.header') : null;
-        $names = [];
-        foreach (is_array($hl) ? $hl : [] as $hd) {
-            $name = \Voxgig\Struct\Struct::getprop($hd, 'name');
-            if (is_string($name) && '' !== $name) {
-                $names[] = $name;
+        $args = array_merge(ProjectNameParam::callArgs($ctx, 'header'),
+            ProjectNameParam::callArgs($ctx, 'cookie'), ProjectNameParam::callArgs($ctx, 'query'));
+        return array_values(array_filter(array_map(fn($arg) => $arg[0], $args),
+            fn($name) => !self::field_arg($ctx, $name)));
+    }
+
+    private static function field_arg(ProjectNameContext $ctx, string $name): bool
+    {
+        foreach (['header', 'cookie', 'query'] as $kind) {
+            $defs = $ctx->point ? \Voxgig\Struct\Struct::getpath($ctx->point, 'args.' . $kind) : null;
+            foreach (is_array($defs) ? $defs : [] as $ad) {
+                if ($name === \Voxgig\Struct\Struct::getprop($ad, 'name') &&
+                    true === \Voxgig\Struct\Struct::getprop($ad, 'field')) {
+                    return true;
+                }
             }
         }
-        return $names;
+        return false;
     }
 
     private static function omit(mixed $reqdata, array $names): mixed

package/project/.sdk/tm/py/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -186,7 +186,7 @@ class ProjectNameContext:
         opcfg = vs.getpath(self.config, "entity." + entname + ".op." + opname)
 
         inpt = "match"
-        if opname == "update" or opname == "create":
+        if opname == "update" or opname == "create" or opname == "patch":
             inpt = "data"
 
         points = []

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/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")