@voxgig/sdkgen 0.26.1 → 0.28.0

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

@@ -0,0 +1,7 @@
+package utility
+
+import "GOMODULE/core"
+
+func cleanUtil(ctx *core.Context, val any) any {
+	return val
+}

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

@@ -0,0 +1,20 @@
+package utility
+
+import "GOMODULE/core"
+
+func doneUtil(ctx *core.Context) (any, error) {
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain = cleanUtil(ctx, ctx.Ctrl.Explain).(map[string]any)
+		if explainResult, ok := ctx.Ctrl.Explain["result"]; ok {
+			if rm, ok := explainResult.(map[string]any); ok {
+				delete(rm, "err")
+			}
+		}
+	}
+
+	if ctx.Result != nil && ctx.Result.Ok {
+		return ctx.Result.Resdata, nil
+	}
+
+	return makeErrorUtil(ctx, nil)
+}

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

@@ -0,0 +1,10 @@
+package utility
+
+import "GOMODULE/core"
+
+func featureAddUtil(ctx *core.Context, f core.Feature) {
+	client := ctx.Client
+	features := client.Features
+
+	client.Features = append(features, f)
+}

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

@@ -0,0 +1,30 @@
+package utility
+
+import (
+	"reflect"
+
+	"GOMODULE/core"
+)
+
+func featureHookUtil(ctx *core.Context, name string) {
+	client := ctx.Client
+	if client == nil {
+		return
+	}
+	features := client.Features
+	if features == nil {
+		return
+	}
+
+	for _, f := range features {
+		callFeatureMethod(f, name, ctx)
+	}
+}
+
+func callFeatureMethod(f core.Feature, name string, ctx *core.Context) {
+	v := reflect.ValueOf(f)
+	m := v.MethodByName(name)
+	if m.IsValid() {
+		m.Call([]reflect.Value{reflect.ValueOf(ctx)})
+	}
+}

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

@@ -0,0 +1,30 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func featureInitUtil(ctx *core.Context, f core.Feature) {
+	fname := f.GetName()
+	fopts := map[string]any{}
+
+	if ctx.Options != nil {
+		if featureOpts := vs.GetProp(ctx.Options, "feature"); featureOpts != nil {
+			if fm, ok := featureOpts.(map[string]any); ok {
+				if fo := vs.GetProp(fm, fname); fo != nil {
+					if fom, ok := fo.(map[string]any); ok {
+						fopts = fom
+					}
+				}
+			}
+		}
+	}
+
+	if active, ok := fopts["active"]; ok {
+		if ab, ok := active.(bool); ok && ab {
+			f.Init(ctx, fopts)
+		}
+	}
+}

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

