@voxgig/sdkgen 0.25.0 → 0.28.0

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

@@ -1,81 +1,200 @@
 
-import type { Feature } from './types'
+import { inspect } from 'node:util'
 
-import { Config } from './Config'
+import type { Context, Feature } from './types'
+
+import { config } from './Config'
 import { Utility } from './utility/Utility'
 
 
 import { BaseFeature } from './feature/base/BaseFeature'
 
-const utility = new Utility()
 
+const stdutil = new Utility()
 
-class ProjectNameSDK {
-  #options: any
-  #utility = utility
 
+class ProjectNameSDK {
+  _mode: string = 'live'
+  _options: any
+  _utility = new Utility()
   _features: Feature[]
-
+  _rootctx: Context
 
   constructor(options?: any) {
 
-    const ctx = this.#utility.contextify({
+    this._rootctx = this._utility.makeContext({
       client: this,
-      utility: this.#utility,
-      config: Config,
+      utility: this._utility,
+      config,
       options,
+      shared: new WeakMap()
     })
 
-    this.#options = this.#utility.options(ctx)
+    this._options = this._utility.makeOptions(this._rootctx)
+
+    const struct = this._utility.struct
+    const getpath = struct.getpath
+    const items = struct.items
+
+    if (true === getpath(this._options.feature, 'test.active')) {
+      this._mode = 'test'
+    }
 
-    ctx.options = this.#options
+    this._rootctx.options = this._options
 
     this._features = []
 
-    const addfeature = this.#utility.addfeature
-    const initfeature = this.#utility.initfeature
+    const featureAdd = this._utility.featureAdd
+    const featureInit = this._utility.featureInit
 
-    // #BuildFeatures
+    items(this._options.feature, (fitem: [string, any]) => {
+      const fname = fitem[0]
+      const fopts = fitem[1]
+      if (fopts.active) {
+        featureAdd(this._rootctx, this._rootctx.config.makeFeature(fname))
+      }
+    })
 
-    if (null != this.#options.extend) {
-      for (let f of this.#options.extend) {
-        addfeature(ctx, f)
+    if (null != this._options.extend) {
+      for (let f of this._options.extend) {
+        featureAdd(this._rootctx, f)
       }
     }
 
     for (let f of this._features) {
-      initfeature(ctx, f)
+      featureInit(this._rootctx, f)
     }
 
-    const featurehook = this.#utility.featurehook
-    featurehook(ctx, 'PostConstruct')
+    const featureHook = this._utility.featureHook
+    featureHook(this._rootctx, 'PostConstruct')
   }
 
 
   options() {
-    return { ...this.#options }
+    return this._utility.struct.clone(this._options)
   }
 
 
   utility() {
-    return { ...this.#utility }
+    return this._utility.struct.clone(this._utility)
+  }
+
+
+  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]>
 
 
-  static test(testopts?: any, sdkopts?: any) {
-    const active = null == testopts ? false : null == testopts.active ? true : !!testopts.active
-    testopts = testopts || {}
-    testopts.active = active
+  static test(testoptsarg?: any, sdkoptsarg?: any) {
+    const struct = stdutil.struct
+    const setpath = struct.setpath
+    const getdef = struct.getdef
+    const clone = struct.clone
+    const setprop = struct.setprop
+
+    const sdkopts = getdef(clone(sdkoptsarg), {})
+    const testopts = getdef(clone(testoptsarg), {})
+    setprop(testopts, 'active', true)
+    setpath(sdkopts, 'feature.test', testopts)
 
-    sdkopts = sdkopts || {}
-    sdkopts.feature = sdkopts.feature || {}
-    sdkopts.feature.test = testopts || {}
-    sdkopts.feature.test.active = true
+    const testsdk = new ProjectNameSDK(sdkopts)
+    testsdk._mode = 'test'
 
-    return new ProjectNameSDK(sdkopts)
+    return testsdk
   }
 
 
@@ -83,6 +202,19 @@ class ProjectNameSDK {
     return ProjectNameSDK.test(testopts, sdkopts)
   }
 
+
+  toJSON() {
+    return { name: 'ProjectName' }
+  }
+
+  toString() {
+    return 'ProjectName ' + this._utility.struct.jsonify(this.toJSON())
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
 }
 
 
@@ -91,11 +223,11 @@ class ProjectNameEntity {
 }
 
 
-
 const SDK = ProjectNameSDK
 
+
 export {
-  utility,
+  stdutil,
 
   BaseFeature,
   ProjectNameEntity,

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/src/cmp/ts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2022",
+    "declaration": true,
+    "declarationDir": "../dist"
+  }
+}

package/project/.sdk/src/cmp/ts/utility_ts.ts

@@ -1,10 +1,64 @@
 
+import * as Path from 'node:path'
+
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+function projectPath(suffix?: string): string {
+  return Path.normalize(Path.join(__dirname, '../../..', suffix ?? ''))
+}
+
+
 function formatJSONSrc(jsonsrc: string) {
   return jsonsrc
     .replace(/([{:\[,])/g, '$1 ')
     .replace(/([}\]])/g, ' $1')
 }
 
+
+function formatJson(obj: any, flags?: { line?: boolean, margin?: number }): string {
+  const marginSize = flags?.margin ?? 0
+  const marginStr = ' '.repeat(marginSize)
+
+  let json: string
+
+  if (flags?.line) {
+    // One line with spaces for clarity
+    json = JSON.stringify(obj)
+      .replace(/([{:\[,])/g, '$1 ')
+      .replace(/([}\]])/g, ' $1')
+  }
+  else {
+    // Pretty printed with 2-space indentation
+    json = JSON.stringify(obj, null, 2)
+  }
+
+  // Add margin to the left of every line
+  if (marginSize > 0) {
+    json = json.split('\n').map(line => marginStr + line).join('\n')
+  }
+
+  return json
+}
+
+
+function clean(o: any) {
+  return walk(clone(o), (k: any, v: any, p: any) => {
+    if (null != k && k.endsWith('$')) {
+      delete p[k]
+    }
+    return v
+  })
+}
+
+
 export {
-  formatJSONSrc
+  clean,
+  formatJSONSrc,
+  formatJson,
+  projectPath,
 }

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