@voxgig/sdkgen 0.26.1 → 0.28.0

package/project/.sdk/tm/go/utility/make_target.go

@@ -0,0 +1,95 @@
+package utility
+
+import (
+	"strings"
+
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func makeTargetUtil(ctx *core.Context) (map[string]any, error) {
+	if ctx.Out["target"] != nil {
+		if tm, ok := ctx.Out["target"].(map[string]any); ok {
+			ctx.Target = tm
+			return tm, nil
+		}
+	}
+
+	op := ctx.Op
+	options := ctx.Options
+
+	allowOp, _ := vs.GetPath([]any{"allow", "op"}, options).(string)
+	if !strings.Contains(allowOp, op.Name) {
+		return nil, ctx.MakeError("target_op_allow",
+			"Operation \""+op.Name+
+				"\" not allowed by SDK option allow.op value: \""+allowOp+"\"")
+	}
+
+	if len(op.Targets) == 1 {
+		ctx.Target = op.Targets[0]
+	} else {
+		var reqselector map[string]any
+		var selector map[string]any
+
+		if op.Input == "data" {
+			reqselector = ctx.Reqdata
+			selector = ctx.Data
+		} else {
+			reqselector = ctx.Reqmatch
+			selector = ctx.Match
+		}
+
+		var target map[string]any
+		for i := 0; i < len(op.Targets); i++ {
+			target = op.Targets[i]
+			selectDef := core.ToMapAny(vs.GetProp(target, "select"))
+			found := true
+
+			if selector != nil && selectDef != nil {
+				if exist := vs.GetProp(selectDef, "exist"); exist != nil {
+					if existList, ok := exist.([]any); ok {
+						for _, ek := range existList {
+							existkey, _ := ek.(string)
+							rv := vs.GetProp(reqselector, existkey)
+							sv := vs.GetProp(selector, existkey)
+							if rv == nil && sv == nil {
+								found = false
+								break
+							}
+						}
+					}
+				}
+			}
+
+			if found {
+				reqAction := vs.GetProp(reqselector, "$action")
+				selectAction := vs.GetProp(selectDef, "$action")
+				if reqAction != selectAction {
+					found = false
+				}
+			}
+
+			if found {
+				break
+			}
+		}
+
+		if reqselector != nil {
+			reqAction := vs.GetProp(reqselector, "$action")
+			if reqAction != nil && target != nil {
+				targetSelect := core.ToMapAny(vs.GetProp(target, "select"))
+				targetAction := vs.GetProp(targetSelect, "$action")
+				if reqAction != targetAction {
+					return nil, ctx.MakeError("target_action_invalid",
+						"Operation \""+op.Name+
+							"\" action \""+vs.Stringify(reqAction)+"\" is not valid.")
+				}
+			}
+		}
+
+		ctx.Target = target
+	}
+
+	return ctx.Target, nil
+}

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

@@ -0,0 +1,41 @@
+package utility
+
+import (
+	"regexp"
+
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func makeUrlUtil(ctx *core.Context) (string, error) {
+	spec := ctx.Spec
+	result := ctx.Result
+
+	if spec == nil {
+		return "", ctx.MakeError("url_no_spec",
+			"Expected context spec property to be defined.")
+	}
+	if result == nil {
+		return "", ctx.MakeError("url_no_result",
+			"Expected context result property to be defined.")
+	}
+
+	url := vs.Join([]any{spec.Base, spec.Prefix, spec.Path, spec.Suffix}, "/", true)
+	resmatch := map[string]any{}
+
+	params := spec.Params
+	for _, item := range vs.Items(params) {
+		key, _ := item[0].(string)
+		val := item[1]
+		if val != nil {
+			re := regexp.MustCompile("\\{" + vs.EscRe(key) + "\\}")
+			url = re.ReplaceAllString(url, vs.EscUrl(vs.Stringify(val)))
+			resmatch[key] = val
+		}
+	}
+
+	result.Resmatch = resmatch
+
+	return url, nil
+}

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

@@ -0,0 +1,66 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func paramUtil(ctx *core.Context, paramdef any) any {
+	target := ctx.Target
+	spec := ctx.Spec
+	match := ctx.Match
+	reqmatch := ctx.Reqmatch
+	data := ctx.Data
+	reqdata := ctx.Reqdata
+
+	pt := vs.Typify(paramdef)
+
+	var key string
+	if 0 < (vs.T_string & pt) {
+		key, _ = paramdef.(string)
+	} else {
+		k := vs.GetProp(paramdef, "name")
+		key, _ = k.(string)
+	}
+
+	var akey string
+	if target != nil {
+		alias := core.ToMapAny(vs.GetProp(target, "alias"))
+		if alias != nil {
+			if ak := vs.GetProp(alias, key); ak != nil {
+				akey, _ = ak.(string)
+			}
+		}
+	}
+
+	val := vs.GetProp(reqmatch, key)
+
+	if val == nil {
+		val = vs.GetProp(match, key)
+	}
+
+	if val == nil && akey != "" {
+		if spec != nil {
+			spec.Alias[akey] = key
+		}
+		val = vs.GetProp(reqmatch, akey)
+	}
+
+	if val == nil {
+		val = vs.GetProp(reqdata, key)
+	}
+
+	if val == nil {
+		val = vs.GetProp(data, key)
+	}
+
+	if val == nil && akey != "" {
+		val = vs.GetProp(reqdata, akey)
+		if val == nil {
+			val = vs.GetProp(data, akey)
+		}
+	}
+
+	return val
+}

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

@@ -0,0 +1,40 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+const headerAuth = "authorization"
+const optionApikey = "apikey"
+const notFound = "__NOTFOUND__"
+
+func prepareAuthUtil(ctx *core.Context) (*core.Spec, error) {
+	spec := ctx.Spec
+	if spec == nil {
+		return nil, ctx.MakeError("auth_no_spec",
+			"Expected context spec property to be defined.")
+	}
+
+	headers := spec.Headers
+	options := ctx.Client.OptionsMap()
+
+	apikey := vs.GetProp(options, optionApikey, notFound)
+
+	if apikeyStr, ok := apikey.(string); ok && apikeyStr == notFound {
+		delete(headers, headerAuth)
+	} else {
+		authPrefix := ""
+		if ap := vs.GetPath([]any{"auth", "prefix"}, options); ap != nil {
+			authPrefix, _ = ap.(string)
+		}
+		apikeyVal := ""
+		if av, ok := apikey.(string); ok {
+			apikeyVal = av
+		}
+		headers[headerAuth] = authPrefix + " " + apikeyVal
+	}
+
+	return spec, nil
+}

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

@@ -0,0 +1,14 @@
+package utility
+
+import "GOMODULE/core"
+
+func prepareBodyUtil(ctx *core.Context) any {
+	op := ctx.Op
+
+	if op.Input == "data" {
+		body := ctx.Utility.TransformRequest(ctx)
+		return body
+	}
+
+	return nil
+}

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

@@ -0,0 +1,22 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func prepareHeadersUtil(ctx *core.Context) map[string]any {
+	options := ctx.Client.OptionsMap()
+
+	headers := vs.GetProp(options, "headers")
+	if headers == nil {
+		return map[string]any{}
+	}
+
+	out := vs.Clone(headers)
+	if om, ok := out.(map[string]any); ok {
+		return om
+	}
+	return map[string]any{}
+}

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

@@ -0,0 +1,21 @@
+package utility
+
+import "GOMODULE/core"
+
+func prepareMethodUtil(ctx *core.Context) string {
+	opname := ctx.Op.Name
+
+	methodMap := map[string]string{
+		"create": "POST",
+		"update": "PUT",
+		"load":   "GET",
+		"list":   "GET",
+		"remove": "DELETE",
+		"patch":  "PATCH",
+	}
+
+	if m, ok := methodMap[opname]; ok {
+		return m
+	}
+	return "GET"
+}

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

@@ -0,0 +1,41 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func prepareParamsUtil(ctx *core.Context) map[string]any {
+	utility := ctx.Utility
+	target := ctx.Target
+
+	var params []any
+	if args := vs.GetProp(target, "args"); args != nil {
+		if argsMap, ok := args.(map[string]any); ok {
+			if p := vs.GetProp(argsMap, "params"); p != nil {
+				if pl, ok := p.([]any); ok {
+					params = pl
+				}
+			}
+		}
+	}
+	if params == nil {
+		params = []any{}
+	}
+
+	out := map[string]any{}
+	for _, pd := range params {
+		val := utility.Param(ctx, pd)
+		if val != nil {
+			if pdm, ok := pd.(map[string]any); ok {
+				name, _ := vs.GetProp(pdm, "name").(string)
+				if name != "" {
+					out[name] = val
+				}
+			}
+		}
+	}
+
+	return out
+}

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

@@ -0,0 +1,21 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func preparePathUtil(ctx *core.Context) string {
+	target := ctx.Target
+
+	var parts []any
+	if p := vs.GetProp(target, "parts"); p != nil {
+		if pl, ok := p.([]any); ok {
+			parts = pl
+		}
+	}
+
+	path := vs.Join(parts, "/", true)
+	return path
+}

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

@@ -0,0 +1,47 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func prepareQueryUtil(ctx *core.Context) map[string]any {
+	target := ctx.Target
+	reqmatch := ctx.Reqmatch
+	if reqmatch == nil {
+		reqmatch = map[string]any{}
+	}
+
+	var params []any
+	if target != nil {
+		if p := vs.GetProp(target, "params"); p != nil {
+			if pl, ok := p.([]any); ok {
+				params = pl
+			}
+		}
+	}
+	if params == nil {
+		params = []any{}
+	}
+
+	out := map[string]any{}
+	for _, item := range vs.Items(reqmatch) {
+		key, _ := item[0].(string)
+		val := item[1]
+		if val != nil && !containsStr(params, key) {
+			out[key] = val
+		}
+	}
+
+	return out
+}
+
+func containsStr(list []any, s string) bool {
+	for _, v := range list {
+		if vs, ok := v.(string); ok && vs == s {
+			return true
+		}
+	}
+	return false
+}

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

@@ -0,0 +1,39 @@
+package utility
+
+import "GOMODULE/core"
+
+func init() {
+	core.UtilityRegistrar = registerAll
+}
+
+func registerAll(u *core.Utility) {
+	u.Clean = cleanUtil
+	u.Done = doneUtil
+	u.MakeError = makeErrorUtil
+	u.FeatureAdd = featureAddUtil
+	u.FeatureHook = featureHookUtil
+	u.FeatureInit = featureInitUtil
+	u.Fetcher = fetcherUtil
+	u.MakeFetchDef = makeFetchDefUtil
+	u.MakeContext = makeContextUtil
+	u.MakeOptions = makeOptionsUtil
+	u.MakeRequest = makeRequestUtil
+	u.MakeResponse = makeResponseUtil
+	u.MakeResult = makeResultUtil
+	u.MakeTarget = makeTargetUtil
+	u.MakeSpec = makeSpecUtil
+	u.MakeUrl = makeUrlUtil
+	u.Param = paramUtil
+	u.PrepareAuth = prepareAuthUtil
+	u.PrepareBody = prepareBodyUtil
+	u.PrepareHeaders = prepareHeadersUtil
+	u.PrepareMethod = prepareMethodUtil
+	u.PrepareParams = prepareParamsUtil
+	u.PreparePath = preparePathUtil
+	u.PrepareQuery = prepareQueryUtil
+	u.ResultBasic = resultBasicUtil
+	u.ResultBody = resultBodyUtil
+	u.ResultHeaders = resultHeadersUtil
+	u.TransformRequest = transformRequestUtil
+	u.TransformResponse = transformResponseUtil
+}

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

@@ -0,0 +1,31 @@
+package utility
+
+import (
+	"fmt"
+
+	"GOMODULE/core"
+)
+
+func resultBasicUtil(ctx *core.Context) *core.Result {
+	response := ctx.Response
+	result := ctx.Result
+
+	if result != nil && response != nil {
+		result.Status = response.Status
+		result.StatusText = response.StatusText
+
+		if result.Status >= 400 {
+			msg := "request: " + fmt.Sprintf("%d", result.Status) + ": " + result.StatusText
+			if result.Err != nil {
+				prevmsg := result.Err.Error()
+				result.Err = ctx.MakeError("request_status", prevmsg+": "+msg)
+			} else {
+				result.Err = ctx.MakeError("request_status", msg)
+			}
+		} else if response.Err != nil {
+			result.Err = response.Err
+		}
+	}
+
+	return result
+}

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

@@ -0,0 +1,17 @@
+package utility
+
+import "GOMODULE/core"
+
+func resultBodyUtil(ctx *core.Context) *core.Result {
+	response := ctx.Response
+	result := ctx.Result
+
+	if result != nil {
+		if response != nil && response.JsonFunc != nil && response.Body != nil {
+			json := response.JsonFunc()
+			result.Body = json
+		}
+	}
+
+	return result
+}

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

@@ -0,0 +1,22 @@
+package utility
+
+import "GOMODULE/core"
+
+func resultHeadersUtil(ctx *core.Context) *core.Result {
+	response := ctx.Response
+	result := ctx.Result
+
+	if result != nil {
+		if response != nil && response.Headers != nil {
+			if hm, ok := response.Headers.(map[string]any); ok {
+				result.Headers = hm
+			} else {
+				result.Headers = map[string]any{}
+			}
+		} else {
+			result.Headers = map[string]any{}
+		}
+	}
+
+	return result
+}

package/project/.sdk/tm/go/utility/struct/go.mod

@@ -0,0 +1,3 @@
+module github.com/voxgig/struct
+
+go 1.20