@voxgig/sdkgen 0.35.2 → 0.37.0

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

@@ -0,0 +1,16 @@
+# ProjectName SDK utility: feature_init
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  FeatureInit = ->(ctx, f) {
+    fname = f.get_name
+    fopts = {}
+    if ctx.options
+      feature_opts = VoxgigStruct.getprop(ctx.options, "feature")
+      if feature_opts.is_a?(Hash)
+        fo = VoxgigStruct.getprop(feature_opts, fname)
+        fopts = fo if fo.is_a?(Hash)
+      end
+    end
+    f.init(ctx, fopts) if fopts["active"] == true
+  }
+end

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

@@ -0,0 +1,67 @@
+# ProjectName SDK utility: fetcher
+require_relative 'struct/voxgig_struct'
+require 'net/http'
+require 'uri'
+require 'json'
+
+module ProjectNameUtilities
+  DefaultHttpFetch = ->(fullurl, fetchdef) {
+    method_str = fetchdef["method"] || "GET"
+    body_str = fetchdef["body"]
+    headers = fetchdef["headers"] || {}
+
+    uri = URI.parse(fullurl)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = (uri.scheme == "https")
+
+    klass = case method_str.upcase
+            when "POST" then Net::HTTP::Post
+            when "PUT" then Net::HTTP::Put
+            when "DELETE" then Net::HTTP::Delete
+            when "PATCH" then Net::HTTP::Patch
+            else Net::HTTP::Get
+            end
+
+    request = klass.new(uri)
+    headers.each { |k, v| request[k] = v.to_s if v.is_a?(String) }
+    request.body = body_str if body_str.is_a?(String)
+
+    resp = http.request(request)
+    resp_headers = {}
+    resp.each_header { |k, v| resp_headers[k.downcase] = v }
+
+    json_body = nil
+    begin
+      json_body = JSON.parse(resp.body) if resp.body && !resp.body.empty?
+    rescue JSON::ParserError
+    end
+
+    return {
+      "status" => resp.code.to_i,
+      "statusText" => resp.message,
+      "headers" => resp_headers,
+      "json" => -> { json_body },
+      "body" => resp.body,
+    }, nil
+  }
+
+  Fetcher = ->(ctx, fullurl, fetchdef) {
+    if ctx.client.mode != "live"
+      return nil, ctx.make_error("fetch_mode_block",
+        "Request blocked by mode: \"#{ctx.client.mode}\" (URL was: \"#{fullurl}\")")
+    end
+
+    options = ctx.client.options_map
+    if VoxgigStruct.getpath(options, "feature.test.active") == true
+      return nil, ctx.make_error("fetch_test_block",
+        "Request blocked as test feature is active (URL was: \"#{fullurl}\")")
+    end
+
+    sys_fetch = VoxgigStruct.getpath(options, "system.fetch")
+
+    return DefaultHttpFetch.call(fullurl, fetchdef) if sys_fetch.nil?
+    return sys_fetch.call(fullurl, fetchdef) if sys_fetch.is_a?(Proc)
+
+    return nil, ctx.make_error("fetch_invalid", "system.fetch is not a valid function")
+  }
+end

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

@@ -0,0 +1,7 @@
+# ProjectName SDK utility: make_context
+require_relative '../core/context'
+module ProjectNameUtilities
+  MakeContext = ->(ctxmap, basectx) {
+    ProjectNameContext.new(ctxmap, basectx)
+  }
+end

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

@@ -0,0 +1,44 @@
+# ProjectName SDK utility: make_error
+require_relative '../core/operation'
+require_relative '../core/result'
+require_relative '../core/error'
+module ProjectNameUtilities
+  MakeError = ->(ctx, err) {
+    if ctx.nil?
+      require_relative '../core/context'
+      ctx = ProjectNameContext.new({}, nil)
+    end
+    op = ctx.op || ProjectNameOperation.new({})
+    opname = op.name
+    opname = "unknown operation" if opname.empty? || opname == "_"
+
+    result = ctx.result || ProjectNameResult.new({})
+    result.ok = false
+
+    err = result.err if err.nil?
+    err = ctx.make_error("unknown", "unknown error") if err.nil?
+
+    errmsg = err.is_a?(ProjectNameError) ? err.msg : err.to_s
+    msg = "ProjectNameSDK: #{opname}: #{errmsg}"
+    msg = ctx.utility.clean.call(ctx, msg)
+
+    result.err = nil
+    spec = ctx.spec
+
+    if ctx.ctrl.explain
+      ctx.ctrl.explain["err"] = { "message" => msg }
+    end
+
+    sdk_err = ProjectNameError.new("", msg, ctx)
+    sdk_err.result = ctx.utility.clean.call(ctx, result)
+    sdk_err.spec = ctx.utility.clean.call(ctx, spec)
+    sdk_err.code = err.code if err.is_a?(ProjectNameError)
+
+    ctx.ctrl.err = sdk_err
+
+    if ctx.ctrl.throw_err == false
+      return result.resdata, nil
+    end
+    return nil, sdk_err
+  }
+end

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

