@voxgig/sdkgen 0.25.0 → 0.28.0

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

@@ -0,0 +1,33 @@
+package core
+
+func ToMapAny(v any) map[string]any {
+	if v == nil {
+		return nil
+	}
+	if m, ok := v.(map[string]any); ok {
+		return m
+	}
+	return nil
+}
+
+func ToInt(v any) int {
+	switch n := v.(type) {
+	case int:
+		return n
+	case float64:
+		return int(n)
+	case float32:
+		return int(n)
+	case int64:
+		return int(n)
+	default:
+		return -1
+	}
+}
+
+func getCtxProp(m map[string]any, key string) any {
+	if m == nil {
+		return nil
+	}
+	return m[key]
+}

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

@@ -0,0 +1,61 @@
+package core
+
+import (
+	vs "github.com/voxgig/struct"
+)
+
+type Operation struct {
+	Entity  string
+	Name    string
+	Input   string
+	Targets []map[string]any
+	Alias   map[string]any
+}
+
+func NewOperation(opmap map[string]any) *Operation {
+	entity, _ := vs.GetProp(opmap, "entity").(string)
+	if entity == "" {
+		entity = "_"
+	}
+	name, _ := vs.GetProp(opmap, "name").(string)
+	if name == "" {
+		name = "_"
+	}
+	input, _ := vs.GetProp(opmap, "input").(string)
+	if input == "" {
+		input = "_"
+	}
+
+	var targets []map[string]any
+	rawTargets := vs.GetProp(opmap, "targets")
+	if rawTargets != nil {
+		if tlist, ok := rawTargets.([]any); ok {
+			for _, t := range tlist {
+				if tm, ok := t.(map[string]any); ok {
+					targets = append(targets, tm)
+				}
+			}
+		} else if tlist, ok := rawTargets.([]map[string]any); ok {
+			targets = tlist
+		}
+	}
+	if targets == nil {
+		targets = []map[string]any{}
+	}
+
+	var alias map[string]any
+	rawAlias := vs.GetProp(opmap, "alias")
+	if rawAlias != nil {
+		if am, ok := rawAlias.(map[string]any); ok {
+			alias = am
+		}
+	}
+
+	return &Operation{
+		Entity:  entity,
+		Name:    name,
+		Input:   input,
+		Targets: targets,
+		Alias:   alias,
+	}
+}

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

@@ -0,0 +1,55 @@
+package core
+
+import (
+	vs "github.com/voxgig/struct"
+)
+
+type Response struct {
+	Status     int
+	StatusText string
+	Headers    any
+	JsonFunc   func() any
+	Body       any
+	Err        error
+}
+
+func NewResponse(resmap map[string]any) *Response {
+	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 := vs.GetProp(resmap, "headers")
+
+	var jsonFunc func() any
+	if jf := vs.GetProp(resmap, "json"); jf != nil {
+		if f, ok := jf.(func() any); ok {
+			jsonFunc = f
+		}
+	}
+
+	body := vs.GetProp(resmap, "body")
+
+	var err error
+	if e := vs.GetProp(resmap, "err"); e != nil {
+		if er, ok := e.(error); ok {
+			err = er
+		}
+	}
+
+	return &Response{
+		Status:     status,
+		StatusText: statusText,
+		Headers:    headers,
+		JsonFunc:   jsonFunc,
+		Body:       body,
+		Err:        err,
+	}
+}

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)                 {}