@voxgig/sdkgen 0.26.1 → 0.28.0

package/project/.sdk/tm/go/core/result.go

@@ -0,0 +1,73 @@
+package core
+
+import (
+	vs "github.com/voxgig/struct"
+)
+
+type Result struct {
+	Ok         bool
+	Status     int
+	StatusText string
+	Headers    map[string]any
+	Body       any
+	Err        error
+	Resdata    any
+	Resmatch   map[string]any
+}
+
+func NewResult(resmap map[string]any) *Result {
+	ok := false
+	if o := vs.GetProp(resmap, "ok"); o != nil {
+		if b, is := o.(bool); is {
+			ok = b
+		}
+	}
+
+	status := -1
+	if s := vs.GetProp(resmap, "status"); s != nil {
+		status = ToInt(s)
+	}
+
+	statusText := ""
+	if st := vs.GetProp(resmap, "statusText"); st != nil {
+		if s, ok := st.(string); ok {
+			statusText = s
+		}
+	}
+
+	headers := map[string]any{}
+	if h := vs.GetProp(resmap, "headers"); h != nil {
+		if hm, ok := h.(map[string]any); ok {
+			headers = hm
+		}
+	}
+
+	body := vs.GetProp(resmap, "body")
+
+	var err error
+	if e := vs.GetProp(resmap, "err"); e != nil {
+		if er, ok := e.(error); ok {
+			err = er
+		}
+	}
+
+	resdata := vs.GetProp(resmap, "resdata")
+
+	var resmatch map[string]any
+	if rm := vs.GetProp(resmap, "resmatch"); rm != nil {
+		if rmm, ok := rm.(map[string]any); ok {
+			resmatch = rmm
+		}
+	}
+
+	return &Result{
+		Ok:         ok,
+		Status:     status,
+		StatusText: statusText,
+		Headers:    headers,
+		Body:       body,
+		Err:        err,
+		Resdata:    resdata,
+		Resmatch:   resmatch,
+	}
+}

package/project/.sdk/tm/go/core/spec.go

@@ -0,0 +1,97 @@
+package core
+
+type Spec struct {
+	Parts   []any
+	Headers map[string]any
+	Alias   map[string]any
+	Base    string
+	Prefix  string
+	Suffix  string
+	Params  map[string]any
+	Query   map[string]any
+	Step    string
+	Method  string
+	Body    any
+	Url     string
+	Path    string
+}
+
+func NewSpec(specmap map[string]any) *Spec {
+	s := &Spec{
+		Headers: map[string]any{},
+		Alias:   map[string]any{},
+		Params:  map[string]any{},
+		Query:   map[string]any{},
+		Method:  "GET",
+	}
+
+	if specmap == nil {
+		return s
+	}
+
+	if v, ok := specmap["parts"]; ok && v != nil {
+		if parts, ok := v.([]any); ok {
+			s.Parts = parts
+		}
+	}
+	if v, ok := specmap["headers"]; ok && v != nil {
+		if h, ok := v.(map[string]any); ok {
+			s.Headers = h
+		}
+	}
+	if v, ok := specmap["alias"]; ok && v != nil {
+		if a, ok := v.(map[string]any); ok {
+			s.Alias = a
+		}
+	}
+	if v, ok := specmap["base"]; ok && v != nil {
+		if b, ok := v.(string); ok {
+			s.Base = b
+		}
+	}
+	if v, ok := specmap["prefix"]; ok && v != nil {
+		if p, ok := v.(string); ok {
+			s.Prefix = p
+		}
+	}
+	if v, ok := specmap["suffix"]; ok && v != nil {
+		if sf, ok := v.(string); ok {
+			s.Suffix = sf
+		}
+	}
+	if v, ok := specmap["params"]; ok && v != nil {
+		if p, ok := v.(map[string]any); ok {
+			s.Params = p
+		}
+	}
+	if v, ok := specmap["query"]; ok && v != nil {
+		if q, ok := v.(map[string]any); ok {
+			s.Query = q
+		}
+	}
+	if v, ok := specmap["step"]; ok && v != nil {
+		if st, ok := v.(string); ok {
+			s.Step = st
+		}
+	}
+	if v, ok := specmap["method"]; ok && v != nil {
+		if m, ok := v.(string); ok {
+			s.Method = m
+		}
+	}
+	if v, ok := specmap["body"]; ok {
+		s.Body = v
+	}
+	if v, ok := specmap["url"]; ok && v != nil {
+		if u, ok := v.(string); ok {
+			s.Url = u
+		}
+	}
+	if v, ok := specmap["path"]; ok && v != nil {
+		if p, ok := v.(string); ok {
+			s.Path = p
+		}
+	}
+
+	return s
+}

