@voxgig/sdkgen 0.35.2 → 0.37.0

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

@@ -0,0 +1,5 @@
+# ProjectName SDK utility: clean
+
+
+def clean_util(ctx, val):
+    return val

package/project/.sdk/tm/py/utility/done.py

@@ -0,0 +1,14 @@
+# ProjectName SDK utility: done
+
+
+def done_util(ctx):
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain = ctx.utility.clean(ctx, ctx.ctrl.explain)
+        explain_result = ctx.ctrl.explain.get("result") if isinstance(ctx.ctrl.explain, dict) else None
+        if isinstance(explain_result, dict):
+            explain_result.pop("err", None)
+
+    if ctx.result is not None and ctx.result.ok:
+        return ctx.result.resdata, None
+
+    return ctx.utility.make_error(ctx, None)

package/project/.sdk/tm/py/utility/feature_add.py

@@ -0,0 +1,6 @@
+# ProjectName SDK utility: feature_add
+
+
+def feature_add_util(ctx, f):
+    client = ctx.client
+    client.features.append(f)

package/project/.sdk/tm/py/utility/feature_hook.py

@@ -0,0 +1,15 @@
+# ProjectName SDK utility: feature_hook
+
+
+def feature_hook_util(ctx, name):
+    client = ctx.client
+    if client is None:
+        return
+    features = client.features
+    if features is None:
+        return
+
+    for f in features:
+        method = getattr(f, name, None)
+        if callable(method):
+            method(ctx)

package/project/.sdk/tm/py/utility/feature_init.py

@@ -0,0 +1,18 @@
+# ProjectName SDK utility: feature_init
+
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def feature_init_util(ctx, f):
+    fname = f.get_name()
+    fopts = {}
+
+    if ctx.options is not None:
+        feature_opts = vs.getprop(ctx.options, "feature")
+        if isinstance(feature_opts, dict):
+            fo = vs.getprop(feature_opts, fname)
+            if isinstance(fo, dict):
+                fopts = fo
+
+    if fopts.get("active") is True:
+        f.init(ctx, fopts)

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

@@ -0,0 +1,95 @@
+# ProjectName SDK utility: fetcher
+
+from __future__ import annotations
+import json
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def _default_http_fetch(fullurl, fetchdef):
+    import urllib.request
+    import urllib.error
+
+    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
+
+    req = urllib.request.Request(fullurl, data=data, method=method)
+    for k, v in headers.items():
+        req.add_header(k, v)
+
+    try:
+        resp = 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
+    except Exception as e:
+        return None, str(e)
+
+
+def fetcher_util(ctx, fullurl, fetchdef):
+    if ctx.client.mode != "live":
+        return None, ctx.make_error("fetch_mode_block",
+            'Request blocked by mode: "' + ctx.client.mode +
+            '" (URL was: "' + fullurl + '")')
+
+    options = ctx.client.options_map()
+    if vs.getpath(options, "feature.test.active") is True:
+        return None, ctx.make_error("fetch_test_block",
+            'Request blocked as test feature is active'
+            ' (URL was: "' + fullurl + '")')
+
+    sys_fetch = vs.getpath(options, "system.fetch")
+
+    if sys_fetch is None:
+        return _default_http_fetch(fullurl, fetchdef)
+
+    if callable(sys_fetch):
+        return sys_fetch(fullurl, fetchdef)
+
+    return None, ctx.make_error("fetch_invalid", "system.fetch is not a valid function")

package/project/.sdk/tm/py/utility/make_context.py

@@ -0,0 +1,7 @@
+# ProjectName SDK utility: make_context
+
+from core.context import ProjectNameContext
+
+
+def make_context_util(ctxmap, basectx):
+    return ProjectNameContext(ctxmap, basectx)

package/project/.sdk/tm/py/utility/make_error.py

