@voxgig/sdkgen 0.35.2 → 0.36.0

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

@@ -0,0 +1,86 @@
+-- ProjectName SDK test runner
+
+local json = require("dkjson")
+local vs = require("utility.struct.struct")
+
+local runner = {}
+
+
+function runner.load_env_local()
+  local f = io.open("../../.env.local", "r")
+  if f == nil then
+    return
+  end
+  local content = f:read("*a")
+  f:close()
+  for line in content:gmatch("[^\r\n]+") do
+    line = line:match("^%s*(.-)%s*$")
+    if line ~= "" and not line:match("^#") then
+      local key, val = line:match("^([^=]+)=(.*)$")
+      if key and val then
+        key = key:match("^%s*(.-)%s*$")
+        val = val:match("^%s*(.-)%s*$")
+        -- Set as env variable (platform-dependent, stored in table)
+        runner._env[key] = val
+      end
+    end
+  end
+end
+
+runner._env = {}
+
+function runner.getenv(key)
+  return runner._env[key] or os.getenv(key)
+end
+
+
+function runner.env_override(m)
+  local live = runner.getenv("PROJECTNAME_TEST_LIVE")
+  local override = runner.getenv("PROJECTNAME_TEST_OVERRIDE")
+
+  if live == "TRUE" or override == "TRUE" then
+    for key, _ in pairs(m) do
+      local envval = runner.getenv(key)
+      if envval ~= nil and envval ~= "" then
+        envval = envval:match("^%s*(.-)%s*$")
+        if envval:sub(1, 1) == "{" then
+          local parsed = json.decode(envval)
+          if parsed ~= nil then
+            m[key] = parsed
+            goto continue
+          end
+        end
+        m[key] = envval
+        ::continue::
+      end
+    end
+  end
+
+  local explain = runner.getenv("PROJECTNAME_TEST_EXPLAIN")
+  if explain ~= nil and explain ~= "" then
+    m["PROJECTNAME_TEST_EXPLAIN"] = explain
+  end
+
+  return m
+end
+
+
+function runner.entity_list_to_data(list)
+  local out = {}
+  for _, item in ipairs(list) do
+    if type(item) == "table" then
+      if type(item.data_get) == "function" then
+        local d = item:data_get()
+        if type(d) == "table" then
+          table.insert(out, d)
+        end
+      else
+        table.insert(out, item)
+      end
+    end
+  end
+  return out
+end
+
+
+return runner

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

@@ -0,0 +1,7 @@
+-- ProjectName SDK utility: clean
+
+local function clean_util(ctx, val)
+  return val
+end
+
+return clean_util

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

@@ -0,0 +1,19 @@
+-- ProjectName SDK utility: done
+
+local function done_util(ctx)
+  if ctx.ctrl.explain ~= nil then
+    ctx.ctrl.explain = ctx.utility.clean(ctx, ctx.ctrl.explain)
+    local explain_result = ctx.ctrl.explain["result"]
+    if type(explain_result) == "table" then
+      explain_result["err"] = nil
+    end
+  end
+
+  if ctx.result ~= nil and ctx.result.ok then
+    return ctx.result.resdata, nil
+  end
+
+  return ctx.utility.make_error(ctx, nil)
+end
+
+return done_util

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

@@ -0,0 +1,8 @@
+-- ProjectName SDK utility: feature_add
+
+local function feature_add_util(ctx, f)
+  local client = ctx.client
+  table.insert(client.features, f)
+end
+
+return feature_add_util

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

@@ -0,0 +1,21 @@
+-- ProjectName SDK utility: feature_hook
+
+local function feature_hook_util(ctx, name)
+  local client = ctx.client
+  if client == nil then
+    return
+  end
+  local features = client.features
+  if features == nil then
+    return
+  end
+
+  for _, f in ipairs(features) do
+    local method = f[name]
+    if type(method) == "function" then
+      method(f, ctx)
+    end
+  end
+end
+
+return feature_hook_util

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

@@ -0,0 +1,24 @@
+-- ProjectName SDK utility: feature_init
+
+local vs = require("utility.struct.struct")
+
+local function feature_init_util(ctx, f)
+  local fname = f:get_name()
+  local fopts = {}
+
+  if ctx.options ~= nil then
+    local feature_opts = vs.getprop(ctx.options, "feature")
+    if type(feature_opts) == "table" then
+      local fo = vs.getprop(feature_opts, fname)
+      if type(fo) == "table" then
+        fopts = fo
+      end
+    end
+  end
+
+  if fopts["active"] == true then
+    f:init(ctx, fopts)
+  end
+end
+
+return feature_init_util

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

