@voxgig/sdkgen 0.35.2 → 0.37.0

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

@@ -0,0 +1,72 @@
+-- ProjectName SDK utility: make_spec
+
+local vs = require("utility.struct.struct")
+local Spec = require("core.spec")
+
+local function make_spec_util(ctx)
+  if ctx.out["spec"] ~= nil then
+    ctx.spec = ctx.out["spec"]
+    return ctx.spec, nil
+  end
+
+  local point = ctx.point
+  local options = ctx.options
+  local utility = ctx.utility
+
+  local base = ""
+  local b = vs.getprop(options, "base")
+  if type(b) == "string" then base = b end
+
+  local prefix = ""
+  local p = vs.getprop(options, "prefix")
+  if type(p) == "string" then prefix = p end
+
+  local suffix = ""
+  local s = vs.getprop(options, "suffix")
+  if type(s) == "string" then suffix = s end
+
+  local parts = {}
+  if point ~= nil then
+    local pt = vs.getprop(point, "parts")
+    if type(pt) == "table" then
+      parts = pt
+    end
+  end
+
+  ctx.spec = Spec.new({
+    base = base,
+    prefix = prefix,
+    parts = parts,
+    suffix = suffix,
+    step = "start",
+  })
+
+  ctx.spec.method = utility.prepare_method(ctx)
+
+  local allow_method = vs.getpath(options, "allow.method") or ""
+  if type(allow_method) == "string" and not string.find(allow_method, ctx.spec.method, 1, true) then
+    return nil, ctx:make_error("spec_method_allow",
+      'Method "' .. ctx.spec.method ..
+      '" not allowed by SDK option allow.method value: "' .. allow_method .. '"')
+  end
+
+  ctx.spec.params = utility.prepare_params(ctx)
+  ctx.spec.query = utility.prepare_query(ctx)
+  ctx.spec.headers = utility.prepare_headers(ctx)
+  ctx.spec.body = utility.prepare_body(ctx)
+  ctx.spec.path = utility.prepare_path(ctx)
+
+  if ctx.ctrl.explain ~= nil then
+    ctx.ctrl.explain["spec"] = ctx.spec
+  end
+
+  local spec, err = utility.prepare_auth(ctx)
+  if err ~= nil then
+    return nil, err
+  end
+
+  ctx.spec = spec
+  return spec, nil
+end
+
+return make_spec_util

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