@@ -0,0 +1,102 @@
+package utility
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any, error) {
+	method, _ := fetchdef["method"].(string)
+	if method == "" {
+		method = "GET"
+	}
+
+	var bodyReader io.Reader
+	if body, ok := fetchdef["body"].(string); ok && body != "" {
+		bodyReader = strings.NewReader(body)
+	}
+
+	req, err := http.NewRequest(method, fullurl, bodyReader)
+	if err != nil {
+		return nil, err
+	}
+
+	if headers, ok := fetchdef["headers"].(map[string]any); ok {
+		for k, v := range headers {
+			if sv, ok := v.(string); ok {
+				req.Header.Set(k, sv)
+			}
+		}
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	headers := map[string]any{}
+	for k, vals := range resp.Header {
+		if len(vals) == 1 {
+			headers[strings.ToLower(k)] = vals[0]
+		} else {
+			headers[strings.ToLower(k)] = strings.Join(vals, ", ")
+		}
+	}
+
+	var jsonBody any
+	if len(bodyBytes) > 0 {
+		json.Unmarshal(bodyBytes, &jsonBody)
+	}
+
+	statusText := resp.Status
+	if idx := strings.Index(statusText, " "); idx >= 0 {
+		statusText = statusText[idx+1:]
+	}
+
+	return map[string]any{
+		"status":     resp.StatusCode,
+		"statusText": statusText,
+		"headers":    headers,
+		"json":       (func() any)(func() any { return jsonBody }),
+		"body":       string(bodyBytes),
+	}, nil
+}
+
+func fetcherUtil(ctx *core.Context, fullurl string, fetchdef map[string]any) (any, error) {
+	if ctx.Client.Mode != "live" {
+		return nil, ctx.MakeError("fetch_mode_block",
+			"Request blocked by mode: \""+ctx.Client.Mode+
+				"\" (URL was: \""+fullurl+"\")")
+	}
+
+	options := ctx.Client.OptionsMap()
+	if vs.GetPath([]any{"feature", "test", "active"}, options) == true {
+		return nil, ctx.MakeError("fetch_test_block",
+			"Request blocked as test feature is active"+
+				" (URL was: \""+fullurl+"\")")
+	}
+
+	sysFetch := vs.GetPath([]any{"system", "fetch"}, options)
+
+	if sysFetch == nil {
+		return defaultHTTPFetch(fullurl, fetchdef)
+	}
+
+	if fetchFunc, ok := sysFetch.(func(string, map[string]any) (map[string]any, error)); ok {
+		return fetchFunc(fullurl, fetchdef)
+	}
+
+	return nil, ctx.MakeError("fetch_invalid", "system.fetch is not a valid function")
+}

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

@@ -0,0 +1,7 @@
+package utility
+
+import "GOMODULE/core"
+
+func makeContextUtil(ctxmap map[string]any, basectx *core.Context) *core.Context {
+	return core.NewContext(ctxmap, basectx)
+}

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

@@ -0,0 +1,69 @@
+package utility
+
+import "GOMODULE/core"
+
+func makeErrorUtil(ctx *core.Context, err error) (any, error) {
+	if ctx == nil {
+		ctx = &core.Context{
+			Ctrl: &core.Control{},
+			Op:   core.NewOperation(map[string]any{}),
+		}
+	}
+
+	op := ctx.Op
+	if op == nil {
+		op = core.NewOperation(map[string]any{})
+	}
+	opname := op.Name
+	if opname == "" || opname == "_" {
+		opname = "unknown operation"
+	}
+
+	result := ctx.Result
+	if result == nil {
+		result = core.NewResult(map[string]any{})
+	}
+	result.Ok = false
+
+	if err == nil {
+		err = result.Err
+	}
+	if err == nil {
+		err = ctx.MakeError("unknown", "unknown error")
+	}
+
+	errmsg := err.Error()
+	msg := "ProjectNameSDK: " + opname + ": " + errmsg
+	msg = cleanUtil(ctx, msg).(string)
+
+	result.Err = nil
+
+	spec := ctx.Spec
+
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain["err"] = map[string]any{
+			"message": msg,
+		}
+	}
+
+	sdkErr := &core.ProjectNameError{
+		IsProjectNameError: true,
+		Sdk:              "ProjectName",
+		Code:             "",
+		Msg:              msg,
+		Ctx:              ctx,
+		Result:           cleanUtil(ctx, result),
+		Spec:             cleanUtil(ctx, spec),
+	}
+	if se, ok := err.(*core.ProjectNameError); ok {
+		sdkErr.Code = se.Code
+	}
+
+	ctx.Ctrl.Err = sdkErr
+
+	if ctx.Ctrl.Throw != nil && *ctx.Ctrl.Throw == false {
+		return result.Resdata, nil
+	}
+
+	return nil, sdkErr
+}

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

