@voxgig/sdkgen 0.35.2 → 0.37.0

package/project/.sdk/tm/js/test/utility/index.js

@@ -0,0 +1,9 @@
+
+const { SDK } = require('../..')
+
+const TEST_JSON_FILE = '../../.sdk/test/test.json'
+
+module.exports = {
+  SDK,
+  TEST_JSON_FILE,
+}

package/project/.sdk/tm/js/test/utility.js

@@ -0,0 +1,72 @@
+/**
+ * Shared utility functions for unit tests
+ *
+ * This module provides common helper functions used across unit tests
+ * for creating test data, transformations, validations, and environment overrides.
+ */
+
+// Creates a new step data structure within the data model
+function makeStepData(dm, stepname) {
+  dm.s[stepname] = {
+    entity: undefined,
+    match: undefined,
+    reqdata: undefined,
+    resdata: undefined,
+  }
+  return dm.s[stepname]
+}
+
+
+// Transforms and creates a match object using the provided transform function
+function makeMatch(dm, transform, match) {
+  return transform({}, match, { meta: { dm } })
+}
+
+
+// Transforms and creates request data using the provided transform function
+function makeReqdata(dm, transform, data) {
+  return transform({}, data, { meta: { dm } })
+}
+
+
+// Validates data against validation rules and returns the result
+function makeValid(dm, validate, data, valid) {
+  valid["`$OPEN`"] = true
+  return validate(data, valid, { meta: { '`$EXISTS`': true, dm } })
+}
+
+
+// Creates a control object for test explanations when enabled
+function makeCtrl(explain) {
+  return explain ? { explain: {} } : undefined
+}
+
+// Overrides configuration values with environment variables if available
+function envOverride(m) {
+  if (
+    'TRUE' === process.env.PROJECTNAME_TEST_LIVE ||
+    'TRUE' === process.env.PROJECTNAME_TEST_OVERRIDE
+  ) {
+    Object.entries(m).map(n => {
+      let envval = process.env[n[0]]
+      if (null != envval) {
+        envval = envval.trim()
+        m[n[0]] = envval.startsWith('{') ? JSON.parse(envval) : envval
+      }
+    })
+  }
+
+  m.PROJECTNAME_TEST_EXPLAIN = process.env.PROJECTNAME_TEST_EXPLAIN || m.PROJECTNAME_TEST_EXPLAIN
+
+  return m
+}
+
+
+module.exports = {
+  makeStepData,
+  makeMatch,
+  makeReqdata,
+  makeValid,
+  makeCtrl,
+  envOverride
+}

package/project/.sdk/tm/lua/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ $$const.Name$$
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/project/.sdk/tm/lua/Makefile

@@ -0,0 +1,10 @@
+.PHONY: test build clean
+
+test:
+	busted test/
+
+build:
+	@echo "No build step for Lua"
+
+clean:
+	@echo "No clean step for Lua"

package/project/.sdk/tm/lua/core/context.lua

