@voxgig/sdkgen 0.35.1 → 0.36.0

package/project/.sdk/src/cmp/py/fragment/EntityLoadOp.fragment.py

@@ -0,0 +1,27 @@
+from utility.voxgig_struct import voxgig_struct as vs
+from core import helpers
+
+entity_load_op = None
+
+# EJECT-START
+
+    def load(self, reqmatch, ctrl=None):
+        utility = self._utility
+        ctx = utility.make_context({
+            "opname": "load",
+            "ctrl": ctrl,
+            "match": self._match,
+            "data": self._data,
+            "reqmatch": reqmatch,
+        }, self._entctx)
+
+        def post_done():
+            if ctx.result is not None:
+                if ctx.result.resmatch is not None:
+                    self._match = ctx.result.resmatch
+                if ctx.result.resdata is not None:
+                    self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+
+        return self._run_op(ctx, post_done)
+
+# EJECT-END

package/project/.sdk/src/cmp/py/fragment/EntityRemoveOp.fragment.py

@@ -0,0 +1,27 @@
+from utility.voxgig_struct import voxgig_struct as vs
+from core import helpers
+
+entity_remove_op = None
+
+# EJECT-START
+
+    def remove(self, reqmatch, ctrl=None):
+        utility = self._utility
+        ctx = utility.make_context({
+            "opname": "remove",
+            "ctrl": ctrl,
+            "match": self._match,
+            "data": self._data,
+            "reqmatch": reqmatch,
+        }, self._entctx)
+
+        def post_done():
+            if ctx.result is not None:
+                if ctx.result.resmatch is not None:
+                    self._match = ctx.result.resmatch
+                if ctx.result.resdata is not None:
+                    self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+
+        return self._run_op(ctx, post_done)
+
+# EJECT-END

package/project/.sdk/src/cmp/py/fragment/EntityUpdateOp.fragment.py

@@ -0,0 +1,27 @@
+from utility.voxgig_struct import voxgig_struct as vs
+from core import helpers
+
+entity_update_op = None
+
+# EJECT-START
+
+    def update(self, reqdata, ctrl=None):
+        utility = self._utility
+        ctx = utility.make_context({
+            "opname": "update",
+            "ctrl": ctrl,
+            "match": self._match,
+            "data": self._data,
+            "reqdata": reqdata,
+        }, self._entctx)
+
+        def post_done():
+            if ctx.result is not None:
+                if ctx.result.resmatch is not None:
+                    self._match = ctx.result.resmatch
+                if ctx.result.resdata is not None:
+                    self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+
+        return self._run_op(ctx, post_done)
+
+# EJECT-END

package/project/.sdk/src/cmp/py/fragment/Main.fragment.py