@@ -0,0 +1,44 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func makeFetchDefUtil(ctx *core.Context) (map[string]any, error) {
+	spec := ctx.Spec
+	if spec == nil {
+		return nil, ctx.MakeError("fetchdef_no_spec",
+			"Expected context spec property to be defined.")
+	}
+
+	if ctx.Result == nil {
+		ctx.Result = core.NewResult(map[string]any{})
+	}
+
+	spec.Step = "prepare"
+
+	url, err := ctx.Utility.MakeUrl(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	spec.Url = url
+
+	fetchdef := map[string]any{
+		"url":     url,
+		"method":  spec.Method,
+		"headers": spec.Headers,
+	}
+
+	if spec.Body != nil {
+		if _, ok := spec.Body.(map[string]any); ok {
+			fetchdef["body"] = vs.Jsonify(spec.Body)
+		} else {
+			fetchdef["body"] = spec.Body
+		}
+	}
+
+	return fetchdef, nil
+}

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

@@ -0,0 +1,130 @@
+package utility
+
+import (
+	"strings"
+
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func makeOptionsUtil(ctx *core.Context) map[string]any {
+	options := ctx.Options
+	if options == nil {
+		options = map[string]any{}
+	}
+
+	// Merge custom utility overrides onto the utility object.
+	// Read from original options before clone, since vs.Clone strips functions.
+	if customUtils := core.ToMapAny(options["utility"]); customUtils != nil {
+		utility := ctx.Utility
+		if utility != nil {
+			for key, val := range customUtils {
+				utility.Custom[key] = val
+			}
+		}
+	}
+
+	opts := vs.Clone(options).(map[string]any)
+
+	config := ctx.Config
+	if config == nil {
+		config = map[string]any{}
+	}
+	cfgopts := map[string]any{}
+	if co, ok := config["options"]; ok && co != nil {
+		if cm, ok := co.(map[string]any); ok {
+			cfgopts = cm
+		}
+	}
+
+	optspec := map[string]any{
+		"apikey": "",
+		"base":   "http://localhost:8000",
+		"prefix": "",
+		"suffix": "",
+		"auth": map[string]any{
+			"prefix": "",
+		},
+		"headers": map[string]any{
+			"`$CHILD`": "`$STRING`",
+		},
+		"allow": map[string]any{
+			"method": "GET,PUT,POST,PATCH,DELETE,OPTIONS",
+			"op":     "create,update,load,list,remove,command,direct",
+		},
+		"entity": map[string]any{
+			"`$CHILD`": map[string]any{
+				"`$OPEN`": true,
+				"active":  false,
+				"alias":   map[string]any{},
+			},
+		},
+		"feature": map[string]any{
+			"`$CHILD`": map[string]any{
+				"`$OPEN`": true,
+				"active":  false,
+			},
+		},
+		"utility": map[string]any{},
+		"system":  map[string]any{},
+		"test": map[string]any{
+			"active": false,
+			"entity": map[string]any{
+				"`$OPEN`": true,
+			},
+		},
+		"clean": map[string]any{
+			"keys": "key,token,id",
+		},
+	}
+
+	// Preserve system.fetch before merge/validate.
+	var sysFetch any
+	if sf := vs.GetPath([]any{"system", "fetch"}, opts); sf != nil {
+		sysFetch = sf
+	}
+
+	merged := vs.Merge([]any{map[string]any{}, cfgopts, opts})
+	validated, _ := vs.Validate(merged, optspec)
+	opts = validated.(map[string]any)
+
+	// Restore system.fetch.
+	if sysFetch != nil {
+		if sys, ok := opts["system"]; ok {
+			if sm, ok := sys.(map[string]any); ok {
+				sm["fetch"] = sysFetch
+			}
+		} else {
+			opts["system"] = map[string]any{"fetch": sysFetch}
+		}
+	}
+
+	// Derived clean config.
+	cleanKeys := "key,token,id"
+	if ck := vs.GetPath([]any{"clean", "keys"}, opts); ck != nil {
+		if cks, ok := ck.(string); ok {
+			cleanKeys = cks
+		}
+	}
+
+	parts := strings.Split(cleanKeys, ",")
+	var filtered []string
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p != "" {
+			filtered = append(filtered, vs.EscRe(p))
+		}
+	}
+	keyre := strings.Join(filtered, "|")
+
+	derived := map[string]any{
+		"clean": map[string]any{},
+	}
+	if keyre != "" {
+		derived["clean"] = map[string]any{"keyre": keyre}
+	}
+	opts["__derived__"] = derived
+
+	return opts
+}

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

@@ -0,0 +1,59 @@
+package utility
+
+import "GOMODULE/core"
+
+func makeRequestUtil(ctx *core.Context) (*core.Response, error) {
+	if ctx.Out["request"] != nil {
+		if resp, ok := ctx.Out["request"].(*core.Response); ok {
+			return resp, nil
+		}
+	}
+
+	spec := ctx.Spec
+	utility := ctx.Utility
+
+	response := core.NewResponse(map[string]any{})
+	result := core.NewResult(map[string]any{})
+	ctx.Result = result
+
+	if spec == nil {
+		return nil, ctx.MakeError("request_no_spec",
+			"Expected context spec property to be defined.")
+	}
+
+	fetchdef, err := utility.MakeFetchDef(ctx)
+	if err != nil {
+		response.Err = err
+		ctx.Response = response
+		spec.Step = "postrequest"
+		return response, nil
+	}
+
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain["fetchdef"] = fetchdef
+	}
+
+	spec.Step = "prerequest"
+
+	url, _ := fetchdef["url"].(string)
+	fetched, fetchErr := utility.Fetcher(ctx, url, fetchdef)
+
+	if fetchErr != nil {
+		response.Err = fetchErr
+	} else if fetched == nil {
+		response = core.NewResponse(map[string]any{
+			"err": ctx.MakeError("request_no_response", "response: undefined"),
+		})
+	} else {
+		if fm, ok := fetched.(map[string]any); ok {
+			response = core.NewResponse(fm)
+		} else {
+			response.Err = ctx.MakeError("request_invalid_response", "response: invalid type")
+		}
+	}
+
+	spec.Step = "postrequest"
+	ctx.Response = response
+
+	return response, nil
+}

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