@@ -0,0 +1,208 @@
+-- ProjectName SDK context
+
+local vs = require("utility.struct.struct")
+local Control = require("core.control")
+local Operation = require("core.operation")
+local Spec = require("core.spec")
+local Result = require("core.result")
+local Response = require("core.response")
+local ProjectNameError = require("core.error")
+local helpers = require("core.helpers")
+
+local Context = {}
+Context.__index = Context
+
+
+function Context.new(ctxmap, basectx)
+  local self = setmetatable({}, Context)
+
+  self.id = "C" .. tostring(math.random(10000000, 99999999))
+  self.out = {}
+
+  ctxmap = ctxmap or {}
+
+  -- Client
+  local c = helpers.get_ctx_prop(ctxmap, "client")
+  if c ~= nil then
+    self.client = c
+  elseif basectx ~= nil then
+    self.client = basectx.client
+  end
+
+  -- Utility
+  local u = helpers.get_ctx_prop(ctxmap, "utility")
+  if u ~= nil then
+    self.utility = u
+  elseif basectx ~= nil then
+    self.utility = basectx.utility
+  end
+
+  -- Ctrl
+  self.ctrl = Control.new()
+  local ctrl_raw = helpers.get_ctx_prop(ctxmap, "ctrl")
+  if type(ctrl_raw) == "table" then
+    if ctrl_raw.throw_err ~= nil then
+      self.ctrl.throw_err = ctrl_raw.throw_err
+    elseif type(ctrl_raw["throw"]) == "boolean" then
+      self.ctrl.throw_err = ctrl_raw["throw"]
+    end
+    if type(ctrl_raw.explain) == "table" then
+      self.ctrl.explain = ctrl_raw.explain
+    end
+  elseif basectx ~= nil and basectx.ctrl ~= nil then
+    self.ctrl = basectx.ctrl
+  end
+
+  -- Meta
+  self.meta = {}
+  local m = helpers.get_ctx_prop(ctxmap, "meta")
+  if type(m) == "table" then
+    self.meta = m
+  elseif basectx ~= nil and basectx.meta ~= nil then
+    self.meta = basectx.meta
+  end
+
+  -- Config
+  local cfg = helpers.get_ctx_prop(ctxmap, "config")
+  if type(cfg) == "table" then
+    self.config = cfg
+  elseif basectx ~= nil then
+    self.config = basectx.config
+  end
+
+  -- Entopts
+  local eo = helpers.get_ctx_prop(ctxmap, "entopts")
+  if type(eo) == "table" then
+    self.entopts = eo
+  elseif basectx ~= nil then
+    self.entopts = basectx.entopts
+  end
+
+  -- Options
+  local o = helpers.get_ctx_prop(ctxmap, "options")
+  if type(o) == "table" then
+    self.options = o
+  elseif basectx ~= nil then
+    self.options = basectx.options
+  end
+
+  -- Entity
+  local e = helpers.get_ctx_prop(ctxmap, "entity")
+  if e ~= nil then
+    self.entity = e
+  elseif basectx ~= nil then
+    self.entity = basectx.entity
+  end
+
+  -- Shared
+  local s = helpers.get_ctx_prop(ctxmap, "shared")
+  if type(s) == "table" then
+    self.shared = s
+  elseif basectx ~= nil then
+    self.shared = basectx.shared
+  end
+
+  -- Opmap
+  local om = helpers.get_ctx_prop(ctxmap, "opmap")
+  if type(om) == "table" then
+    self.opmap = om
+  elseif basectx ~= nil then
+    self.opmap = basectx.opmap
+  end
+  if self.opmap == nil then
+    self.opmap = {}
+  end
+
+  -- Data
+  self.data = helpers.to_map(helpers.get_ctx_prop(ctxmap, "data")) or {}
+  self.reqdata = helpers.to_map(helpers.get_ctx_prop(ctxmap, "reqdata")) or {}
+  self.match = helpers.to_map(helpers.get_ctx_prop(ctxmap, "match")) or {}
+  self.reqmatch = helpers.to_map(helpers.get_ctx_prop(ctxmap, "reqmatch")) or {}
+
+  -- Point
+  local pt = helpers.get_ctx_prop(ctxmap, "point")
+  if type(pt) == "table" then
+    self.point = pt
+  elseif basectx ~= nil then
+    self.point = basectx.point
+  end
+
+  -- Spec
+  local sp = helpers.get_ctx_prop(ctxmap, "spec")
+  if sp ~= nil and getmetatable(sp) == Spec then
+    self.spec = sp
+  elseif basectx ~= nil then
+    self.spec = basectx.spec
+  end
+
+  -- Result
+  local r = helpers.get_ctx_prop(ctxmap, "result")
+  if r ~= nil and getmetatable(r) == Result then
+    self.result = r
+  elseif basectx ~= nil then
+    self.result = basectx.result
+  end
+
+  -- Response
+  local rp = helpers.get_ctx_prop(ctxmap, "response")
+  if rp ~= nil and getmetatable(rp) == Response then
+    self.response = rp
+  elseif basectx ~= nil then
+    self.response = basectx.response
+  end
+
+  -- Resolve operation
+  local opname = helpers.get_ctx_prop(ctxmap, "opname") or ""
+  self.op = self:resolve_op(opname)
+
+  return self
+end
+
+
+function Context:resolve_op(opname)
+  if self.opmap[opname] ~= nil then
+    return self.opmap[opname]
+  end
+
+  if opname == "" then
+    return Operation.new({})
+  end
+
+  local entname = "_"
+  if self.entity ~= nil and type(self.entity.get_name) == "function" then
+    entname = self.entity:get_name()
+  end
+
+  local opcfg = vs.getpath(self.config, "entity." .. entname .. ".op." .. opname)
+
+  local input = "match"
+  if opname == "update" or opname == "create" then
+    input = "data"
+  end
+
+  local points = {}
+  if type(opcfg) == "table" then
+    local t = vs.getprop(opcfg, "points")
+    if type(t) == "table" then
+      points = t
+    end
+  end
+
+  local op = Operation.new({
+    entity = entname,
+    name = opname,
+    input = input,
+    points = points,
+  })
+
+  self.opmap[opname] = op
+  return op
+end
+
+
+function Context:make_error(code, msg)
+  return ProjectNameError.new(code, msg, self)
+end
+
+
+return Context