@@ -0,0 +1,222 @@
+# ProjectName SDK
+
+from utility.voxgig_struct import voxgig_struct as vs
+from core.utility_type import ProjectNameUtility
+from core.spec import ProjectNameSpec
+from core import helpers
+
+# Load utility registration (populates Utility._registrar)
+from utility import register
+
+# Load features
+from feature.base_feature import ProjectNameBaseFeature
+from features import _make_feature
+
+
+class ProjectNameSDK:
+
+    def __init__(self, options=None):
+        self.mode = "live"
+        self.features = []
+        self.options = None
+
+        utility = ProjectNameUtility()
+        self._utility = utility
+
+        from config import make_config
+        config = make_config()
+
+        self._rootctx = utility.make_context({
+            "client": self,
+            "utility": utility,
+            "config": config,
+            "options": options if options is not None else {},
+            "shared": {},
+        }, None)
+
+        self.options = utility.make_options(self._rootctx)
+
+        if vs.getpath(self.options, "feature.test.active") is True:
+            self.mode = "test"
+
+        self._rootctx.options = self.options
+
+        # Add features from config.
+        feature_opts = helpers.to_map(vs.getprop(self.options, "feature"))
+        if feature_opts is not None:
+            feature_items = vs.items(feature_opts)
+            if feature_items is not None:
+                for item in feature_items:
+                    fname = item[0]
+                    fopts = helpers.to_map(item[1])
+                    if fopts is not None and fopts.get("active") is True:
+                        utility.feature_add(self._rootctx, _make_feature(fname))
+
+        # Add extension features.
+        extend = vs.getprop(self.options, "extend")
+        if isinstance(extend, list):
+            for f in extend:
+                if isinstance(f, dict) or (hasattr(f, "get_name") and callable(f.get_name)):
+                    utility.feature_add(self._rootctx, f)
+
+        # Initialize features.
+        for f in self.features:
+            utility.feature_init(self._rootctx, f)
+
+        utility.feature_hook(self._rootctx, "PostConstruct")
+
+        # #BuildFeatures
+
+    def options_map(self):
+        out = vs.clone(self.options)
+        if isinstance(out, dict):
+            return out
+        return {}
+
+    def get_utility(self):
+        return ProjectNameUtility.copy(self._utility)
+
+    def get_root_ctx(self):
+        return self._rootctx
+
+    def prepare(self, fetchargs=None):
+        utility = self._utility
+
+        if fetchargs is None:
+            fetchargs = {}
+
+        ctrl = helpers.to_map(vs.getprop(fetchargs, "ctrl"))
+        if ctrl is None:
+            ctrl = {}
+
+        ctx = utility.make_context({
+            "opname": "prepare",
+            "ctrl": ctrl,
+        }, self._rootctx)
+
+        options = self.options
+
+        path = vs.getprop(fetchargs, "path") or ""
+        if not isinstance(path, str):
+            path = ""
+
+        method = vs.getprop(fetchargs, "method") or "GET"
+        if not isinstance(method, str):
+            method = "GET"
+
+        params = helpers.to_map(vs.getprop(fetchargs, "params"))
+        if params is None:
+            params = {}
+        query = helpers.to_map(vs.getprop(fetchargs, "query"))
+        if query is None:
+            query = {}
+
+        headers = utility.prepare_headers(ctx)
+
+        base = vs.getprop(options, "base") or ""
+        if not isinstance(base, str):
+            base = ""
+        prefix = vs.getprop(options, "prefix") or ""
+        if not isinstance(prefix, str):
+            prefix = ""
+        suffix = vs.getprop(options, "suffix") or ""
+        if not isinstance(suffix, str):
+            suffix = ""
+
+        ctx.spec = ProjectNameSpec({
+            "base": base,
+            "prefix": prefix,
+            "suffix": suffix,
+            "path": path,
+            "method": method,
+            "params": params,
+            "query": query,
+            "headers": headers,
+            "body": vs.getprop(fetchargs, "body"),
+            "step": "start",
+        })
+
+        # Merge user-provided headers.
+        uh = vs.getprop(fetchargs, "headers")
+        if isinstance(uh, dict):
+            for k, v in uh.items():
+                ctx.spec.headers[k] = v
+
+        _, err = utility.prepare_auth(ctx)
+        if err is not None:
+            return None, err
+
+        return utility.make_fetch_def(ctx)
+
+    def direct(self, fetchargs=None):
+        utility = self._utility
+
+        fetchdef, err = self.prepare(fetchargs)
+        if err is not None:
+            return {"ok": False, "err": err}, None
+
+        if fetchargs is None:
+            fetchargs = {}
+        ctrl = helpers.to_map(vs.getprop(fetchargs, "ctrl"))
+        if ctrl is None:
+            ctrl = {}
+
+        ctx = utility.make_context({
+            "opname": "direct",
+            "ctrl": ctrl,
+        }, self._rootctx)
+
+        url = fetchdef.get("url", "")
+        fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
+
+        if fetch_err is not None:
+            return {"ok": False, "err": fetch_err}, None
+
+        if fetched is None:
+            return {
+                "ok": False,
+                "err": ctx.make_error("direct_no_response", "response: undefined"),
+            }, None
+
+        if isinstance(fetched, dict):
+            status = helpers.to_int(vs.getprop(fetched, "status"))
+            json_data = None
+            jf = vs.getprop(fetched, "json")
+            if callable(jf):
+                json_data = jf()
+
+            return {
+                "ok": status >= 200 and status < 300,
+                "status": status,
+                "headers": vs.getprop(fetched, "headers"),
+                "data": json_data,
+            }, None
+
+        return {
+            "ok": False,
+            "err": ctx.make_error("direct_invalid", "invalid response type"),
+        }, None
+
+    # <[SLOT]>
+
+    @classmethod
+    def test(cls, testopts=None, sdkopts=None):
+        if sdkopts is None:
+            sdkopts = {}
+        sdkopts = vs.clone(sdkopts)
+        if not isinstance(sdkopts, dict):
+            sdkopts = {}
+
+        if testopts is None:
+            testopts = {}
+        testopts = vs.clone(testopts)
+        if not isinstance(testopts, dict):
+            testopts = {}
+        testopts["active"] = True
+
+        vs.setpath(sdkopts, "feature.test", testopts)
+
+        sdk = cls(sdkopts)
+        sdk.mode = "test"
+
+        return sdk

