@voxgig/sdkgen 0.26.1 → 0.30.0

package/project/.sdk/src/cmp/ts/fragment/EntityUpdateOp.fragment.ts

@@ -19,11 +19,11 @@ class EntityOperation {
       done,
       error,
       featureHook,
-      selection,
-      request,
-      response,
-      result,
-      spec,
+      makeTarget,
+      makeRequest,
+      makeResponse,
+      makeResult,
+      makeSpec,
     } = utility
 
     let fres: Promise<any> | undefined = undefined
@@ -40,15 +40,15 @@ class EntityOperation {
 
       // #PreSelection-Hook    
 
-      ctx.out.selected = selection(ctx)
-      if (ctx.out.selected instanceof Error) {
-        return error(ctx, ctx.out.selected)
+      ctx.out.target = makeTarget(ctx)
+      if (ctx.out.target instanceof Error) {
+        return error(ctx, ctx.out.target)
       }
 
 
       // #PreSpec-Hook
 
-      ctx.out.spec = spec(ctx)
+      ctx.out.spec = makeSpec(ctx)
       if (ctx.out.spec instanceof Error) {
         return error(ctx, ctx.out.spec)
       }
@@ -56,7 +56,7 @@ class EntityOperation {
 
       // #PreRequest-Hook
 
-      ctx.out.request = await request(ctx)
+      ctx.out.request = await makeRequest(ctx)
       if (ctx.out.request instanceof Error) {
         return error(ctx, ctx.out.request)
       }
@@ -64,7 +64,7 @@ class EntityOperation {
 
       // #PreResponse-Hook
 
-      ctx.out.response = await response(ctx)
+      ctx.out.response = await makeResponse(ctx)
       if (ctx.out.response instanceof Error) {
         return error(ctx, ctx.out.response)
       }
@@ -72,7 +72,7 @@ class EntityOperation {
 
       // #PreResult-Hook
 
-      ctx.out.result = await result(ctx)
+      ctx.out.result = await makeResult(ctx)
       if (ctx.out.result instanceof Error) {
         return error(ctx, ctx.out.result)
       }

package/project/.sdk/src/cmp/ts/fragment/Main.fragment.ts

@@ -30,7 +30,7 @@ class ProjectNameSDK {
       shared: new WeakMap()
     })
 
-    this._options = this._utility.options(this._rootctx)
+    this._options = this._utility.makeOptions(this._rootctx)
 
     const struct = this._utility.struct
     const getpath = struct.getpath
@@ -44,25 +44,25 @@ class ProjectNameSDK {
 
     this._features = []
 
-    const addfeature = this._utility.addfeature
-    const initfeature = this._utility.initfeature
+    const featureAdd = this._utility.featureAdd
+    const featureInit = this._utility.featureInit
 
     items(this._options.feature, (fitem: [string, any]) => {
       const fname = fitem[0]
       const fopts = fitem[1]
       if (fopts.active) {
-        addfeature(this._rootctx, this._rootctx.config.makeFeature(fname))
+        featureAdd(this._rootctx, this._rootctx.config.makeFeature(fname))
       }
     })
 
     if (null != this._options.extend) {
       for (let f of this._options.extend) {
-        addfeature(this._rootctx, f)
+        featureAdd(this._rootctx, f)
       }
     }
 
     for (let f of this._features) {
-      initfeature(this._rootctx, f)
+      featureInit(this._rootctx, f)
     }
 
     const featureHook = this._utility.featureHook
@@ -80,6 +80,102 @@ class ProjectNameSDK {
   }
 
 
+  async prepare(fetchargs?: any) {
+    const utility = this._utility
+    const struct = utility.struct
+    const clone = struct.clone
+
+    const {
+      makeContext,
+      makeFetchDef,
+      prepareHeaders,
+      prepareAuth,
+    } = utility
+
+    fetchargs = fetchargs || {}
+
+    let ctx: Context = makeContext({
+      opname: 'prepare',
+      ctrl: fetchargs.ctrl || {},
+    }, this._rootctx)
+
+    const options = this._options
+
+    // Build spec directly from SDK options + user-provided fetch args.
+    const spec: any = {
+      base: options.base,
+      prefix: options.prefix,
+      suffix: options.suffix,
+      path: fetchargs.path || '',
+      method: fetchargs.method || 'GET',
+      params: fetchargs.params || {},
+      query: fetchargs.query || {},
+      headers: prepareHeaders(ctx),
+      body: fetchargs.body,
+      step: 'start',
+    }
+
+    ctx.spec = spec
+
+    // Merge user-provided headers over SDK defaults.
+    if (fetchargs.headers) {
+      const uheaders = fetchargs.headers
+      for (let key in uheaders) {
+        spec.headers[key] = uheaders[key]
+      }
+    }
+
+    // Apply SDK auth (apikey, auth prefix, etc.)
+    const authResult = prepareAuth(ctx)
+    if (authResult instanceof Error) {
+      return authResult
+    }
+
+    return makeFetchDef(ctx)
+  }
+
+
+  async direct(fetchargs?: any) {
+    const utility = this._utility
+    const fetcher = utility.fetcher
+    const makeContext = utility.makeContext
+
+    const fetchdef = await this.prepare(fetchargs)
+    if (fetchdef instanceof Error) {
+      return fetchdef
+    }
+
+    let ctx: Context = makeContext({
+      opname: 'direct',
+      ctrl: (fetchargs || {}).ctrl || {},
+    }, this._rootctx)
+
+    try {
+      const fetched = await fetcher(ctx, fetchdef.url, fetchdef)
+
+      if (null == fetched) {
+        return { ok: false, err: ctx.error('direct_no_response', 'response: undefined') }
+      }
+      else if (fetched instanceof Error) {
+        return { ok: false, err: fetched }
+      }
+
+      const status = fetched.status
+      const json = 'function' === typeof fetched.json ? await fetched.json() : fetched.json
+
+      return {
+        ok: status >= 200 && status < 300,
+        status,
+        headers: fetched.headers,
+        data: json,
+      }
+    }
+    catch (err: any) {
+      return { ok: false, err }
+    }
+  }
+
+
   // <[SLOT]>
 
 

package/project/.sdk/src/cmp/ts/fragment/SdkError.fragment.ts

@@ -0,0 +1,25 @@
+
+import { Context } from './Context'
+
+
+class ProjectNameError extends Error {
+
+  isProjectNameError = true
+
+  sdk = 'ProjectName'
+
+  code: string
+  ctx: Context
+
+  constructor(code: string, msg: string, ctx: Context) {
+    super(msg)
+    this.code = code
+    this.ctx = ctx
+  }
+
+}
+
+export {
+  ProjectNameError
+}
+

package/project/.sdk/tm/go/Makefile

@@ -0,0 +1,10 @@
+.PHONY: test build clean
+
+test:
+	go test ./... -v
+
+build:
+	go build ./...
+
+clean:
+	go clean ./...

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

@@ -0,0 +1,267 @@
+package core
+
+import (
+	"math/rand"
+	"strconv"
+
+	vs "github.com/voxgig/struct"
+)
+
+type Context struct {
+	Id       string
+	Out      map[string]any
+	Ctrl     *Control
+	Meta     map[string]any
+	Client   *ProjectNameSDK
+	Utility  *Utility
+	Op       *Operation
+	Target   map[string]any
+	Config   map[string]any
+	Entopts  map[string]any
+	Options  map[string]any
+	Opmap    map[string]*Operation
+	Response *Response
+	Result   *Result
+	Spec     *Spec
+	Data     map[string]any
+	Reqdata  map[string]any
+	Match    map[string]any
+	Reqmatch map[string]any
+	Entity   Entity
+	Shared   map[string]any
+}
+
+func NewContext(ctxmap map[string]any, basectx *Context) *Context {
+	ctx := &Context{
+		Id:  "C" + strconv.Itoa(rand.Intn(90000000)+10000000),
+		Out: map[string]any{},
+	}
+
+	// Client
+	if c := getCtxProp(ctxmap, "client"); c != nil {
+		if sdk, ok := c.(*ProjectNameSDK); ok {
+			ctx.Client = sdk
+		}
+	}
+	if ctx.Client == nil && basectx != nil {
+		ctx.Client = basectx.Client
+	}
+
+	// Utility
+	if u := getCtxProp(ctxmap, "utility"); u != nil {
+		if util, ok := u.(*Utility); ok {
+			ctx.Utility = util
+		}
+	}
+	if ctx.Utility == nil && basectx != nil {
+		ctx.Utility = basectx.Utility
+	}
+
+	// Ctrl
+	ctx.Ctrl = &Control{}
+	if c := getCtxProp(ctxmap, "ctrl"); c != nil {
+		if cm, ok := c.(map[string]any); ok {
+			if t, ok := cm["throw"]; ok {
+				if b, ok := t.(bool); ok {
+					ctx.Ctrl.Throw = &b
+				}
+			}
+			if e, ok := cm["explain"]; ok {
+				if em, ok := e.(map[string]any); ok {
+					ctx.Ctrl.Explain = em
+				}
+			}
+		} else if ctrl, ok := c.(*Control); ok {
+			ctx.Ctrl = ctrl
+		}
+	} else if basectx != nil && basectx.Ctrl != nil {
+		ctx.Ctrl = basectx.Ctrl
+	}
+
+	// Meta
+	ctx.Meta = map[string]any{}
+	if m := getCtxProp(ctxmap, "meta"); m != nil {
+		if mm, ok := m.(map[string]any); ok {
+			ctx.Meta = mm
+		}
+	} else if basectx != nil && basectx.Meta != nil {
+		ctx.Meta = basectx.Meta
+	}
+
+	// Config
+	if c := getCtxProp(ctxmap, "config"); c != nil {
+		if cm, ok := c.(map[string]any); ok {
+			ctx.Config = cm
+		}
+	}
+	if ctx.Config == nil && basectx != nil {
+		ctx.Config = basectx.Config
+	}
+
+	// Entopts
+	if e := getCtxProp(ctxmap, "entopts"); e != nil {
+		if em, ok := e.(map[string]any); ok {
+			ctx.Entopts = em
+		}
+	}
+	if ctx.Entopts == nil && basectx != nil {
+		ctx.Entopts = basectx.Entopts
+	}
+
+	// Options
+	if o := getCtxProp(ctxmap, "options"); o != nil {
+		if om, ok := o.(map[string]any); ok {
+			ctx.Options = om
+		}
+	}
+	if ctx.Options == nil && basectx != nil {
+		ctx.Options = basectx.Options
+	}
+
+	// Entity
+	if e := getCtxProp(ctxmap, "entity"); e != nil {
+		if ent, ok := e.(Entity); ok {
+			ctx.Entity = ent
+		}
+	}
+	if ctx.Entity == nil && basectx != nil {
+		ctx.Entity = basectx.Entity
+	}
+
+	// Shared
+	if s := getCtxProp(ctxmap, "shared"); s != nil {
+		if sm, ok := s.(map[string]any); ok {
+			ctx.Shared = sm
+		}
+	}
+	if ctx.Shared == nil && basectx != nil {
+		ctx.Shared = basectx.Shared
+	}
+
+	// Opmap
+	if o := getCtxProp(ctxmap, "opmap"); o != nil {
+		if om, ok := o.(map[string]*Operation); ok {
+			ctx.Opmap = om
+		}
+	}
+	if ctx.Opmap == nil && basectx != nil {
+		ctx.Opmap = basectx.Opmap
+	}
+	if ctx.Opmap == nil {
+		ctx.Opmap = map[string]*Operation{}
+	}
+
+	// Data
+	ctx.Data = ToMapAny(getCtxProp(ctxmap, "data"))
+	if ctx.Data == nil {
+		ctx.Data = map[string]any{}
+	}
+	ctx.Reqdata = ToMapAny(getCtxProp(ctxmap, "reqdata"))
+	if ctx.Reqdata == nil {
+		ctx.Reqdata = map[string]any{}
+	}
+	ctx.Match = ToMapAny(getCtxProp(ctxmap, "match"))
+	if ctx.Match == nil {
+		ctx.Match = map[string]any{}
+	}
+	ctx.Reqmatch = ToMapAny(getCtxProp(ctxmap, "reqmatch"))
+	if ctx.Reqmatch == nil {
+		ctx.Reqmatch = map[string]any{}
+	}
+
+	// Target
+	if t := getCtxProp(ctxmap, "target"); t != nil {
+		if tm, ok := t.(map[string]any); ok {
+			ctx.Target = tm
+		}
+	}
+	if ctx.Target == nil && basectx != nil {
+		ctx.Target = basectx.Target
+	}
+
+	// Spec
+	if s := getCtxProp(ctxmap, "spec"); s != nil {
+		if sp, ok := s.(*Spec); ok {
+			ctx.Spec = sp
+		}
+	}
+	if ctx.Spec == nil && basectx != nil {
+		ctx.Spec = basectx.Spec
+	}
+
+	// Result
+	if r := getCtxProp(ctxmap, "result"); r != nil {
+		if res, ok := r.(*Result); ok {
+			ctx.Result = res
+		}
+	}
+	if ctx.Result == nil && basectx != nil {
+		ctx.Result = basectx.Result
+	}
+
+	// Response
+	if r := getCtxProp(ctxmap, "response"); r != nil {
+		if resp, ok := r.(*Response); ok {
+			ctx.Response = resp
+		}
+	}
+	if ctx.Response == nil && basectx != nil {
+		ctx.Response = basectx.Response
+	}
+
+	// Resolve operation
+	opname, _ := getCtxProp(ctxmap, "opname").(string)
+	ctx.Op = ctx.resolveOp(opname)
+
+	return ctx
+}
+
+func (ctx *Context) resolveOp(opname string) *Operation {
+	if op, ok := ctx.Opmap[opname]; ok && op != nil {
+		return op
+	}
+
+	if opname == "" {
+		return NewOperation(map[string]any{})
+	}
+
+	entname := ""
+	if ctx.Entity != nil {
+		entname = ctx.Entity.GetName()
+	}
+
+	opcfg := vs.GetPath([]any{"entity", entname, "op", opname}, ctx.Config)
+
+	input := "match"
+	if opname == "update" || opname == "create" {
+		input = "data"
+	}
+
+	var targets []any
+	if opcfg != nil {
+		if ocm, ok := opcfg.(map[string]any); ok {
+			if t := vs.GetProp(ocm, "targets"); t != nil {
+				if tl, ok := t.([]any); ok {
+					targets = tl
+				}
+			}
+		}
+	}
+	if targets == nil {
+		targets = []any{}
+	}
+
+	op := NewOperation(map[string]any{
+		"entity":  entname,
+		"name":    opname,
+		"input":   input,
+		"targets": targets,
+	})
+
+	ctx.Opmap[opname] = op
+	return op
+}
+
+func (ctx *Context) MakeError(code string, msg string) *ProjectNameError {
+	return NewProjectNameError(code, msg, ctx)
+}

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

@@ -0,0 +1,7 @@
+package core
+
+type Control struct {
+	Throw   *bool
+	Err     error
+	Explain map[string]any
+}

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

@@ -0,0 +1,25 @@
+package core
+
+type ProjectNameError struct {
+	IsProjectNameError bool
+	Sdk              string
+	Code             string
+	Msg              string
+	Ctx              *Context
+	Result           any
+	Spec             any
+}
+
+func NewProjectNameError(code string, msg string, ctx *Context) *ProjectNameError {
+	return &ProjectNameError{
+		IsProjectNameError: true,
+		Sdk:              "ProjectName",
+		Code:             code,
+		Msg:              msg,
+		Ctx:              ctx,
+	}
+}
+
+func (e *ProjectNameError) Error() string {
+	return e.Msg
+}

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,
+	}
+}