package/project/.sdk/tm/go/core/target.go

@@ -0,0 +1,102 @@
+package core
+
+import (
+	vs "github.com/voxgig/struct"
+)
+
+type Target struct {
+	Args      map[string]any
+	Rename    map[string]any
+	Method    string
+	Orig      string
+	Parts     []any
+	Params    []any
+	Select    map[string]any
+	Active    bool
+	Relations []any
+	Alias     map[string]any
+	Transform map[string]any
+}
+
+func NewTarget(altmap map[string]any) *Target {
+	t := &Target{}
+
+	if args := vs.GetProp(altmap, "args"); args != nil {
+		if am, ok := args.(map[string]any); ok {
+			t.Args = am
+		}
+	}
+	if t.Args == nil {
+		t.Args = map[string]any{"params": []any{}}
+	}
+
+	if rename := vs.GetProp(altmap, "rename"); rename != nil {
+		if rm, ok := rename.(map[string]any); ok {
+			t.Rename = rm
+		}
+	}
+	if t.Rename == nil {
+		t.Rename = map[string]any{"params": map[string]any{}}
+	}
+
+	if m := vs.GetProp(altmap, "method"); m != nil {
+		t.Method, _ = m.(string)
+	}
+
+	if o := vs.GetProp(altmap, "orig"); o != nil {
+		t.Orig, _ = o.(string)
+	}
+
+	if p := vs.GetProp(altmap, "parts"); p != nil {
+		if pl, ok := p.([]any); ok {
+			t.Parts = pl
+		}
+	}
+	if t.Parts == nil {
+		t.Parts = []any{}
+	}
+
+	if p := vs.GetProp(altmap, "params"); p != nil {
+		if pl, ok := p.([]any); ok {
+			t.Params = pl
+		}
+	}
+
+	if s := vs.GetProp(altmap, "select"); s != nil {
+		if sm, ok := s.(map[string]any); ok {
+			t.Select = sm
+		}
+	}
+
+	if a := vs.GetProp(altmap, "active"); a != nil {
+		if ab, ok := a.(bool); ok {
+			t.Active = ab
+		}
+	}
+
+	if r := vs.GetProp(altmap, "relations"); r != nil {
+		if rl, ok := r.([]any); ok {
+			t.Relations = rl
+		}
+	}
+
+	if a := vs.GetProp(altmap, "alias"); a != nil {
+		if am, ok := a.(map[string]any); ok {
+			t.Alias = am
+		}
+	}
+	if t.Alias == nil {
+		t.Alias = map[string]any{}
+	}
+
+	if tf := vs.GetProp(altmap, "transform"); tf != nil {
+		if tm, ok := tf.(map[string]any); ok {
+			t.Transform = tm
+		}
+	}
+	if t.Transform == nil {
+		t.Transform = map[string]any{}
+	}
+
+	return t
+}

package/project/.sdk/tm/go/core/types.go