package/project/.sdk/src/cmp/py/fragment/SdkError.fragment.py

@@ -0,0 +1,16 @@
+# ProjectName SDK error
+
+
+class ProjectNameError(Exception):
+
+    def __init__(self, code="", msg=""):
+        self.code = code
+        self.msg = msg
+        self.sdk = "ProjectName"
+        super().__init__(self.error())
+
+    def error(self):
+        return self.sdk + ": " + self.code + ": " + self.msg
+
+    def __str__(self):
+        return self.error()

package/project/.sdk/src/cmp/py/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2022",
+    "declaration": true,
+    "declarationDir": "../dist"
+  }
+}

package/project/.sdk/src/cmp/py/utility_py.ts

@@ -0,0 +1,84 @@
+
+import * as Path from 'node:path'
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+function projectPath(suffix?: string): string {
+  return Path.normalize(Path.join(__dirname, '../../..', suffix ?? ''))
+}
+
+
+function formatPyDict(obj: any, indent: number = 0): string {
+  if (obj == null) {
+    return 'None'
+  }
+
+  const pad = '  '.repeat(indent)
+  const padInner = '  '.repeat(indent + 1)
+
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return '[]'
+    }
+    const items = obj.map(v => padInner + formatPyValue(v, indent + 1)).join(',\n')
+    return `[\n${items},\n${pad}]`
+  }
+
+  if (typeof obj === 'object') {
+    const entries = Object.entries(obj)
+    if (entries.length === 0) {
+      return '{}'
+    }
+    const items = entries
+      .map(([k, v]) => `${padInner}"${k}": ${formatPyValue(v, indent + 1)}`)
+      .join(',\n')
+    return `{\n${items},\n${pad}}`
+  }
+
+  return formatPyValue(obj, indent)
+}
+
+
+function formatPyValue(val: any, indent: number = 0): string {
+  if (val === null || val === undefined) {
+    return 'None'
+  }
+  if (typeof val === 'string') {
+    return `"${val.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+  }
+  if (typeof val === 'number') {
+    return String(val)
+  }
+  if (typeof val === 'boolean') {
+    return val ? 'True' : 'False'
+  }
+  if (Array.isArray(val)) {
+    return formatPyDict(val, indent)
+  }
+  if (typeof val === 'object') {
+    return formatPyDict(val, indent)
+  }
+  return String(val)
+}
+
+
+function clean(o: any) {
+  return walk(clone(o), (k: any, v: any, p: any) => {
+    if (null != k && k.endsWith('$')) {
+      delete p[k]
+    }
+    return v
+  })
+}
+
+
+export {
+  clean,
+  formatPyDict,
+  formatPyValue,
+  projectPath,
+}

package/project/.sdk/src/cmp/rb/Config_rb.ts

@@ -0,0 +1,101 @@
+
+import * as Path from 'node:path'
+
+
+import {
+  Content,
+  File,
+  Fragment,
+  Line,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+
+import {
+  clean,
+  formatRubyHash,
+} from './utility_rb'
+
+
+const Config = cmp(async function Config(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const feature = getModelPath(model, `main.${KIT}.feature`)
+
+  const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
+  const authPrefix = getModelPath(model, `main.${KIT}.config.auth.prefix`)
+  const baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`)
+
+  File({ name: 'config.' + target.ext }, () => {
+
+    Content(`# ${model.const.Name} SDK configuration
+
+module ${model.const.Name}Config
+  def self.make_config
+    {
+      "main" => {
+        "name" => "${model.const.Name}",
+      },
+      "feature" => {
+`)
+
+    each(feature, (f: any) => {
+      const fconfig = f.config || {}
+      Content(`        "${f.name}" => ${formatRubyHash(fconfig, 4)},
+`)
+    })
+
+    Content(`      },
+      "options" => {
+        "base" => "${baseUrl}",
+        "auth" => {
+          "prefix" => "${authPrefix}",
+        },
+        "headers" => ${formatRubyHash(headers, 4)},
+        "entity" => {
+`)
+
+    each(entity, (entity: any) => {
+      Content(`          "${entity.name}" => {},
+`)
+    })
+
+    Content(`        },
+      },
+      "entity" => ${formatRubyHash(
+      Object.values(entity).reduce((a: any, n: any) => (a[n.name] = clean({
+        fields: n.fields,
+        name: n.name,
+        op: n.op,
+        relations: n.relations,
+      }), a), {}), 3)},
+    }
+  end
+
+
+  def self.make_feature(name)
+    require_relative 'features'
+    ${model.const.Name}Features.make_feature(name)
+  end
+end
+`)
+  })
+})
+
+
+export {
+  Config
+}