@@ -0,0 +1,96 @@
+-- ProjectName SDK utility: fetcher
+
+local vs = require("utility.struct.struct")
+local json = require("dkjson")
+
+local function default_http_fetch(fullurl, fetchdef)
+  -- Use LuaSocket or similar for real HTTP requests.
+  -- This is the default live implementation.
+  local http_ok, http = pcall(require, "socket.http")
+  local ltn12_ok, ltn12 = pcall(require, "ltn12")
+
+  if not http_ok or not ltn12_ok then
+    return nil, "HTTP library not available (install luasocket)"
+  end
+
+  local method = fetchdef["method"] or "GET"
+  local body_str = fetchdef["body"]
+  local headers = fetchdef["headers"] or {}
+
+  if type(body_str) ~= "string" then
+    body_str = nil
+  end
+
+  if body_str ~= nil then
+    headers["content-length"] = tostring(#body_str)
+  end
+
+  local response_body = {}
+  local res, code, response_headers = http.request({
+    url = fullurl,
+    method = method,
+    headers = headers,
+    source = body_str and ltn12.source.string(body_str) or nil,
+    sink = ltn12.sink.table(response_body),
+  })
+
+  if not res then
+    return nil, code
+  end
+
+  local body = table.concat(response_body)
+  local resp_headers = {}
+  if type(response_headers) == "table" then
+    for k, v in pairs(response_headers) do
+      resp_headers[string.lower(k)] = v
+    end
+  end
+
+  local json_body = nil
+  if #body > 0 then
+    json_body = json.decode(body)
+  end
+
+  local status_text = "OK"
+  if code >= 400 then
+    status_text = "Error"
+  end
+
+  return {
+    status = code,
+    statusText = status_text,
+    headers = resp_headers,
+    json = function() return json_body end,
+    body = body,
+  }, nil
+end
+
+
+local function fetcher_util(ctx, fullurl, fetchdef)
+  if ctx.client.mode ~= "live" then
+    return nil, ctx:make_error("fetch_mode_block",
+      'Request blocked by mode: "' .. ctx.client.mode ..
+      '" (URL was: "' .. fullurl .. '")')
+  end
+
+  local options = ctx.client:options_map()
+  if vs.getpath(options, "feature.test.active") == true then
+    return nil, ctx:make_error("fetch_test_block",
+      'Request blocked as test feature is active' ..
+      ' (URL was: "' .. fullurl .. '")')
+  end
+
+  local sys_fetch = vs.getpath(options, "system.fetch")
+
+  if sys_fetch == nil then
+    return default_http_fetch(fullurl, fetchdef)
+  end
+
+  if type(sys_fetch) == "function" then
+    return sys_fetch(fullurl, fetchdef)
+  end
+
+  return nil, ctx:make_error("fetch_invalid", "system.fetch is not a valid function")
+end
+
+return fetcher_util

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

@@ -0,0 +1,9 @@
+-- ProjectName SDK utility: make_context
+
+local Context = require("core.context")
+
+local function make_context_util(ctxmap, basectx)
+  return Context.new(ctxmap, basectx)
+end
+
+return make_context_util

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

@@ -0,0 +1,73 @@
+-- ProjectName SDK utility: make_error
+
+local Operation = require("core.operation")
+local Result = require("core.result")
+local Control = require("core.control")
+local ProjectNameError = require("core.error")
+
+local function make_error_util(ctx, err)
+  if ctx == nil then
+    local Context = require("core.context")
+    ctx = Context.new({}, nil)
+  end
+
+  local op = ctx.op
+  if op == nil then
+    op = Operation.new({})
+  end
+  local opname = op.name
+  if opname == "" or opname == "_" then
+    opname = "unknown operation"
+  end
+
+  local result = ctx.result
+  if result == nil then
+    result = Result.new({})
+  end
+  result.ok = false
+
+  if err == nil then
+    err = result.err
+  end
+  if err == nil then
+    err = ctx:make_error("unknown", "unknown error")
+  end
+
+  local errmsg = ""
+  if type(err) == "table" and err.msg ~= nil then
+    errmsg = err.msg
+  elseif type(err) == "string" then
+    errmsg = err
+  else
+    errmsg = tostring(err)
+  end
+
+  local msg = "ProjectNameSDK: " .. opname .. ": " .. errmsg
+  msg = ctx.utility.clean(ctx, msg)
+
+  result.err = nil
+
+  local spec = ctx.spec
+
+  if ctx.ctrl.explain ~= nil then
+    ctx.ctrl.explain["err"] = { message = msg }
+  end
+
+  local sdk_err = ProjectNameError.new("", msg, ctx)
+  sdk_err.result = ctx.utility.clean(ctx, result)
+  sdk_err.spec = ctx.utility.clean(ctx, spec)
+
+  if type(err) == "table" and getmetatable(err) == ProjectNameError then
+    sdk_err.code = err.code
+  end
+
+  ctx.ctrl.err = sdk_err
+
+  if ctx.ctrl.throw_err == false then
+    return result.resdata, nil
+  end
+
+  return nil, sdk_err
+end
+
+return make_error_util

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

@@ -0,0 +1,43 @@
+-- ProjectName SDK utility: make_fetch_def
+
+local vs = require("utility.struct.struct")
+
+local function make_fetch_def_util(ctx)
+  local spec = ctx.spec
+  if spec == nil then
+    return nil, ctx:make_error("fetchdef_no_spec",
+      "Expected context spec property to be defined.")
+  end
+
+  local Result = require("core.result")
+  if ctx.result == nil then
+    ctx.result = Result.new({})
+  end
+
+  spec.step = "prepare"
+
+  local url, err = ctx.utility.make_url(ctx)
+  if err ~= nil then
+    return nil, err
+  end
+
+  spec.url = url
+
+  local fetchdef = {
+    url = url,
+    method = spec.method,
+    headers = spec.headers,
+  }
+
+  if spec.body ~= nil then
+    if type(spec.body) == "table" then
+      fetchdef["body"] = vs.jsonify(spec.body)
+    else
+      fetchdef["body"] = spec.body
+    end
+  end
+
+  return fetchdef, nil
+end
+
+return make_fetch_def_util

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

@@ -0,0 +1,116 @@
+-- ProjectName SDK utility: make_options
+
+local vs = require("utility.struct.struct")
+
+local function make_options_util(ctx)
+  local options = ctx.options or {}
+
+  -- Merge custom utility overrides.
+  local custom_utils = vs.getprop(options, "utility")
+  if type(custom_utils) == "table" then
+    local utility = ctx.utility
+    if utility ~= nil then
+      for key, val in pairs(custom_utils) do
+        utility.custom[key] = val
+      end
+    end
+  end
+
+  local opts = vs.clone(options)
+  if type(opts) ~= "table" then
+    opts = {}
+  end
+
+  local config = ctx.config or {}
+  local cfgopts = {}
+  local co = config["options"]
+  if type(co) == "table" then
+    cfgopts = co
+  end
+
+  local 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.
+  local sys_fetch = vs.getpath(opts, "system.fetch")
+
+  local merged = vs.merge({ {}, cfgopts, opts })
+  local validated = vs.validate(merged, optspec)
+  if type(validated) ~= "table" then
+    validated = {}
+  end
+  opts = validated
+
+  -- Restore system.fetch.
+  if sys_fetch ~= nil then
+    if type(opts["system"]) == "table" then
+      opts["system"]["fetch"] = sys_fetch
+    else
+      opts["system"] = { fetch = sys_fetch }
+    end
+  end
+
+  -- Derived clean config.
+  local clean_keys = "key,token,id"
+  local ck = vs.getpath(opts, "clean.keys")
+  if type(ck) == "string" then
+    clean_keys = ck
+  end
+
+  local parts = {}
+  for part in string.gmatch(clean_keys, "[^,]+") do
+    local trimmed = part:match("^%s*(.-)%s*$")
+    if trimmed ~= "" then
+      table.insert(parts, vs.escre(trimmed))
+    end
+  end
+  local keyre = table.concat(parts, "|")
+
+  local derived = { clean = {} }
+  if keyre ~= "" then
+    derived.clean = { keyre = keyre }
+  end
+  opts["__derived__"] = derived
+
+  return opts
+end
+
+return make_options_util

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

@@ -0,0 +1,92 @@
+-- ProjectName SDK utility: make_point
+
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local function make_point_util(ctx)
+  if ctx.out["point"] ~= nil then
+    ctx.point = ctx.out["point"]
+    return ctx.point, nil
+  end
+
+  local op = ctx.op
+  local options = ctx.options
+
+  local allow_op = vs.getpath(options, "allow.op") or ""
+  if type(allow_op) == "string" and not string.find(allow_op, op.name, 1, true) then
+    return nil, ctx:make_error("point_op_allow",
+      'Operation "' .. op.name ..
+      '" not allowed by SDK option allow.op value: "' .. allow_op .. '"')
+  end
+
+  if #op.points == 0 then
+    return nil, ctx:make_error("point_no_points",
+      'Operation "' .. op.name .. '" has no endpoint definitions.')
+  end
+
+  if #op.points == 1 then
+    ctx.point = op.points[1]
+  else
+    local reqselector, selector
+    if op.input == "data" then
+      reqselector = ctx.reqdata
+      selector = ctx.data
+    else
+      reqselector = ctx.reqmatch
+      selector = ctx.match
+    end
+
+    local point = nil
+    for i = 1, #op.points do
+      point = op.points[i]
+      local select_def = helpers.to_map(vs.getprop(point, "select"))
+      local found = true
+
+      if selector ~= nil and select_def ~= nil then
+        local exist = vs.getprop(select_def, "exist")
+        if type(exist) == "table" then
+          for _, ek in ipairs(exist) do
+            local existkey = tostring(ek)
+            local rv = vs.getprop(reqselector, existkey)
+            local sv = vs.getprop(selector, existkey)
+            if rv == nil and sv == nil then
+              found = false
+              break
+            end
+          end
+        end
+      end
+
+      if found then
+        local req_action = vs.getprop(reqselector, "$action")
+        local select_action = vs.getprop(select_def, "$action")
+        if req_action ~= select_action then
+          found = false
+        end
+      end
+
+      if found then
+        break
+      end
+    end
+
+    if reqselector ~= nil then
+      local req_action = vs.getprop(reqselector, "$action")
+      if req_action ~= nil and point ~= nil then
+        local point_select = helpers.to_map(vs.getprop(point, "select"))
+        local point_action = vs.getprop(point_select, "$action")
+        if req_action ~= point_action then
+          return nil, ctx:make_error("point_action_invalid",
+            'Operation "' .. op.name ..
+            '" action "' .. vs.stringify(req_action) .. '" is not valid.')
+        end
+      end
+    end
+
+    ctx.point = point
+  end
+
+  return ctx.point, nil
+end
+
+return make_point_util

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

@@ -0,0 +1,58 @@
+-- ProjectName SDK utility: make_request
+
+local Response = require("core.response")
+local Result = require("core.result")
+
+local function make_request_util(ctx)
+  if ctx.out["request"] ~= nil then
+    return ctx.out["request"], nil
+  end
+
+  local spec = ctx.spec
+  local utility = ctx.utility
+
+  local response = Response.new({})
+  local result = Result.new({})
+  ctx.result = result
+
+  if spec == nil then
+    return nil, ctx:make_error("request_no_spec",
+      "Expected context spec property to be defined.")
+  end
+
+  local fetchdef, err = utility.make_fetch_def(ctx)
+  if err ~= nil then
+    response.err = err
+    ctx.response = response
+    spec.step = "postrequest"
+    return response, nil
+  end
+
+  if ctx.ctrl.explain ~= nil then
+    ctx.ctrl.explain["fetchdef"] = fetchdef
+  end
+
+  spec.step = "prerequest"
+
+  local url = fetchdef["url"] or ""
+  local fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
+
+  if fetch_err ~= nil then
+    response.err = fetch_err
+  elseif fetched == nil then
+    response = Response.new({
+      err = ctx:make_error("request_no_response", "response: undefined"),
+    })
+  elseif type(fetched) == "table" then
+    response = Response.new(fetched)
+  else
+    response.err = ctx:make_error("request_invalid_response", "response: invalid type")
+  end
+
+  spec.step = "postrequest"
+  ctx.response = response
+
+  return response, nil
+end
+
+return make_request_util

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

@@ -0,0 +1,44 @@
+-- ProjectName SDK utility: make_response
+
+local function make_response_util(ctx)
+  if ctx.out["response"] ~= nil then
+    return ctx.out["response"], nil
+  end
+
+  local utility = ctx.utility
+  local spec = ctx.spec
+  local result = ctx.result
+  local response = ctx.response
+
+  if spec == nil then
+    return nil, ctx:make_error("response_no_spec",
+      "Expected context spec property to be defined.")
+  end
+  if response == nil then
+    return nil, ctx:make_error("response_no_response",
+      "Expected context response property to be defined.")
+  end
+  if result == nil then
+    return nil, ctx:make_error("response_no_result",
+      "Expected context result property to be defined.")
+  end
+
+  spec.step = "response"
+
+  utility.result_basic(ctx)
+  utility.result_headers(ctx)
+  utility.result_body(ctx)
+  utility.transform_response(ctx)
+
+  if result.err == nil then
+    result.ok = true
+  end
+
+  if ctx.ctrl.explain ~= nil then
+    ctx.ctrl.explain["result"] = result
+  end
+
+  return response, nil
+end
+
+return make_response_util