@@ -0,0 +1,44 @@
+package core
+
+type Feature interface {
+	GetVersion() string
+	GetName() string
+	GetActive() bool
+
+	Init(ctx *Context, options map[string]any)
+
+	PostConstruct(ctx *Context)
+	PostConstructEntity(ctx *Context)
+	SetData(ctx *Context)
+	GetData(ctx *Context)
+	GetMatch(ctx *Context)
+
+	PreTarget(ctx *Context)
+	PreSelection(ctx *Context)
+	PreSpec(ctx *Context)
+	PreRequest(ctx *Context)
+	PreResponse(ctx *Context)
+	PreResult(ctx *Context)
+	PreDone(ctx *Context)
+	PreUnexpected(ctx *Context)
+	PostOperation(ctx *Context)
+	SetMatch(ctx *Context)
+}
+
+type Entity interface {
+	GetName() string
+	Make() Entity
+	Data(data ...any) any
+	Match(match ...any) any
+}
+
+type ProjectNameEntity interface {
+	Entity
+	Load(reqmatch map[string]any, ctrl map[string]any) (any, error)
+	List(reqmatch map[string]any, ctrl map[string]any) (any, error)
+	Create(reqdata map[string]any, ctrl map[string]any) (any, error)
+	Update(reqdata map[string]any, ctrl map[string]any) (any, error)
+	Remove(reqmatch map[string]any, ctrl map[string]any) (any, error)
+}
+
+type FetcherFunc func(ctx *Context, fullurl string, fetchdef map[string]any) (any, error)

package/project/.sdk/tm/go/core/utility_type.go

@@ -0,0 +1,54 @@
+package core
+
+type Utility struct {
+	Clean             func(ctx *Context, val any) any
+	Done              func(ctx *Context) (any, error)
+	MakeError         func(ctx *Context, err error) (any, error)
+	FeatureAdd        func(ctx *Context, f Feature)
+	FeatureHook       func(ctx *Context, name string)
+	FeatureInit       func(ctx *Context, f Feature)
+	Fetcher           FetcherFunc
+	MakeFetchDef      func(ctx *Context) (map[string]any, error)
+	MakeContext       func(ctxmap map[string]any, basectx *Context) *Context
+	MakeOptions       func(ctx *Context) map[string]any
+	MakeRequest       func(ctx *Context) (*Response, error)
+	MakeResponse      func(ctx *Context) (*Response, error)
+	MakeResult        func(ctx *Context) (*Result, error)
+	MakeTarget        func(ctx *Context) (map[string]any, error)
+	MakeSpec          func(ctx *Context) (*Spec, error)
+	MakeUrl           func(ctx *Context) (string, error)
+	Param             func(ctx *Context, paramdef any) any
+	PrepareAuth       func(ctx *Context) (*Spec, error)
+	PrepareBody       func(ctx *Context) any
+	PrepareHeaders    func(ctx *Context) map[string]any
+	PrepareMethod     func(ctx *Context) string
+	PrepareParams     func(ctx *Context) map[string]any
+	PreparePath       func(ctx *Context) string
+	PrepareQuery      func(ctx *Context) map[string]any
+	ResultBasic       func(ctx *Context) *Result
+	ResultBody        func(ctx *Context) *Result
+	ResultHeaders     func(ctx *Context) *Result
+	TransformRequest  func(ctx *Context) any
+	TransformResponse func(ctx *Context) any
+	Custom            map[string]any
+}
+
+func NewUtility() *Utility {
+	u := &Utility{
+		Custom: map[string]any{},
+	}
+	if UtilityRegistrar != nil {
+		UtilityRegistrar(u)
+	}
+	return u
+}
+
+func CopyUtility(src *Utility) *Utility {
+	u := &Utility{}
+	*u = *src
+	u.Custom = map[string]any{}
+	for k, v := range src.Custom {
+		u.Custom[k] = v
+	}
+	return u
+}

package/project/.sdk/tm/go/feature/base_feature.go

