@voxgig/sdkgen 0.35.2 → 0.36.0

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

package/project/.sdk/tm/lua/feature/base_feature.lua

@@ -0,0 +1,35 @@
+-- ProjectName SDK base feature
+
+local BaseFeature = {}
+BaseFeature.__index = BaseFeature
+
+
+function BaseFeature.new()
+  local self = setmetatable({}, BaseFeature)
+  self.version = "0.0.1"
+  self.name = "base"
+  self.active = true
+  return self
+end
+
+function BaseFeature:get_version() return self.version end
+function BaseFeature:get_name() return self.name end
+function BaseFeature:get_active() return self.active end
+
+function BaseFeature:init(ctx, options) end
+function BaseFeature:PostConstruct(ctx) end
+function BaseFeature:PostConstructEntity(ctx) end
+function BaseFeature:SetData(ctx) end
+function BaseFeature:GetData(ctx) end
+function BaseFeature:GetMatch(ctx) end
+function BaseFeature:SetMatch(ctx) end
+function BaseFeature:PrePoint(ctx) end
+function BaseFeature:PreSpec(ctx) end
+function BaseFeature:PreRequest(ctx) end
+function BaseFeature:PreResponse(ctx) end
+function BaseFeature:PreResult(ctx) end
+function BaseFeature:PreDone(ctx) end
+function BaseFeature:PreUnexpected(ctx) end
+
+
+return BaseFeature

package/project/.sdk/tm/lua/feature/log_feature.lua

@@ -0,0 +1,80 @@
+-- ProjectName SDK log feature
+
+local BaseFeature = require("feature.base_feature")
+
+local LogFeature = {}
+LogFeature.__index = LogFeature
+setmetatable(LogFeature, { __index = BaseFeature })
+
+
+function LogFeature.new()
+  local self = setmetatable(BaseFeature.new(), LogFeature)
+  self.version = "0.0.1"
+  self.name = "log"
+  self.active = true
+  self.client = nil
+  self.options = nil
+  self.logger = nil
+  return self
+end
+
+
+function LogFeature:init(ctx, options)
+  self.client = ctx.client
+  self.options = options
+
+  if options["active"] == true then
+    self.active = true
+  else
+    self.active = false
+  end
+
+  if self.active then
+    if type(options["logger"]) == "table" then
+      self.logger = options["logger"]
+    else
+      self.logger = {
+        info = function(_, msg, ...) io.stderr:write("[INFO] " .. msg .. "\n") end,
+        debug = function(_, msg, ...) io.stderr:write("[DEBUG] " .. msg .. "\n") end,
+        warn = function(_, msg, ...) io.stderr:write("[WARN] " .. msg .. "\n") end,
+        error = function(_, msg, ...) io.stderr:write("[ERROR] " .. msg .. "\n") end,
+      }
+    end
+  end
+end
+
+
+function LogFeature:_loghook(hook, ctx, level)
+  if self.logger == nil then
+    return
+  end
+
+  level = level or "info"
+  local opname = ""
+  if ctx.op ~= nil then
+    opname = ctx.op.name
+  end
+
+  local msg = "hook=" .. hook .. " op=" .. opname
+
+  local log_fn = self.logger[level]
+  if type(log_fn) == "function" then
+    log_fn(self.logger, msg)
+  end
+end
+
+
+function LogFeature:PostConstruct(ctx) self:_loghook("PostConstruct", ctx) end
+function LogFeature:PostConstructEntity(ctx) self:_loghook("PostConstructEntity", ctx) end
+function LogFeature:SetData(ctx) self:_loghook("SetData", ctx) end
+function LogFeature:GetData(ctx) self:_loghook("GetData", ctx) end
+function LogFeature:SetMatch(ctx) self:_loghook("SetMatch", ctx) end
+function LogFeature:GetMatch(ctx) self:_loghook("GetMatch", ctx) end
+function LogFeature:PrePoint(ctx) self:_loghook("PrePoint", ctx) end
+function LogFeature:PreSpec(ctx) self:_loghook("PreSpec", ctx) end
+function LogFeature:PreRequest(ctx) self:_loghook("PreRequest", ctx) end
+function LogFeature:PreResponse(ctx) self:_loghook("PreResponse", ctx) end
+function LogFeature:PreResult(ctx) self:_loghook("PreResult", ctx) end
+
+
+return LogFeature

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