@@ -0,0 +1,64 @@
+# ProjectName SDK utility: make_error
+
+from __future__ import annotations
+from core.operation import ProjectNameOperation
+from core.result import ProjectNameResult
+from core.control import ProjectNameControl
+from core.error import ProjectNameError
+
+
+def make_error_util(ctx, err):
+    if ctx is None:
+        from core.context import ProjectNameContext
+        ctx = ProjectNameContext({}, None)
+
+    op = ctx.op
+    if op is None:
+        op = ProjectNameOperation({})
+    opname = op.name
+    if opname == "" or opname == "_":
+        opname = "unknown operation"
+
+    result = ctx.result
+    if result is None:
+        result = ProjectNameResult({})
+    result.ok = False
+
+    if err is None:
+        err = result.err
+    if err is None:
+        err = ctx.make_error("unknown", "unknown error")
+
+    errmsg = ""
+    if isinstance(err, ProjectNameError):
+        errmsg = err.msg
+    elif hasattr(err, "msg") and err.msg is not None:
+        errmsg = err.msg
+    elif isinstance(err, str):
+        errmsg = err
+    else:
+        errmsg = str(err)
+
+    msg = "ProjectNameSDK: " + opname + ": " + errmsg
+    msg = ctx.utility.clean(ctx, msg)
+
+    result.err = None
+
+    spec = ctx.spec
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["err"] = {"message": msg}
+
+    sdk_err = ProjectNameError("", msg, ctx)
+    sdk_err.result = ctx.utility.clean(ctx, result)
+    sdk_err.spec = ctx.utility.clean(ctx, spec)
+
+    if isinstance(err, ProjectNameError):
+        sdk_err.code = err.code
+
+    ctx.ctrl.err = sdk_err
+
+    if ctx.ctrl.throw_err is False:
+        return result.resdata, None
+
+    return None, sdk_err

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

@@ -0,0 +1,37 @@
+# ProjectName SDK utility: make_fetch_def
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def make_fetch_def_util(ctx):
+    spec = ctx.spec
+    if spec is None:
+        return None, ctx.make_error("fetchdef_no_spec",
+            "Expected context spec property to be defined.")
+
+    from core.result import ProjectNameResult
+    if ctx.result is None:
+        ctx.result = ProjectNameResult({})
+
+    spec.step = "prepare"
+
+    url, err = ctx.utility.make_url(ctx)
+    if err is not None:
+        return None, err
+
+    spec.url = url
+
+    fetchdef = {
+        "url": url,
+        "method": spec.method,
+        "headers": spec.headers,
+    }
+
+    if spec.body is not None:
+        if isinstance(spec.body, dict):
+            fetchdef["body"] = vs.jsonify(spec.body)
+        else:
+            fetchdef["body"] = spec.body
+
+    return fetchdef, None

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

@@ -0,0 +1,103 @@
+# ProjectName SDK utility: make_options
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def make_options_util(ctx):
+    options = ctx.options or {}
+
+    # Merge custom utility overrides.
+    custom_utils = vs.getprop(options, "utility")
+    if isinstance(custom_utils, dict):
+        utility = ctx.utility
+        if utility is not None:
+            for key, val in custom_utils.items():
+                utility.custom[key] = val
+
+    opts = vs.clone(options)
+    if not isinstance(opts, dict):
+        opts = {}
+
+    config = ctx.config or {}
+    cfgopts = {}
+    co = config.get("options") if isinstance(config, dict) else None
+    if isinstance(co, dict):
+        cfgopts = co
+
+    optspec = {
+        "apikey": "",
+        "base": "http://localhost:8000",
+        "prefix": "",
+        "suffix": "",
+        "auth": {
+            "prefix": "",
+        },
+        "headers": {
+            "`$CHILD`": "`$STRING`",
+        },
+        "allow": {
+            "method": "GET,PUT,POST,PATCH,DELETE,OPTIONS",
+            "op": "create,update,load,list,remove,command,direct",
+        },
+        "entity": {
+            "`$CHILD`": {
+                "`$OPEN`": True,
+                "active": False,
+                "alias": {},
+            },
+        },
+        "feature": {
+            "`$CHILD`": {
+                "`$OPEN`": True,
+                "active": False,
+            },
+        },
+        "utility": {},
+        "system": {},
+        "test": {
+            "active": False,
+            "entity": {
+                "`$OPEN`": True,
+            },
+        },
+        "clean": {
+            "keys": "key,token,id",
+        },
+    }
+
+    # Preserve system.fetch before merge/validate.
+    sys_fetch = vs.getpath(opts, "system.fetch")
+
+    merged = vs.merge([{}, cfgopts, opts])
+    validated = vs.validate(merged, optspec)
+    if not isinstance(validated, dict):
+        validated = {}
+    opts = validated
+
+    # Restore system.fetch.
+    if sys_fetch is not None:
+        if isinstance(opts.get("system"), dict):
+            opts["system"]["fetch"] = sys_fetch
+        else:
+            opts["system"] = {"fetch": sys_fetch}
+
+    # Derived clean config.
+    clean_keys = "key,token,id"
+    ck = vs.getpath(opts, "clean.keys")
+    if isinstance(ck, str):
+        clean_keys = ck
+
+    parts = []
+    for part in clean_keys.split(","):
+        trimmed = part.strip()
+        if trimmed != "":
+            parts.append(vs.escre(trimmed))
+    keyre = "|".join(parts)
+
+    derived = {"clean": {}}
+    if keyre != "":
+        derived["clean"] = {"keyre": keyre}
+    opts["__derived__"] = derived
+
+    return opts

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