package/project/.sdk/tm/lua/core/control.lua

@@ -0,0 +1,17 @@
+-- ProjectName SDK control
+
+local Control = {}
+Control.__index = Control
+
+
+function Control.new(opts)
+  opts = opts or {}
+  local self = setmetatable({}, Control)
+  self.throw_err = opts.throw_err
+  self.err = nil
+  self.explain = opts.explain
+  return self
+end
+
+
+return Control

package/project/.sdk/tm/lua/core/error.lua

@@ -0,0 +1,30 @@
+-- ProjectName SDK error
+
+local ProjectNameError = {}
+ProjectNameError.__index = ProjectNameError
+
+
+function ProjectNameError.new(code, msg, ctx)
+  local self = setmetatable({}, ProjectNameError)
+  self.is_sdk_error = true
+  self.sdk = "ProjectName"
+  self.code = code or ""
+  self.msg = msg or ""
+  self.ctx = ctx
+  self.result = nil
+  self.spec = nil
+  return self
+end
+
+
+function ProjectNameError:error()
+  return self.msg
+end
+
+
+function ProjectNameError:__tostring()
+  return self.msg
+end
+
+
+return ProjectNameError

package/project/.sdk/tm/lua/core/helpers.lua

@@ -0,0 +1,30 @@
+-- ProjectName SDK helpers
+
+local helpers = {}
+
+
+function helpers.to_map(v)
+  if type(v) == "table" then
+    return v
+  end
+  return nil
+end
+
+
+function helpers.to_int(v)
+  if type(v) == "number" then
+    return math.floor(v)
+  end
+  return -1
+end
+
+
+function helpers.get_ctx_prop(m, key)
+  if m == nil then
+    return nil
+  end
+  return m[key]
+end
+
+
+return helpers

package/project/.sdk/tm/lua/core/operation.lua

@@ -0,0 +1,51 @@
+-- ProjectName SDK operation
+
+local vs = require("utility.struct.struct")
+
+local Operation = {}
+Operation.__index = Operation
+
+
+function Operation.new(opmap)
+  local self = setmetatable({}, Operation)
+  opmap = opmap or {}
+
+  local entity = vs.getprop(opmap, "entity")
+  if type(entity) ~= "string" or entity == "" then
+    entity = "_"
+  end
+  self.entity = entity
+
+  local name = vs.getprop(opmap, "name")
+  if type(name) ~= "string" or name == "" then
+    name = "_"
+  end
+  self.name = name
+
+  local input = vs.getprop(opmap, "input")
+  if type(input) ~= "string" or input == "" then
+    input = "_"
+  end
+  self.input = input
+
+  self.points = {}
+  local raw_points = vs.getprop(opmap, "points")
+  if type(raw_points) == "table" then
+    for _, t in ipairs(raw_points) do
+      if type(t) == "table" then
+        table.insert(self.points, t)
+      end
+    end
+  end
+
+  self.alias = nil
+  local raw_alias = vs.getprop(opmap, "alias")
+  if type(raw_alias) == "table" then
+    self.alias = raw_alias
+  end
+
+  return self
+end
+
+
+return Operation

package/project/.sdk/tm/lua/core/response.lua

@@ -0,0 +1,45 @@
+-- ProjectName SDK response
+
+local vs = require("utility.struct.struct")
+
+local Response = {}
+Response.__index = Response
+
+
+function Response.new(resmap)
+  local self = setmetatable({}, Response)
+  resmap = resmap or {}
+
+  self.status = -1
+  local s = vs.getprop(resmap, "status")
+  if s ~= nil and type(s) == "number" then
+    self.status = math.floor(s)
+  end
+
+  self.status_text = ""
+  local st = vs.getprop(resmap, "statusText")
+  if type(st) == "string" then
+    self.status_text = st
+  end
+
+  self.headers = vs.getprop(resmap, "headers")
+
+  self.json_func = nil
+  local jf = vs.getprop(resmap, "json")
+  if type(jf) == "function" then
+    self.json_func = jf
+  end
+
+  self.body = vs.getprop(resmap, "body")
+
+  self.err = nil
+  local e = vs.getprop(resmap, "err")
+  if e ~= nil then
+    self.err = e
+  end
+
+  return self
+end
+
+
+return Response

package/project/.sdk/tm/lua/core/result.lua