@@ -0,0 +1,40 @@
+package feature
+
+import (
+	"GOMODULE/core"
+)
+
+type BaseFeature struct {
+	Version string
+	Name    string
+	Active  bool
+}
+
+func NewBaseFeature() *BaseFeature {
+	return &BaseFeature{
+		Version: "0.0.1",
+		Name:    "base",
+		Active:  true,
+	}
+}
+
+func (f *BaseFeature) GetVersion() string { return f.Version }
+func (f *BaseFeature) GetName() string    { return f.Name }
+func (f *BaseFeature) GetActive() bool    { return f.Active }
+
+func (f *BaseFeature) Init(ctx *core.Context, options map[string]any)  {}
+func (f *BaseFeature) PostConstruct(ctx *core.Context)                 {}
+func (f *BaseFeature) PostConstructEntity(ctx *core.Context)           {}
+func (f *BaseFeature) SetData(ctx *core.Context)                       {}
+func (f *BaseFeature) GetData(ctx *core.Context)                       {}
+func (f *BaseFeature) GetMatch(ctx *core.Context)                      {}
+func (f *BaseFeature) SetMatch(ctx *core.Context)                      {}
+func (f *BaseFeature) PreTarget(ctx *core.Context)                     {}
+func (f *BaseFeature) PreSelection(ctx *core.Context)                  {}
+func (f *BaseFeature) PreSpec(ctx *core.Context)                       {}
+func (f *BaseFeature) PreRequest(ctx *core.Context)                    {}
+func (f *BaseFeature) PreResponse(ctx *core.Context)                   {}
+func (f *BaseFeature) PreResult(ctx *core.Context)                     {}
+func (f *BaseFeature) PreDone(ctx *core.Context)                       {}
+func (f *BaseFeature) PreUnexpected(ctx *core.Context)                 {}
+func (f *BaseFeature) PostOperation(ctx *core.Context)                 {}

package/project/.sdk/tm/go/feature/test_feature.go