@@ -0,0 +1,46 @@
+-- ProjectName SDK utility: make_url
+
+local vs = require("utility.struct.struct")
+
+local function make_url_util(ctx)
+  local spec = ctx.spec
+  local result = ctx.result
+
+  if spec == nil then
+    return "", ctx:make_error("url_no_spec",
+      "Expected context spec property to be defined.")
+  end
+  if result == nil then
+    return "", ctx:make_error("url_no_result",
+      "Expected context result property to be defined.")
+  end
+
+  local url = vs.join({ spec.base, spec.prefix, spec.path, spec.suffix }, "/", true)
+  local resmatch = {}
+
+  local param_items = vs.items(spec.params)
+  if param_items ~= nil then
+    for _, item in ipairs(param_items) do
+      local key = item[1]
+      local val = item[2]
+      if val ~= nil and type(key) == "string" then
+        local placeholder = "{" .. key .. "}"
+        local val_str = type(val) == "string" and val or tostring(val)
+        local encoded = vs.escurl(val_str)
+        -- Plain string replacement (not pattern-based)
+        local i, j = url:find(placeholder, 1, true)
+        while i do
+          url = url:sub(1, i - 1) .. encoded .. url:sub(j + 1)
+          i, j = url:find(placeholder, i + #encoded, true)
+        end
+        resmatch[key] = val
+      end
+    end
+  end
+
+  result.resmatch = resmatch
+
+  return url, nil
+end
+
+return make_url_util

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

@@ -0,0 +1,68 @@
+-- ProjectName SDK utility: param
+
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local function param_util(ctx, paramdef)
+  local point = ctx.point
+  local spec = ctx.spec
+  local match = ctx.match
+  local reqmatch = ctx.reqmatch
+  local data = ctx.data
+  local reqdata = ctx.reqdata
+
+  local pt = vs.typify(paramdef)
+  local key = ""
+
+  if (vs.T_string & pt) > 0 then
+    key = paramdef
+  else
+    local k = vs.getprop(paramdef, "name")
+    if type(k) == "string" then
+      key = k
+    end
+  end
+
+  local akey = ""
+  if point ~= nil then
+    local alias = helpers.to_map(vs.getprop(point, "alias"))
+    if alias ~= nil then
+      local ak = vs.getprop(alias, key)
+      if type(ak) == "string" then
+        akey = ak
+      end
+    end
+  end
+
+  local val = vs.getprop(reqmatch, key)
+
+  if val == nil then
+    val = vs.getprop(match, key)
+  end
+
+  if val == nil and akey ~= "" then
+    if spec ~= nil then
+      spec.alias[akey] = key
+    end
+    val = vs.getprop(reqmatch, akey)
+  end
+
+  if val == nil then
+    val = vs.getprop(reqdata, key)
+  end
+
+  if val == nil then
+    val = vs.getprop(data, key)
+  end
+
+  if val == nil and akey ~= "" then
+    val = vs.getprop(reqdata, akey)
+    if val == nil then
+      val = vs.getprop(data, akey)
+    end
+  end
+
+  return val
+end
+
+return param_util

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

@@ -0,0 +1,39 @@
+-- ProjectName SDK utility: prepare_auth
+
+local vs = require("utility.struct.struct")
+
+local HEADER_AUTH = "authorization"
+local OPTION_APIKEY = "apikey"
+local NOT_FOUND = "__NOTFOUND__"
+
+local function prepare_auth_util(ctx)
+  local spec = ctx.spec
+  if spec == nil then
+    return nil, ctx:make_error("auth_no_spec",
+      "Expected context spec property to be defined.")
+  end
+
+  local headers = spec.headers
+  local options = ctx.client:options_map()
+
+  local apikey = vs.getprop(options, OPTION_APIKEY, NOT_FOUND)
+
+  if type(apikey) == "string" and apikey == NOT_FOUND then
+    headers[HEADER_AUTH] = nil
+  else
+    local auth_prefix = ""
+    local ap = vs.getpath(options, "auth.prefix")
+    if type(ap) == "string" then
+      auth_prefix = ap
+    end
+    local apikey_val = ""
+    if type(apikey) == "string" then
+      apikey_val = apikey
+    end
+    headers[HEADER_AUTH] = auth_prefix .. " " .. apikey_val
+  end
+
+  return spec, nil
+end
+
+return prepare_auth_util

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

@@ -0,0 +1,14 @@
+-- ProjectName SDK utility: prepare_body
+
+local function prepare_body_util(ctx)
+  local op = ctx.op
+
+  if op.input == "data" then
+    local body = ctx.utility.transform_request(ctx)
+    return body
+  end
+
+  return nil
+end
+
+return prepare_body_util

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

@@ -0,0 +1,20 @@
+-- ProjectName SDK utility: prepare_headers
+
+local vs = require("utility.struct.struct")
+
+local function prepare_headers_util(ctx)
+  local options = ctx.client:options_map()
+  local headers = vs.getprop(options, "headers")
+
+  if headers == nil then
+    return {}
+  end
+
+  local out = vs.clone(headers)
+  if type(out) == "table" then
+    return out
+  end
+  return {}
+end
+
+return prepare_headers_util

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

@@ -0,0 +1,17 @@
+-- ProjectName SDK utility: prepare_method
+
+local METHOD_MAP = {
+  create = "POST",
+  update = "PUT",
+  load = "GET",
+  list = "GET",
+  remove = "DELETE",
+  patch = "PATCH",
+}
+
+local function prepare_method_util(ctx)
+  local opname = ctx.op.name
+  return METHOD_MAP[opname] or "GET"
+end
+
+return prepare_method_util

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

@@ -0,0 +1,36 @@
+-- ProjectName SDK utility: prepare_params
+
+local vs = require("utility.struct.struct")
+
+local function prepare_params_util(ctx)
+  local utility = ctx.utility
+  local point = ctx.point
+
+  local params = {}
+  if point ~= nil then
+    local args = vs.getprop(point, "args")
+    if type(args) == "table" then
+      local p = vs.getprop(args, "params")
+      if type(p) == "table" then
+        params = p
+      end
+    end
+  end
+
+  local out = {}
+  for _, pd in ipairs(params) do
+    local val = utility.param(ctx, pd)
+    if val ~= nil then
+      if type(pd) == "table" then
+        local name = vs.getprop(pd, "name")
+        if type(name) == "string" and name ~= "" then
+          out[name] = val
+        end
+      end
+    end
+  end
+
+  return out
+end
+
+return prepare_params_util

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

@@ -0,0 +1,19 @@
+-- ProjectName SDK utility: prepare_path
+
+local vs = require("utility.struct.struct")
+
+local function prepare_path_util(ctx)
+  local point = ctx.point
+
+  local parts = {}
+  if point ~= nil then
+    local p = vs.getprop(point, "parts")
+    if type(p) == "table" then
+      parts = p
+    end
+  end
+
+  return vs.join(parts, "/", true)
+end
+
+return prepare_path_util

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

@@ -0,0 +1,41 @@
+-- ProjectName SDK utility: prepare_query
+
+local vs = require("utility.struct.struct")
+
+local function contains_param(params, s)
+  for _, v in ipairs(params) do
+    if type(v) == "string" and v == s then
+      return true
+    end
+  end
+  return false
+end
+
+local function prepare_query_util(ctx)
+  local point = ctx.point
+  local reqmatch = ctx.reqmatch or {}
+
+  local params = {}
+  if point ~= nil then
+    local p = vs.getprop(point, "params")
+    if type(p) == "table" then
+      params = p
+    end
+  end
+
+  local out = {}
+  local reqmatch_items = vs.items(reqmatch)
+  if reqmatch_items ~= nil then
+    for _, item in ipairs(reqmatch_items) do
+      local key = item[1]
+      local val = item[2]
+      if val ~= nil and type(key) == "string" and not contains_param(params, key) then
+        out[key] = val
+      end
+    end
+  end
+
+  return out
+end
+
+return prepare_query_util

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

@@ -0,0 +1,71 @@
+-- ProjectName SDK utility registration
+
+local Utility = require("core.utility_type")
+
+local clean = require("utility.clean")
+local done = require("utility.done")
+local make_error = require("utility.make_error")
+local feature_add = require("utility.feature_add")
+local feature_hook = require("utility.feature_hook")
+local feature_init = require("utility.feature_init")
+local fetcher = require("utility.fetcher")
+local make_fetch_def = require("utility.make_fetch_def")
+local make_context = require("utility.make_context")
+local make_options = require("utility.make_options")
+local make_request = require("utility.make_request")
+local make_response = require("utility.make_response")
+local make_result = require("utility.make_result")
+local make_point = require("utility.make_point")
+local make_spec = require("utility.make_spec")
+local make_url = require("utility.make_url")
+local param = require("utility.param")
+local prepare_auth = require("utility.prepare_auth")
+local prepare_body = require("utility.prepare_body")
+local prepare_headers = require("utility.prepare_headers")
+local prepare_method = require("utility.prepare_method")
+local prepare_params = require("utility.prepare_params")
+local prepare_path = require("utility.prepare_path")
+local prepare_query = require("utility.prepare_query")
+local result_basic = require("utility.result_basic")
+local result_body = require("utility.result_body")
+local result_headers = require("utility.result_headers")
+local transform_request = require("utility.transform_request")
+local transform_response = require("utility.transform_response")
+
+
+local function register_all(u)
+  u.clean = clean
+  u.done = done
+  u.make_error = make_error
+  u.feature_add = feature_add
+  u.feature_hook = feature_hook
+  u.feature_init = feature_init
+  u.fetcher = fetcher
+  u.make_fetch_def = make_fetch_def
+  u.make_context = make_context
+  u.make_options = make_options
+  u.make_request = make_request
+  u.make_response = make_response
+  u.make_result = make_result
+  u.make_point = make_point
+  u.make_spec = make_spec
+  u.make_url = make_url
+  u.param = param
+  u.prepare_auth = prepare_auth
+  u.prepare_body = prepare_body
+  u.prepare_headers = prepare_headers
+  u.prepare_method = prepare_method
+  u.prepare_params = prepare_params
+  u.prepare_path = prepare_path
+  u.prepare_query = prepare_query
+  u.result_basic = result_basic
+  u.result_body = result_body
+  u.result_headers = result_headers
+  u.transform_request = transform_request
+  u.transform_response = transform_response
+end
+
+
+Utility._registrar = register_all
+
+return register_all

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

@@ -0,0 +1,32 @@
+-- ProjectName SDK utility: result_basic
+
+local function result_basic_util(ctx)
+  local response = ctx.response
+  local result = ctx.result
+
+  if result ~= nil and response ~= nil then
+    result.status = response.status
+    result.status_text = response.status_text
+
+    if result.status >= 400 then
+      local msg = "request: " .. tostring(result.status) .. ": " .. result.status_text
+      if result.err ~= nil then
+        local prevmsg = ""
+        if type(result.err) == "table" and result.err.msg then
+          prevmsg = result.err.msg
+        else
+          prevmsg = tostring(result.err)
+        end
+        result.err = ctx:make_error("request_status", prevmsg .. ": " .. msg)
+      else
+        result.err = ctx:make_error("request_status", msg)
+      end
+    elseif response.err ~= nil then
+      result.err = response.err
+    end
+  end
+
+  return result
+end
+
+return result_basic_util

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

@@ -0,0 +1,17 @@
+-- ProjectName SDK utility: result_body
+
+local function result_body_util(ctx)
+  local response = ctx.response
+  local result = ctx.result
+
+  if result ~= nil then
+    if response ~= nil and response.json_func ~= nil and response.body ~= nil then
+      local json_data = response.json_func()
+      result.body = json_data
+    end
+  end
+
+  return result
+end
+
+return result_body_util

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

@@ -0,0 +1,22 @@
+-- ProjectName SDK utility: result_headers
+
+local function result_headers_util(ctx)
+  local response = ctx.response
+  local result = ctx.result
+
+  if result ~= nil then
+    if response ~= nil and response.headers ~= nil then
+      if type(response.headers) == "table" then
+        result.headers = response.headers
+      else
+        result.headers = {}
+      end
+    else
+      result.headers = {}
+    end
+  end
+
+  return result
+end
+
+return result_headers_util