@voxgig/sdkgen 0.35.2 → 0.36.0

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

@@ -0,0 +1,164 @@
+# ProjectName SDK test feature
+
+from __future__ import annotations
+import random
+
+from utility.voxgig_struct import voxgig_struct as vs
+from feature.base_feature import ProjectNameBaseFeature
+
+
+class ProjectNameTestFeature(ProjectNameBaseFeature):
+    def __init__(self):
+        super().__init__()
+        self.version = "0.0.1"
+        self.name = "test"
+        self.active = True
+        self.client = None
+        self.options = None
+
+    def init(self, ctx, options):
+        self.client = ctx.client
+        self.options = options
+
+        entity = vs.getprop(options, "entity")
+        if not isinstance(entity, dict):
+            entity = {}
+
+        self.client.mode = "test"
+
+        # Ensure entity ids are correct.
+        vs.walk(entity, lambda key, val, parent, path: (
+            val.__setitem__("id", key) if len(path) == 2 and isinstance(val, dict) and key is not None else None,
+            val
+        )[-1])
+
+        test_self = self
+
+        def test_fetcher(fctx, _fullurl, _fetchdef):
+            def respond(status, data, extra=None):
+                out = {
+                    "status": status,
+                    "statusText": "OK",
+                    "json": lambda: data,
+                    "body": "not-used",
+                }
+                if isinstance(extra, dict):
+                    for k, v in extra.items():
+                        out[k] = v
+                return out, None
+
+            op = fctx.op
+            entmap = vs.getprop(entity, op.entity)
+            if not isinstance(entmap, dict):
+                entmap = {}
+
+            if op.name == "load":
+                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                found = vs.select(entmap, args)
+                ent = vs.getelem(found, 0)
+                if ent is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                vs.delprop(ent, "$KEY")
+                out = vs.clone(ent)
+                return respond(200, out)
+
+            elif op.name == "list":
+                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                found = vs.select(entmap, args)
+                if found is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                if isinstance(found, list):
+                    for item in found:
+                        vs.delprop(item, "$KEY")
+                out = vs.clone(found)
+                return respond(200, out)
+
+            elif op.name == "update":
+                args = test_self.build_args(fctx, op, fctx.reqdata)
+                found = vs.select(entmap, args)
+                ent = vs.getelem(found, 0)
+                if ent is None:
+                    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
+                vs.delprop(ent, "$KEY")
+                out = vs.clone(ent)
+                return respond(200, out)
+
+            elif op.name == "remove":
+                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                found = vs.select(entmap, args)
+                ent = vs.getelem(found, 0)
+                if ent is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                if isinstance(ent, dict):
+                    eid = vs.getprop(ent, "id")
+                    vs.delprop(entmap, eid)
+                return respond(200, None)
+
+            elif op.name == "create":
+                test_self.build_args(fctx, op, fctx.reqdata)
+                eid = fctx.utility.param(fctx, "id")
+                if eid is None:
+                    eid = "%04x%04x%04x%04x" % (
+                        random.randint(0, 0xFFFF), random.randint(0, 0xFFFF),
+                        random.randint(0, 0xFFFF), random.randint(0, 0xFFFF))
+
+                ent = vs.clone(fctx.reqdata)
+                if isinstance(ent, dict):
+                    ent["id"] = eid
+                    if isinstance(eid, str):
+                        entmap[eid] = ent
+                    vs.delprop(ent, "$KEY")
+                    out = vs.clone(ent)
+                    return respond(200, out)
+                return respond(200, ent)
+
+            return respond(404, None, {"statusText": "Unknown operation"})
+
+        ctx.utility.fetcher = test_fetcher
+
+    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)
+
+        # Get required params.
+        params_path = vs.getpath(point, "args.params")
+        reqd_params = vs.select(params_path, {"reqd": True})
+        reqd = vs.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"])
+
+        qand = []
+        q = {"`$AND`": qand}
+
+        if args is not None:
+            keys = vs.keysof(args)
+            if keys is not None:
+                for key in keys:
+                    is_id = (key == "id")
+                    selected = vs.select(reqd, key)
+                    is_reqd = not vs.isempty(selected)
+
+                    if is_id or is_reqd:
+                        v = ctx.utility.param(ctx, key)
+                        ka = None
+                        if op.alias is not None:
+                            ka = vs.getprop(op.alias, key)
+
+                        qor = [{key: v}]
+                        if ka is not None and isinstance(ka, str):
+                            qor.append({ka: v})
+
+                        qand.append({"`$OR`": qor})
+
+        q["`$AND`"] = qand
+
+        if ctx.ctrl.explain is not None:
+            ctx.ctrl.explain["test"] = {"query": q}
+
+        return q

package/project/.sdk/tm/py/src/feature/README.md

@@ -0,0 +1,3 @@
+# Features
+
+This folder contains the feature source templates.

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

@@ -0,0 +1,77 @@
+# ProjectName SDK test runner
+
+from __future__ import annotations
+import os
+import json
+
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+class ProjectNameTestRunner:
+    _env = {}
+
+    @staticmethod
+    def load_env_local():
+        try:
+            with open("../../.env.local", "r") as f:
+                content = f.read()
+        except (FileNotFoundError, IOError):
+            return
+
+        for line in content.splitlines():
+            line = line.strip()
+            if line == "" or line.startswith("#"):
+                continue
+            eq_idx = line.find("=")
+            if eq_idx < 0:
+                continue
+            key = line[:eq_idx].strip()
+            val = line[eq_idx + 1:].strip()
+            ProjectNameTestRunner._env[key] = val
+
+    @staticmethod
+    def getenv(key):
+        val = ProjectNameTestRunner._env.get(key)
+        if val is not None:
+            return val
+        return os.environ.get(key)
+
+    @staticmethod
+    def env_override(m):
+        live = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_LIVE")
+        override = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_OVERRIDE")
+
+        if live == "TRUE" or override == "TRUE":
+            for key in list(m.keys()):
+                envval = ProjectNameTestRunner.getenv(key)
+                if envval is not None and envval != "":
+                    envval = envval.strip()
+                    if envval.startswith("{"):
+                        try:
+                            parsed = json.loads(envval)
+                            if parsed is not None:
+                                m[key] = parsed
+                                continue
+                        except Exception:
+                            pass
+                    m[key] = envval
+
+        explain = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_EXPLAIN")
+        if explain is not None and explain != "":
+            m["PROJECTNAME_TEST_EXPLAIN"] = explain
+
+        return m
+
+    @staticmethod
+    def entity_list_to_data(lst):
+        out = []
+        for item in lst:
+            if isinstance(item, dict):
+                out.append(item)
+            elif hasattr(item, "data_get") and callable(item.data_get):
+                d = item.data_get()
+                if isinstance(d, dict):
+                    out.append(d)
+            else:
+                out.append(item)
+        return out

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