@@ -0,0 +1,196 @@
+package feature
+
+import (
+	"fmt"
+	"math/rand"
+
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+type TestFeature struct {
+	BaseFeature
+	client  *core.ProjectNameSDK
+	options map[string]any
+}
+
+func NewTestFeature() *TestFeature {
+	return &TestFeature{
+		BaseFeature: BaseFeature{
+			Version: "0.0.1",
+			Name:    "test",
+			Active:  true,
+		},
+	}
+}
+
+func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
+	f.client = ctx.Client
+	f.options = options
+
+	entity := core.ToMapAny(vs.GetProp(options, "entity"))
+
+	f.client.Mode = "test"
+
+	// Ensure entity ids are correct.
+	vs.Walk(entity, func(key *string, val any, parent any, path []string) any {
+		if len(path) == 2 {
+			if m, ok := val.(map[string]any); ok {
+				if key != nil {
+					m["id"] = *key
+				}
+			}
+		}
+		return val
+	})
+
+	self := f
+
+	testFetcher := func(ctx *core.Context, _fullurl string, _fetchdef map[string]any) (any, error) {
+		respond := func(status int, data any, extra map[string]any) map[string]any {
+			out := map[string]any{
+				"status":     status,
+				"statusText": "OK",
+				"json":       (func() any)(func() any { return data }),
+				"body":       "not-used",
+			}
+			if extra != nil {
+				for k, v := range extra {
+					out[k] = v
+				}
+			}
+			return out
+		}
+
+		op := ctx.Op
+		entmap := core.ToMapAny(vs.GetProp(entity, op.Entity))
+		if entmap == nil {
+			entmap = map[string]any{}
+		}
+
+		if op.Name == "load" {
+			args := self.buildArgs(ctx, op, ctx.Reqmatch)
+			found := vs.Select(entmap, args)
+			ent := vs.GetElem(found, 0)
+			if ent == nil {
+				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
+			}
+			vs.DelProp(ent, "$KEY")
+			out := vs.Clone(ent)
+			return respond(200, out, nil), nil
+		} else if op.Name == "list" {
+			args := self.buildArgs(ctx, op, ctx.Reqmatch)
+			found := vs.Select(entmap, args)
+			if found == nil {
+				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
+			}
+			for _, item := range found {
+				vs.DelProp(item, "$KEY")
+			}
+			out := vs.Clone(found)
+			return respond(200, out, nil), nil
+		} else if op.Name == "update" {
+			args := self.buildArgs(ctx, op, ctx.Reqdata)
+			found := vs.Select(entmap, args)
+			ent := vs.GetElem(found, 0)
+			if ent == nil {
+				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
+			}
+			if entm, ok := ent.(map[string]any); ok {
+				reqdata := ctx.Reqdata
+				if reqdata != nil {
+					for k, v := range reqdata {
+						entm[k] = v
+					}
+				}
+			}
+			vs.DelProp(ent, "$KEY")
+			out := vs.Clone(ent)
+			return respond(200, out, nil), nil
+		} else if op.Name == "remove" {
+			args := self.buildArgs(ctx, op, ctx.Reqmatch)
+			found := vs.Select(entmap, args)
+			ent := vs.GetElem(found, 0)
+			if ent == nil {
+				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
+			}
+			if entm, ok := ent.(map[string]any); ok {
+				id := vs.GetProp(entm, "id")
+				vs.DelProp(entmap, id)
+			}
+			return respond(200, nil, nil), nil
+		} else if op.Name == "create" {
+			_ = self.buildArgs(ctx, op, ctx.Reqdata)
+			id := ctx.Utility.Param(ctx, "id")
+			if id == nil {
+				id = fmt.Sprintf("%04x%04x%04x%04x",
+					rand.Intn(0x10000), rand.Intn(0x10000),
+					rand.Intn(0x10000), rand.Intn(0x10000))
+			}
+
+			ent := vs.Clone(ctx.Reqdata)
+			if entm, ok := ent.(map[string]any); ok {
+				entm["id"] = id
+				if idStr, ok := id.(string); ok {
+					entmap[idStr] = entm
+				}
+				vs.DelProp(entm, "$KEY")
+				out := vs.Clone(entm)
+				return respond(200, out, nil), nil
+			}
+			return respond(200, ent, nil), nil
+		}
+
+		return respond(404, nil, map[string]any{"statusText": "Unknown operation"}), nil
+	}
+
+	ctx.Utility.Fetcher = testFetcher
+}
+
+func (f *TestFeature) buildArgs(ctx *core.Context, op *core.Operation, args map[string]any) any {
+	opname := op.Name
+
+	// Get last target from config.
+	targets := vs.GetPath([]any{"entity", ctx.Entity.GetName(), "op", opname, "targets"}, ctx.Config)
+	target := vs.GetElem(targets, -1)
+
+	// Get required params.
+	paramsPath := vs.GetPath([]any{"args", "params"}, target)
+	reqdParams := vs.Select(paramsPath, map[string]any{"reqd": true})
+	reqd := vs.Transform(reqdParams, []any{"`$EACH`", "", "`$KEY.name`"})
+
+	qand := []any{}
+	q := map[string]any{"`$AND`": &qand}
+
+	if args != nil {
+		for _, key := range vs.KeysOf(args) {
+			isId := key == "id"
+			selected := vs.Select(reqd, key)
+			isReqd := !vs.IsEmpty(selected)
+
+			if isId || isReqd {
+				v := ctx.Utility.Param(ctx, key)
+				ka := vs.GetProp(op.Alias, key)
+
+				qor := []any{map[string]any{key: v}}
+				if ka != nil {
+					if kas, ok := ka.(string); ok {
+						qor = append(qor, map[string]any{kas: v})
+					}
+				}
+
+				qand = append(qand, map[string]any{"`$OR`": qor})
+			}
+		}
+	}
+
+	// Update the slice behind the pointer.
+	q["`$AND`"] = qand
+
+	if ctx.Ctrl.Explain != nil {
+		ctx.Ctrl.Explain["test"] = map[string]any{"query": q}
+	}
+
+	return q
+}