package/project/.sdk/src/cmp/rb/EntityOperation_rb.ts

@@ -0,0 +1,44 @@
+
+import {
+  cmp, camelify,
+  Content, Fragment
+} from '@voxgig/sdkgen'
+
+
+const EntityOperation = cmp(function Operation(props: any) {
+  const { model } = props.ctx$
+  const { ff, opname, entity, entrep } = props
+
+  let { indent } = props
+
+  if (null != indent) {
+    indent = indent.substring(1)
+    if ('' == indent) {
+      indent = undefined
+    }
+  }
+
+  const entop = entity.op[opname]
+
+  Fragment({
+    from: ff + '/Entity' + camelify(opname) + 'Op.fragment.rb',
+    eject: ['# EJECT-START', '# EJECT-END'],
+    indent,
+    replace: {
+      ...entrep,
+      ProjectName: model.const.Name,
+      EntityName: entity.Name,
+      entityname: entity.name,
+      '#Feature-Hook': ({ name, indent }: any) =>
+        Content({ indent }, `
+u.feature_hook.call(ctx, "${name}")
+`)
+
+    }
+  })
+})
+
+
+export {
+  EntityOperation
+}

package/project/.sdk/src/cmp/rb/Entity_rb.ts

@@ -0,0 +1,62 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each, camelify, names,
+  File, Content, Folder, Fragment, Line, FeatureHook, Slot
+} from '@voxgig/sdkgen'
+
+import { EntityOperation } from './EntityOperation_rb'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target, entity } = props
+
+  const entrep = {
+    ...stdrep,
+  }
+
+  names(entrep, entity.Name, 'EntityName')
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/rb/fragment/')
+
+  // Entity files go to entity/ folder
+  Folder({ name: 'entity' }, () => {
+
+    File({ name: entity.name + '_entity.' + target.ext }, () => {
+
+      const opnames = Object.keys(entity.op)
+
+      const opfrags =
+        (['load', 'list', 'create', 'update', 'remove']
+          .reduce((a: any, opname: string) =>
+          (a['# #' + camelify(opname) + 'Op'] =
+            !opnames.includes(opname) ? '' : ({ indent }: any) => {
+              EntityOperation({ ff, opname, indent, entity, entrep })
+            }, a), {}))
+
+      Fragment({
+        from: ff + 'Entity.fragment.rb',
+        replace: {
+          ...entrep,
+          ProjectName: model.const.Name,
+          EntityName: entity.Name,
+          entityname: entity.name,
+
+          '#Entity-Hook': ({ name, indent }: any) =>
+            Content({ indent }, `utility.feature_hook.call(ctx, "${name}")`),
+
+          ...opfrags,
+        }
+      })
+
+    })
+  })
+})
+
+
+
+export {
+  Entity
+}

package/project/.sdk/src/cmp/rb/MainEntity_rb.ts

@@ -0,0 +1,23 @@
+
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity } = props
+  const { model } = props.ctx$
+
+  Content(`
+  def ${entity.Name}(data = nil)
+    require_relative 'entity/${entity.name}_entity'
+    ${entity.Name}Entity.new(self, data)
+  end
+
+`)
+
+})
+
+
+export {
+  MainEntity
+}