@@ -0,0 +1,24 @@
+# ProjectName SDK utility: make_fetch_def
+require_relative 'struct/voxgig_struct'
+require_relative '../core/result'
+module ProjectNameUtilities
+  MakeFetchDef = ->(ctx) {
+    spec = ctx.spec
+    return nil, ctx.make_error("fetchdef_no_spec", "Expected context spec property to be defined.") unless spec
+
+    ctx.result = ProjectNameResult.new({}) unless ctx.result
+    spec.step = "prepare"
+
+    url, err = ctx.utility.make_url.call(ctx)
+    return nil, err if err
+
+    spec.url = url
+
+    fetchdef = { "url" => url, "method" => spec.method, "headers" => spec.headers }
+    if spec.body
+      fetchdef["body"] = spec.body.is_a?(Hash) ? VoxgigStruct.jsonify(spec.body) : spec.body
+    end
+
+    return fetchdef, nil
+  }
+end

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

@@ -0,0 +1,57 @@
+# ProjectName SDK utility: make_options
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  MakeOptions = ->(ctx) {
+    options = ctx.options || {}
+
+    custom_utils = VoxgigStruct.getprop(options, "utility")
+    if custom_utils.is_a?(Hash) && ctx.utility
+      custom_utils.each { |k, v| ctx.utility.custom[k] = v }
+    end
+
+    opts = VoxgigStruct.clone(options)
+    opts = {} unless opts.is_a?(Hash)
+
+    config = ctx.config || {}
+    cfgopts = config["options"].is_a?(Hash) ? config["options"] : {}
+
+    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" },
+    }
+
+    sys_fetch = VoxgigStruct.getpath(opts, "system.fetch")
+
+    merged = VoxgigStruct.merge([{}, cfgopts, opts])
+    validated = VoxgigStruct.validate(merged, optspec)
+    opts = validated.is_a?(Hash) ? validated : {}
+
+    if sys_fetch
+      opts["system"] = {} unless opts["system"].is_a?(Hash)
+      opts["system"]["fetch"] = sys_fetch
+    end
+
+    clean_keys = VoxgigStruct.getpath(opts, "clean.keys")
+    clean_keys = "key,token,id" unless clean_keys.is_a?(String)
+    parts = clean_keys.split(",").map(&:strip).reject(&:empty?).map { |p| VoxgigStruct.escre(p) }
+    keyre = parts.join("|")
+    derived = { "clean" => keyre.empty? ? {} : { "keyre" => keyre } }
+    opts["__derived__"] = derived
+
+    opts
+  }
+end

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

@@ -0,0 +1,77 @@
+# ProjectName SDK utility: make_point
+require_relative 'struct/voxgig_struct'
+require_relative '../core/helpers'
+module ProjectNameUtilities
+  MakePoint = ->(ctx) {
+    if ctx.out["point"]
+      ctx.point = ctx.out["point"]
+      return ctx.point, nil
+    end
+
+    op = ctx.op
+    options = ctx.options
+
+    allow_op = VoxgigStruct.getpath(options, "allow.op") || ""
+    unless allow_op.include?(op.name)
+      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.empty?
+      return nil, ctx.make_error("point_no_points",
+        "Operation \"#{op.name}\" has no endpoint definitions.")
+    end
+
+    if op.points.length == 1
+      ctx.point = op.points[0]
+    else
+      reqselector = op.input == "data" ? ctx.reqdata : ctx.reqmatch
+      selector = op.input == "data" ? ctx.data : ctx.match
+
+      point = nil
+      op.points.each do |p|
+        point = p
+        select_def = ProjectNameHelpers.to_map(VoxgigStruct.getprop(p, "select"))
+        found = true
+
+        if selector && select_def
+          exist = VoxgigStruct.getprop(select_def, "exist")
+          if exist.is_a?(Array)
+            exist.each do |ek|
+              rv = VoxgigStruct.getprop(reqselector, ek.to_s)
+              sv = VoxgigStruct.getprop(selector, ek.to_s)
+              if rv.nil? && sv.nil?
+                found = false
+                break
+              end
+            end
+          end
+        end
+
+        if found
+          req_action = VoxgigStruct.getprop(reqselector, "$action")
+          select_action = VoxgigStruct.getprop(select_def, "$action")
+          found = false if req_action != select_action
+        end
+
+        break if found
+      end
+
+      if reqselector
+        req_action = VoxgigStruct.getprop(reqselector, "$action")
+        if req_action && point
+          point_select = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "select"))
+          point_action = VoxgigStruct.getprop(point_select, "$action")
+          if req_action != point_action
+            return nil, ctx.make_error("point_action_invalid",
+              "Operation \"#{op.name}\" action \"#{VoxgigStruct.stringify(req_action)}\" is not valid.")
+          end
+        end
+      end
+
+      ctx.point = point
+    end
+
+    return ctx.point, nil
+  }
+end

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