@@ -0,0 +1,46 @@
+package utility
+
+import "GOMODULE/core"
+
+func makeResponseUtil(ctx *core.Context) (*core.Response, error) {
+	if ctx.Out["response"] != nil {
+		if resp, ok := ctx.Out["response"].(*core.Response); ok {
+			return resp, nil
+		}
+	}
+
+	utility := ctx.Utility
+	spec := ctx.Spec
+	result := ctx.Result
+	response := ctx.Response
+
+	if spec == nil {
+		return nil, ctx.MakeError("response_no_spec",
+			"Expected context spec property to be defined.")
+	}
+	if response == nil {
+		return nil, ctx.MakeError("response_no_response",
+			"Expected context response property to be defined.")
+	}
+	if result == nil {
+		return nil, ctx.MakeError("response_no_result",
+			"Expected context result property to be defined.")
+	}
+
+	spec.Step = "response"
+
+	utility.ResultBasic(ctx)
+	utility.ResultHeaders(ctx)
+	utility.ResultBody(ctx)
+	utility.TransformResponse(ctx)
+
+	if result.Err == nil {
+		result.Ok = true
+	}
+
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain["result"] = result
+	}
+
+	return response, nil
+}

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

@@ -0,0 +1,55 @@
+package utility
+
+import "GOMODULE/core"
+
+func makeResultUtil(ctx *core.Context) (*core.Result, error) {
+	if ctx.Out["result"] != nil {
+		if res, ok := ctx.Out["result"].(*core.Result); ok {
+			return res, nil
+		}
+	}
+
+	utility := ctx.Utility
+	op := ctx.Op
+	entity := ctx.Entity
+	spec := ctx.Spec
+	result := ctx.Result
+
+	if spec == nil {
+		return nil, ctx.MakeError("result_no_spec",
+			"Expected context spec property to be defined.")
+	}
+	if result == nil {
+		return nil, ctx.MakeError("result_no_result",
+			"Expected context result property to be defined.")
+	}
+
+	spec.Step = "result"
+
+	utility.TransformResponse(ctx)
+
+	if op.Name == "list" {
+		resdata := result.Resdata
+		result.Resdata = []any{}
+
+		if resdata != nil {
+			if list, ok := resdata.([]any); ok && len(list) > 0 && entity != nil {
+				var entities []any
+				for _, entry := range list {
+					ent := entity.Make()
+					if entryMap, ok := entry.(map[string]any); ok {
+						ent.Data(entryMap)
+					}
+					entities = append(entities, ent)
+				}
+				result.Resdata = entities
+			}
+		}
+	}
+
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain["result"] = result
+	}
+
+	return result, nil
+}

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

@@ -0,0 +1,68 @@
+package utility
+
+import (
+	"strings"
+
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func makeSpecUtil(ctx *core.Context) (*core.Spec, error) {
+	if ctx.Out["spec"] != nil {
+		if sp, ok := ctx.Out["spec"].(*core.Spec); ok {
+			ctx.Spec = sp
+			return sp, nil
+		}
+	}
+
+	target := ctx.Target
+	options := ctx.Options
+	utility := ctx.Utility
+
+	base, _ := vs.GetProp(options, "base").(string)
+	prefix, _ := vs.GetProp(options, "prefix").(string)
+	suffix, _ := vs.GetProp(options, "suffix").(string)
+
+	var parts []any
+	if p := vs.GetProp(target, "parts"); p != nil {
+		if pl, ok := p.([]any); ok {
+			parts = pl
+		}
+	}
+
+	ctx.Spec = core.NewSpec(map[string]any{
+		"base":   base,
+		"prefix": prefix,
+		"parts":  parts,
+		"suffix": suffix,
+		"step":   "start",
+	})
+
+	ctx.Spec.Method = utility.PrepareMethod(ctx)
+
+	allowMethod, _ := vs.GetPath([]any{"allow", "method"}, options).(string)
+	if !strings.Contains(allowMethod, ctx.Spec.Method) {
+		return nil, ctx.MakeError("spec_method_allow",
+			"Method \""+ctx.Spec.Method+
+				"\" not allowed by SDK option allow.method value: \""+allowMethod+"\"")
+	}
+
+	ctx.Spec.Params = utility.PrepareParams(ctx)
+	ctx.Spec.Query = utility.PrepareQuery(ctx)
+	ctx.Spec.Headers = utility.PrepareHeaders(ctx)
+	ctx.Spec.Body = utility.PrepareBody(ctx)
+	ctx.Spec.Path = utility.PreparePath(ctx)
+
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain["spec"] = ctx.Spec
+	}
+
+	spec, err := utility.PrepareAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx.Spec = spec
+	return spec, nil
+}