@@ -0,0 +1,58 @@
+-- ProjectName SDK result
+
+local vs = require("utility.struct.struct")
+
+local Result = {}
+Result.__index = Result
+
+
+function Result.new(resmap)
+  local self = setmetatable({}, Result)
+  resmap = resmap or {}
+
+  self.ok = false
+  if vs.getprop(resmap, "ok") == true then
+    self.ok = true
+  end
+
+  self.status = -1
+  local s = vs.getprop(resmap, "status")
+  if s ~= nil then
+    if type(s) == "number" then
+      self.status = math.floor(s)
+    end
+  end
+
+  self.status_text = ""
+  local st = vs.getprop(resmap, "statusText")
+  if type(st) == "string" then
+    self.status_text = st
+  end
+
+  self.headers = {}
+  local h = vs.getprop(resmap, "headers")
+  if type(h) == "table" then
+    self.headers = h
+  end
+
+  self.body = vs.getprop(resmap, "body")
+
+  self.err = nil
+  local e = vs.getprop(resmap, "err")
+  if e ~= nil then
+    self.err = e
+  end
+
+  self.resdata = vs.getprop(resmap, "resdata")
+
+  self.resmatch = nil
+  local rm = vs.getprop(resmap, "resmatch")
+  if type(rm) == "table" then
+    self.resmatch = rm
+  end
+
+  return self
+end
+
+
+return Result

package/project/.sdk/tm/lua/core/spec.lua

@@ -0,0 +1,29 @@
+-- ProjectName SDK spec
+
+local Spec = {}
+Spec.__index = Spec
+
+
+function Spec.new(specmap)
+  local self = setmetatable({}, Spec)
+  specmap = specmap or {}
+
+  self.parts = specmap.parts or {}
+  self.headers = specmap.headers or {}
+  self.alias = specmap.alias or {}
+  self.base = specmap.base or ""
+  self.prefix = specmap.prefix or ""
+  self.suffix = specmap.suffix or ""
+  self.params = specmap.params or {}
+  self.query = specmap.query or {}
+  self.step = specmap.step or ""
+  self.method = specmap.method or "GET"
+  self.body = specmap.body
+  self.url = specmap.url or ""
+  self.path = specmap.path or ""
+
+  return self
+end
+
+
+return Spec

package/project/.sdk/tm/lua/core/utility_type.lua

@@ -0,0 +1,90 @@
+-- ProjectName SDK utility type
+
+local Utility = {}
+Utility.__index = Utility
+
+
+function Utility.new()
+  local self = setmetatable({}, Utility)
+  self.custom = {}
+
+  -- All utility functions are set by the register module
+  self.clean = nil
+  self.done = nil
+  self.make_error = nil
+  self.feature_add = nil
+  self.feature_hook = nil
+  self.feature_init = nil
+  self.fetcher = nil
+  self.make_fetch_def = nil
+  self.make_context = nil
+  self.make_options = nil
+  self.make_request = nil
+  self.make_response = nil
+  self.make_result = nil
+  self.make_point = nil
+  self.make_spec = nil
+  self.make_url = nil
+  self.param = nil
+  self.prepare_auth = nil
+  self.prepare_body = nil
+  self.prepare_headers = nil
+  self.prepare_method = nil
+  self.prepare_params = nil
+  self.prepare_path = nil
+  self.prepare_query = nil
+  self.result_basic = nil
+  self.result_body = nil
+  self.result_headers = nil
+  self.transform_request = nil
+  self.transform_response = nil
+
+  -- Let the registrar fill in all functions
+  if Utility._registrar ~= nil then
+    Utility._registrar(self)
+  end
+
+  return self
+end
+
+
+function Utility.copy(src)
+  local u = Utility.new()
+  u.clean = src.clean
+  u.done = src.done
+  u.make_error = src.make_error
+  u.feature_add = src.feature_add
+  u.feature_hook = src.feature_hook
+  u.feature_init = src.feature_init
+  u.fetcher = src.fetcher
+  u.make_fetch_def = src.make_fetch_def
+  u.make_context = src.make_context
+  u.make_options = src.make_options
+  u.make_request = src.make_request
+  u.make_response = src.make_response
+  u.make_result = src.make_result
+  u.make_point = src.make_point
+  u.make_spec = src.make_spec
+  u.make_url = src.make_url
+  u.param = src.param
+  u.prepare_auth = src.prepare_auth
+  u.prepare_body = src.prepare_body
+  u.prepare_headers = src.prepare_headers
+  u.prepare_method = src.prepare_method
+  u.prepare_params = src.prepare_params
+  u.prepare_path = src.prepare_path
+  u.prepare_query = src.prepare_query
+  u.result_basic = src.result_basic
+  u.result_body = src.result_body
+  u.result_headers = src.result_headers
+  u.transform_request = src.transform_request
+  u.transform_response = src.transform_response
+  u.custom = {}
+  for k, v in pairs(src.custom) do
+    u.custom[k] = v
+  end
+  return u
+end
+
+
+return Utility