@@ -0,0 +1,44 @@
+# ProjectName SDK utility: make_request
+require_relative '../core/response'
+require_relative '../core/result'
+module ProjectNameUtilities
+  MakeRequest = ->(ctx) {
+    return ctx.out["request"], nil if ctx.out["request"]
+
+    spec = ctx.spec
+    utility = ctx.utility
+    response = ProjectNameResponse.new({})
+    result = ProjectNameResult.new({})
+    ctx.result = result
+
+    return nil, ctx.make_error("request_no_spec", "Expected context spec property to be defined.") unless spec
+
+    fetchdef, err = utility.make_fetch_def.call(ctx)
+    if err
+      response.err = err
+      ctx.response = response
+      spec.step = "postrequest"
+      return response, nil
+    end
+
+    ctx.ctrl.explain["fetchdef"] = fetchdef if ctx.ctrl.explain
+
+    spec.step = "prerequest"
+    url = fetchdef["url"] || ""
+    fetched, fetch_err = utility.fetcher.call(ctx, url, fetchdef)
+
+    if fetch_err
+      response.err = fetch_err
+    elsif fetched.nil?
+      response = ProjectNameResponse.new({ "err" => ctx.make_error("request_no_response", "response: undefined") })
+    elsif fetched.is_a?(Hash)
+      response = ProjectNameResponse.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

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

@@ -0,0 +1,25 @@
+# ProjectName SDK utility: make_response
+module ProjectNameUtilities
+  MakeResponse = ->(ctx) {
+    return ctx.out["response"], nil if ctx.out["response"]
+    utility = ctx.utility
+    spec = ctx.spec
+    result = ctx.result
+    response = ctx.response
+
+    return nil, ctx.make_error("response_no_spec", "Expected context spec property to be defined.") unless spec
+    return nil, ctx.make_error("response_no_response", "Expected context response property to be defined.") unless response
+    return nil, ctx.make_error("response_no_result", "Expected context result property to be defined.") unless result
+
+    spec.step = "response"
+    utility.result_basic.call(ctx)
+    utility.result_headers.call(ctx)
+    utility.result_body.call(ctx)
+    utility.transform_response.call(ctx)
+
+    result.ok = true if result.err.nil?
+    ctx.ctrl.explain["result"] = result if ctx.ctrl.explain
+
+    return response, nil
+  }
+end

package/project/.sdk/tm/rb/utility/make_result.rb

@@ -0,0 +1,33 @@
+# ProjectName SDK utility: make_result
+module ProjectNameUtilities
+  MakeResult = ->(ctx) {
+    return ctx.out["result"], nil if ctx.out["result"]
+    utility = ctx.utility
+    op = ctx.op
+    entity = ctx.entity
+    spec = ctx.spec
+    result = ctx.result
+
+    return nil, ctx.make_error("result_no_spec", "Expected context spec property to be defined.") unless spec
+    return nil, ctx.make_error("result_no_result", "Expected context result property to be defined.") unless result
+
+    spec.step = "result"
+    utility.transform_response.call(ctx)
+
+    if op.name == "list"
+      resdata = result.resdata
+      result.resdata = []
+      if resdata.is_a?(Array) && !resdata.empty? && entity
+        entities = resdata.map do |entry|
+          ent = entity.make
+          ent.data_set(entry) if entry.is_a?(Hash)
+          ent
+        end
+        result.resdata = entities
+      end
+    end
+
+    ctx.ctrl.explain["result"] = result if ctx.ctrl.explain
+    return result, nil
+  }
+end

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

@@ -0,0 +1,50 @@
+# ProjectName SDK utility: make_spec
+require_relative 'struct/voxgig_struct'
+require_relative '../core/spec'
+module ProjectNameUtilities
+  MakeSpec = ->(ctx) {
+    if ctx.out["spec"]
+      ctx.spec = ctx.out["spec"]
+      return ctx.spec, nil
+    end
+
+    point = ctx.point
+    options = ctx.options
+    utility = ctx.utility
+
+    base = VoxgigStruct.getprop(options, "base") || ""
+    prefix = VoxgigStruct.getprop(options, "prefix") || ""
+    suffix = VoxgigStruct.getprop(options, "suffix") || ""
+
+    parts = []
+    parts = VoxgigStruct.getprop(point, "parts") if point
+    parts = [] unless parts.is_a?(Array)
+
+    ctx.spec = ProjectNameSpec.new({
+      "base" => base, "prefix" => prefix, "parts" => parts,
+      "suffix" => suffix, "step" => "start",
+    })
+
+    ctx.spec.method = utility.prepare_method.call(ctx)
+
+    allow_method = VoxgigStruct.getpath(options, "allow.method") || ""
+    unless allow_method.include?(ctx.spec.method)
+      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.call(ctx)
+    ctx.spec.query = utility.prepare_query.call(ctx)
+    ctx.spec.headers = utility.prepare_headers.call(ctx)
+    ctx.spec.body = utility.prepare_body.call(ctx)
+    ctx.spec.path = utility.prepare_path.call(ctx)
+
+    ctx.ctrl.explain["spec"] = ctx.spec if ctx.ctrl.explain
+
+    spec, err = utility.prepare_auth.call(ctx)
+    return nil, err if err
+
+    ctx.spec = spec
+    return spec, nil
+  }
+end

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

@@ -0,0 +1,32 @@
+# ProjectName SDK utility: make_url
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  MakeUrl = ->(ctx) {
+    spec = ctx.spec
+    result = ctx.result
+
+    return "", ctx.make_error("url_no_spec", "Expected context spec property to be defined.") unless spec
+    return "", ctx.make_error("url_no_result", "Expected context result property to be defined.") unless result
+
+    url = VoxgigStruct.join([spec.base, spec.prefix, spec.path, spec.suffix], "/", true)
+    resmatch = {}
+
+    param_items = VoxgigStruct.items(spec.params)
+    if param_items
+      param_items.each do |item|
+        key = item[0]
+        val = item[1]
+        if val && key.is_a?(String)
+          placeholder = "{#{key}}"
+          val_str = val.is_a?(String) ? val : val.to_s
+          encoded = VoxgigStruct.escurl(val_str)
+          url = url.gsub(placeholder, encoded)
+          resmatch[key] = val
+        end
+      end
+    end
+
+    result.resmatch = resmatch
+    return url, nil
+  }
+end

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

@@ -0,0 +1,48 @@
+# ProjectName SDK utility: param
+require_relative 'struct/voxgig_struct'
+require_relative '../core/helpers'
+module ProjectNameUtilities
+  Param = ->(ctx, paramdef) {
+    point = ctx.point
+    spec = ctx.spec
+    match_val = ctx.match
+    reqmatch = ctx.reqmatch
+    data = ctx.data
+    reqdata = ctx.reqdata
+
+    pt = VoxgigStruct.typify(paramdef)
+    key = if (VoxgigStruct::T_string & pt) > 0
+            paramdef
+          else
+            k = VoxgigStruct.getprop(paramdef, "name")
+            k.is_a?(String) ? k : ""
+          end
+
+    akey = ""
+    if point
+      alias_map = ProjectNameHelpers.to_map(VoxgigStruct.getprop(point, "alias"))
+      if alias_map
+        ak = VoxgigStruct.getprop(alias_map, key)
+        akey = ak if ak.is_a?(String)
+      end
+    end
+
+    val = VoxgigStruct.getprop(reqmatch, key)
+    val = VoxgigStruct.getprop(match_val, key) if val.nil?
+
+    if val.nil? && !akey.empty?
+      spec.alias_map[akey] = key if spec
+      val = VoxgigStruct.getprop(reqmatch, akey)
+    end
+
+    val = VoxgigStruct.getprop(reqdata, key) if val.nil?
+    val = VoxgigStruct.getprop(data, key) if val.nil?
+
+    if val.nil? && !akey.empty?
+      val = VoxgigStruct.getprop(reqdata, akey)
+      val = VoxgigStruct.getprop(data, akey) if val.nil?
+    end
+
+    val
+  }
+end

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

@@ -0,0 +1,26 @@
+# ProjectName SDK utility: prepare_auth
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  HEADER_AUTH = "authorization"
+  OPTION_APIKEY = "apikey"
+  NOT_FOUND = "__NOTFOUND__"
+
+  PrepareAuth = ->(ctx) {
+    spec = ctx.spec
+    return nil, ctx.make_error("auth_no_spec", "Expected context spec property to be defined.") unless spec
+
+    headers = spec.headers
+    options = ctx.client.options_map
+    apikey = VoxgigStruct.getprop(options, OPTION_APIKEY, NOT_FOUND)
+
+    if apikey.is_a?(String) && apikey == NOT_FOUND
+      headers.delete(HEADER_AUTH)
+    else
+      auth_prefix = VoxgigStruct.getpath(options, "auth.prefix") || ""
+      apikey_val = apikey.is_a?(String) ? apikey : ""
+      headers[HEADER_AUTH] = "#{auth_prefix} #{apikey_val}"
+    end
+
+    return spec, nil
+  }
+end

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

@@ -0,0 +1,6 @@
+# ProjectName SDK utility: prepare_body
+module ProjectNameUtilities
+  PrepareBody = ->(ctx) {
+    ctx.op.input == "data" ? ctx.utility.transform_request.call(ctx) : nil
+  }
+end

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

@@ -0,0 +1,11 @@
+# ProjectName SDK utility: prepare_headers
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  PrepareHeaders = ->(ctx) {
+    options = ctx.client.options_map
+    headers = VoxgigStruct.getprop(options, "headers")
+    return {} unless headers
+    out = VoxgigStruct.clone(headers)
+    out.is_a?(Hash) ? out : {}
+  }
+end

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

@@ -0,0 +1,5 @@
+# ProjectName SDK utility: prepare_method
+module ProjectNameUtilities
+  METHOD_MAP = { "create"=>"POST", "update"=>"PUT", "load"=>"GET", "list"=>"GET", "remove"=>"DELETE", "patch"=>"PATCH" }
+  PrepareMethod = ->(ctx) { METHOD_MAP[ctx.op.name] || "GET" }
+end

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

@@ -0,0 +1,25 @@
+# ProjectName SDK utility: prepare_params
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  PrepareParams = ->(ctx) {
+    utility = ctx.utility
+    point = ctx.point
+    params = []
+    if point
+      args = VoxgigStruct.getprop(point, "args")
+      if args.is_a?(Hash)
+        p = VoxgigStruct.getprop(args, "params")
+        params = p if p.is_a?(Array)
+      end
+    end
+    out = {}
+    params.each do |pd|
+      val = utility.param.call(ctx, pd)
+      if val && pd.is_a?(Hash)
+        name = VoxgigStruct.getprop(pd, "name")
+        out[name] = val if name.is_a?(String) && !name.empty?
+      end
+    end
+    out
+  }
+end

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

@@ -0,0 +1,13 @@
+# ProjectName SDK utility: prepare_path
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  PreparePath = ->(ctx) {
+    point = ctx.point
+    parts = []
+    if point
+      p = VoxgigStruct.getprop(point, "parts")
+      parts = p if p.is_a?(Array)
+    end
+    VoxgigStruct.join(parts, "/", true)
+  }
+end

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

@@ -0,0 +1,22 @@
+# ProjectName SDK utility: prepare_query
+require_relative 'struct/voxgig_struct'
+module ProjectNameUtilities
+  PrepareQuery = ->(ctx) {
+    point = ctx.point
+    reqmatch = ctx.reqmatch || {}
+    params = []
+    if point
+      p = VoxgigStruct.getprop(point, "params")
+      params = p if p.is_a?(Array)
+    end
+    out = {}
+    items = VoxgigStruct.items(reqmatch)
+    if items
+      items.each do |item|
+        key, val = item[0], item[1]
+        out[key] = val if val && key.is_a?(String) && !params.include?(key)
+      end
+    end
+    out
+  }
+end