@@ -0,0 +1,74 @@
+# ProjectName SDK utility: make_point
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.helpers import to_map
+
+
+def make_point_util(ctx):
+    if ctx.out.get("point") is not None:
+        ctx.point = ctx.out["point"]
+        return ctx.point, None
+
+    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:
+        return None, ctx.make_error("point_op_allow",
+            'Operation "' + op.name +
+            '" not allowed by SDK option allow.op value: "' + allow_op + '"')
+
+    if len(op.points) == 0:
+        return None, ctx.make_error("point_no_points",
+            'Operation "' + op.name + '" has no endpoint definitions.')
+
+    if len(op.points) == 1:
+        ctx.point = op.points[0]
+    else:
+        if op.input == "data":
+            reqselector = ctx.reqdata
+            selector = ctx.data
+        else:
+            reqselector = ctx.reqmatch
+            selector = ctx.match
+
+        point = None
+        for i in range(len(op.points)):
+            point = op.points[i]
+            select_def = to_map(vs.getprop(point, "select"))
+            found = True
+
+            if selector is not None and select_def is not None:
+                exist = vs.getprop(select_def, "exist")
+                if isinstance(exist, list):
+                    for ek in exist:
+                        existkey = str(ek)
+                        rv = vs.getprop(reqselector, existkey)
+                        sv = vs.getprop(selector, existkey)
+                        if rv is None and sv is None:
+                            found = False
+                            break
+
+            if found:
+                req_action = vs.getprop(reqselector, "$action")
+                select_action = vs.getprop(select_def, "$action")
+                if req_action != select_action:
+                    found = False
+
+            if found:
+                break
+
+        if reqselector is not None:
+            req_action = vs.getprop(reqselector, "$action")
+            if req_action is not None and point is not None:
+                point_select = to_map(vs.getprop(point, "select"))
+                point_action = vs.getprop(point_select, "$action")
+                if req_action != point_action:
+                    return None, ctx.make_error("point_action_invalid",
+                        'Operation "' + op.name +
+                        '" action "' + vs.stringify(req_action) + '" is not valid.')
+
+        ctx.point = point
+
+    return ctx.point, None

package/project/.sdk/tm/py/utility/make_request.py

@@ -0,0 +1,52 @@
+# ProjectName SDK utility: make_request
+
+from __future__ import annotations
+from core.response import ProjectNameResponse
+from core.result import ProjectNameResult
+
+
+def make_request_util(ctx):
+    if ctx.out.get("request") is not None:
+        return ctx.out["request"], None
+
+    spec = ctx.spec
+    utility = ctx.utility
+
+    response = ProjectNameResponse({})
+    result = ProjectNameResult({})
+    ctx.result = result
+
+    if spec is None:
+        return None, ctx.make_error("request_no_spec",
+            "Expected context spec property to be defined.")
+
+    fetchdef, err = utility.make_fetch_def(ctx)
+    if err is not None:
+        response.err = err
+        ctx.response = response
+        spec.step = "postrequest"
+        return response, None
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["fetchdef"] = fetchdef
+
+    spec.step = "prerequest"
+
+    url = fetchdef.get("url", "")
+    fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
+
+    if fetch_err is not None:
+        response.err = fetch_err
+    elif fetched is None:
+        response = ProjectNameResponse({
+            "err": ctx.make_error("request_no_response", "response: undefined"),
+        })
+    elif isinstance(fetched, dict):
+        response = ProjectNameResponse(fetched)
+    else:
+        response.err = ctx.make_error("request_invalid_response", "response: invalid type")
+
+    spec.step = "postrequest"
+    ctx.response = response
+
+    return response, None

package/project/.sdk/tm/py/utility/make_response.py