@@ -0,0 +1,202 @@
+-- ProjectName SDK test feature
+
+local vs = require("utility.struct.struct")
+local BaseFeature = require("feature.base_feature")
+
+local TestFeature = {}
+TestFeature.__index = TestFeature
+setmetatable(TestFeature, { __index = BaseFeature })
+
+
+function TestFeature.new()
+  local self = setmetatable(BaseFeature.new(), TestFeature)
+  self.version = "0.0.1"
+  self.name = "test"
+  self.active = true
+  self.client = nil
+  self.options = nil
+  return self
+end
+
+
+function TestFeature:init(ctx, options)
+  self.client = ctx.client
+  self.options = options
+
+  local entity = vs.getprop(options, "entity")
+  if type(entity) ~= "table" then
+    entity = {}
+  end
+
+  self.client.mode = "test"
+
+  -- Ensure entity ids are correct.
+  vs.walk(entity, function(key, val, parent, path)
+    if #path == 2 and type(val) == "table" and key ~= nil then
+      val["id"] = key
+    end
+    return val
+  end)
+
+  local test_self = self
+
+  local function test_fetcher(fctx, _fullurl, _fetchdef)
+    local function respond(status, data, extra)
+      local out = {
+        status = status,
+        statusText = "OK",
+        json = function() return data end,
+        body = "not-used",
+      }
+      if type(extra) == "table" then
+        for k, v in pairs(extra) do
+          out[k] = v
+        end
+      end
+      return out, nil
+    end
+
+    local op = fctx.op
+    local entmap = vs.getprop(entity, op.entity)
+    if type(entmap) ~= "table" then
+      entmap = {}
+    end
+
+    if op.name == "load" then
+      local args = test_self:build_args(fctx, op, fctx.reqmatch)
+      local found = vs.select(entmap, args)
+      local ent = vs.getelem(found, 0)
+      if ent == nil then
+        return respond(404, nil, { statusText = "Not found" })
+      end
+      vs.delprop(ent, "$KEY")
+      local out = vs.clone(ent)
+      return respond(200, out, nil)
+
+    elseif op.name == "list" then
+      local args = test_self:build_args(fctx, op, fctx.reqmatch)
+      local found = vs.select(entmap, args)
+      if found == nil then
+        return respond(404, nil, { statusText = "Not found" })
+      end
+      if type(found) == "table" then
+        for _, item in ipairs(found) do
+          vs.delprop(item, "$KEY")
+        end
+      end
+      local out = vs.clone(found)
+      return respond(200, out, nil)
+
+    elseif op.name == "update" then
+      local args = test_self:build_args(fctx, op, fctx.reqdata)
+      local found = vs.select(entmap, args)
+      local ent = vs.getelem(found, 0)
+      if ent == nil then
+        return respond(404, nil, { statusText = "Not found" })
+      end
+      if type(ent) == "table" then
+        local reqdata = fctx.reqdata
+        if reqdata ~= nil then
+          for k, v in pairs(reqdata) do
+            ent[k] = v
+          end
+        end
+      end
+      vs.delprop(ent, "$KEY")
+      local out = vs.clone(ent)
+      return respond(200, out, nil)
+
+    elseif op.name == "remove" then
+      local args = test_self:build_args(fctx, op, fctx.reqmatch)
+      local found = vs.select(entmap, args)
+      local ent = vs.getelem(found, 0)
+      if ent == nil then
+        return respond(404, nil, { statusText = "Not found" })
+      end
+      if type(ent) == "table" then
+        local id = vs.getprop(ent, "id")
+        vs.delprop(entmap, id)
+      end
+      return respond(200, nil, nil)
+
+    elseif op.name == "create" then
+      test_self:build_args(fctx, op, fctx.reqdata)
+      local id = fctx.utility.param(fctx, "id")
+      if id == nil then
+        id = string.format("%04x%04x%04x%04x",
+          math.random(0, 0xFFFF), math.random(0, 0xFFFF),
+          math.random(0, 0xFFFF), math.random(0, 0xFFFF))
+      end
+
+      local ent = vs.clone(fctx.reqdata)
+      if type(ent) == "table" then
+        ent["id"] = id
+        if type(id) == "string" then
+          entmap[id] = ent
+        end
+        vs.delprop(ent, "$KEY")
+        local out = vs.clone(ent)
+        return respond(200, out, nil)
+      end
+      return respond(200, ent, nil)
+    end
+
+    return respond(404, nil, { statusText = "Unknown operation" })
+  end
+
+  ctx.utility.fetcher = test_fetcher
+end
+
+
+function TestFeature:build_args(ctx, op, args)
+  local opname = op.name
+
+  -- Get last point from config.
+  local points = vs.getpath(ctx.config, "entity." .. ctx.entity:get_name() .. ".op." .. opname .. ".points")
+  local point = vs.getelem(points, -1)
+
+  -- Get required params.
+  local params_path = vs.getpath(point, "args.params")
+  local reqd_params = vs.select(params_path, { reqd = true })
+  local reqd = vs.transform(reqd_params, { "`$EACH`", "", "`$KEY.name`" })
+
+  local qand = {}
+  local q = { ["`$AND`"] = qand }
+
+  if args ~= nil then
+    local keys = vs.keysof(args)
+    if keys ~= nil then
+      for _, key in ipairs(keys) do
+        local is_id = (key == "id")
+        local selected = vs.select(reqd, key)
+        local is_reqd = not vs.isempty(selected)
+
+        if is_id or is_reqd then
+          local v = ctx.utility.param(ctx, key)
+          local ka = nil
+          if op.alias ~= nil then
+            ka = vs.getprop(op.alias, key)
+          end
+
+          local qor = { { [key] = v } }
+          if ka ~= nil and type(ka) == "string" then
+            table.insert(qor, { [ka] = v })
+          end
+
+          table.insert(qand, { ["`$OR`"] = qor })
+        end
+      end
+    end
+  end
+
+  q["`$AND`"] = qand
+
+  if ctx.ctrl.explain ~= nil then
+    ctx.ctrl.explain["test"] = { query = q }
+  end
+
+  return q
+end
+
+
+return TestFeature

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

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