package/project/.sdk/tm/go/src/feature/README.md

@@ -0,0 +1 @@
+# Go Features

package/project/.sdk/tm/go/test/custom_utility_test.go

@@ -0,0 +1,80 @@
+package sdktest
+
+import (
+	"testing"
+
+	sdk "GOMODULE"
+)
+
+func TestCustomUtility(t *testing.T) {
+	t.Run("basic", func(t *testing.T) {
+		client := sdk.TestSDK(nil, map[string]any{
+			"apikey": "APIKEY01",
+			"utility": map[string]any{
+				"auth":       func() map[string]any { return map[string]any{"util": "AUTH"} },
+				"body":       func() map[string]any { return map[string]any{"util": "BODY"} },
+				"contextify": func() map[string]any { return map[string]any{"util": "CONTEXTIFY"} },
+				"done":       func() map[string]any { return map[string]any{"util": "DONE"} },
+				"error":      func() map[string]any { return map[string]any{"util": "ERROR"} },
+				"findparam":  func() map[string]any { return map[string]any{"util": "FINDPARAM"} },
+				"fullurl":    func() map[string]any { return map[string]any{"util": "FULLURL"} },
+				"headers":    func() map[string]any { return map[string]any{"util": "HEADERS"} },
+				"method":     func() map[string]any { return map[string]any{"util": "METHOD"} },
+				"operator":   func() map[string]any { return map[string]any{"util": "OPERATOR"} },
+				"params":     func() map[string]any { return map[string]any{"util": "PARAMS"} },
+				"query":      func() map[string]any { return map[string]any{"util": "QUERY"} },
+				"reqform":    func() map[string]any { return map[string]any{"util": "REQFORM"} },
+				"request":    func() map[string]any { return map[string]any{"util": "REQUEST"} },
+				"resbasic":   func() map[string]any { return map[string]any{"util": "RESBASIC"} },
+				"resbody":    func() map[string]any { return map[string]any{"util": "RESBODY"} },
+				"resform":    func() map[string]any { return map[string]any{"util": "RESFORM"} },
+				"resheaders": func() map[string]any { return map[string]any{"util": "RESHEADERS"} },
+				"response":   func() map[string]any { return map[string]any{"util": "RESPONSE"} },
+				"result":     func() map[string]any { return map[string]any{"util": "RESULT"} },
+				"spec":       func() map[string]any { return map[string]any{"util": "SPEC"} },
+			},
+		})
+
+		u := client.GetUtility()
+
+		checks := map[string]string{
+			"auth":       "AUTH",
+			"body":       "BODY",
+			"contextify": "CONTEXTIFY",
+			"done":       "DONE",
+			"error":      "ERROR",
+			"findparam":  "FINDPARAM",
+			"fullurl":    "FULLURL",
+			"headers":    "HEADERS",
+			"method":     "METHOD",
+			"operator":   "OPERATOR",
+			"params":     "PARAMS",
+			"query":      "QUERY",
+			"reqform":    "REQFORM",
+			"request":    "REQUEST",
+			"resbasic":   "RESBASIC",
+			"resbody":    "RESBODY",
+			"resform":    "RESFORM",
+			"resheaders": "RESHEADERS",
+			"response":   "RESPONSE",
+			"result":     "RESULT",
+			"spec":       "SPEC",
+		}
+
+		for key, expected := range checks {
+			fn, ok := u.Custom[key]
+			if !ok {
+				t.Errorf("expected custom utility %q to exist", key)
+				continue
+			}
+			if f, ok := fn.(func() map[string]any); ok {
+				result := f()
+				if result["util"] != expected {
+					t.Errorf("custom utility %q: got %v, want %v", key, result["util"], expected)
+				}
+			} else {
+				t.Errorf("custom utility %q: expected func() map[string]any, got %T", key, fn)
+			}
+		}
+	})
+}