@@ -0,0 +1,36 @@
+# ProjectName SDK utility: make_response
+
+
+def make_response_util(ctx):
+    if ctx.out.get("response") is not None:
+        return ctx.out["response"], None
+
+    utility = ctx.utility
+    spec = ctx.spec
+    result = ctx.result
+    response = ctx.response
+
+    if spec is None:
+        return None, ctx.make_error("response_no_spec",
+            "Expected context spec property to be defined.")
+    if response is None:
+        return None, ctx.make_error("response_no_response",
+            "Expected context response property to be defined.")
+    if result is None:
+        return None, ctx.make_error("response_no_result",
+            "Expected context result property to be defined.")
+
+    spec.step = "response"
+
+    utility.result_basic(ctx)
+    utility.result_headers(ctx)
+    utility.result_body(ctx)
+    utility.transform_response(ctx)
+
+    if result.err is None:
+        result.ok = True
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["result"] = result
+
+    return response, None

package/project/.sdk/tm/py/utility/make_result.py

@@ -0,0 +1,41 @@
+# ProjectName SDK utility: make_result
+
+
+def make_result_util(ctx):
+    if ctx.out.get("result") is not None:
+        return ctx.out["result"], None
+
+    utility = ctx.utility
+    op = ctx.op
+    entity = ctx.entity
+    spec = ctx.spec
+    result = ctx.result
+
+    if spec is None:
+        return None, ctx.make_error("result_no_spec",
+            "Expected context spec property to be defined.")
+    if result is None:
+        return None, ctx.make_error("result_no_result",
+            "Expected context result property to be defined.")
+
+    spec.step = "result"
+
+    utility.transform_response(ctx)
+
+    if op.name == "list":
+        resdata = result.resdata
+        result.resdata = []
+
+        if resdata is not None and isinstance(resdata, list) and entity is not None:
+            entities = []
+            for entry in resdata:
+                ent = entity.make()
+                if isinstance(entry, dict):
+                    ent.data_set(entry)
+                entities.append(ent)
+            result.resdata = entities
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["result"] = result
+
+    return result, None

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

@@ -0,0 +1,68 @@
+# ProjectName SDK utility: make_spec
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.spec import ProjectNameSpec
+
+
+def make_spec_util(ctx):
+    if ctx.out.get("spec") is not None:
+        ctx.spec = ctx.out["spec"]
+        return ctx.spec, None
+
+    point = ctx.point
+    options = ctx.options
+    utility = ctx.utility
+
+    base = ""
+    b = vs.getprop(options, "base")
+    if isinstance(b, str):
+        base = b
+
+    prefix = ""
+    p = vs.getprop(options, "prefix")
+    if isinstance(p, str):
+        prefix = p
+
+    suffix = ""
+    s = vs.getprop(options, "suffix")
+    if isinstance(s, str):
+        suffix = s
+
+    parts = []
+    if point is not None:
+        pt = vs.getprop(point, "parts")
+        if isinstance(pt, list):
+            parts = pt
+
+    ctx.spec = ProjectNameSpec({
+        "base": base,
+        "prefix": prefix,
+        "parts": parts,
+        "suffix": suffix,
+        "step": "start",
+    })
+
+    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:
+        return None, ctx.make_error("spec_method_allow",
+            'Method "' + ctx.spec.method +
+            '" not allowed by SDK option allow.method value: "' + allow_method + '"')
+
+    ctx.spec.params = utility.prepare_params(ctx)
+    ctx.spec.query = utility.prepare_query(ctx)
+    ctx.spec.headers = utility.prepare_headers(ctx)
+    ctx.spec.body = utility.prepare_body(ctx)
+    ctx.spec.path = utility.prepare_path(ctx)
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["spec"] = ctx.spec
+
+    spec, err = utility.prepare_auth(ctx)
+    if err is not None:
+        return None, err
+
+    ctx.spec = spec
+    return spec, None

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

@@ -0,0 +1,34 @@
+# ProjectName SDK utility: make_url
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def make_url_util(ctx):
+    spec = ctx.spec
+    result = ctx.result
+
+    if spec is None:
+        return "", ctx.make_error("url_no_spec",
+            "Expected context spec property to be defined.")
+    if result is None:
+        return "", ctx.make_error("url_no_result",
+            "Expected context result property to be defined.")
+
+    url = vs.join([spec.base, spec.prefix, spec.path, spec.suffix], "/", True)
+    resmatch = {}
+
+    param_items = vs.items(spec.params)
+    if param_items is not None:
+        for item in param_items:
+            key = item[0]
+            val = item[1]
+            if val is not None and isinstance(key, str):
+                val_str = val if isinstance(val, str) else str(val)
+                encoded = vs.escurl(val_str)
+                url = url.replace("{" + key + "}", encoded)
+                resmatch[key] = val
+
+    result.resmatch = resmatch
+
+    return url, None