@voxgig/sdkgen 0.25.0 → 0.28.0

package/project/.sdk/src/cmp/go/Test_go.ts

@@ -0,0 +1,37 @@
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import { cmp, each, Folder } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_go'
+import { TestDirect } from './TestDirect_go'
+
+
+const Test = cmp(function Test(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target } = props
+
+  // Module name: concatenated lowercase
+  const orgPrefix = (model.origin || '').replace(/-sdk$/, '').replace(/[^a-z0-9]/gi, '')
+  const gomodule = orgPrefix + model.name + 'sdk'
+
+  Folder({ name: 'test' }, () => {
+    each(model.main[KIT].entity, (entity: ModelEntity) => {
+      TestEntity({ target, entity, gomodule })
+      TestDirect({ target, entity, gomodule })
+    })
+  })
+})
+
+
+export {
+  Test
+}

package/project/.sdk/src/cmp/go/fragment/Entity.fragment.go

@@ -0,0 +1,146 @@
+package entity
+
+import (
+	"GOMODULE/core"
+
+	vs "github.com/voxgig/struct"
+)
+
+type EntityNameEntity struct {
+	name    string
+	client  *core.ProjectNameSDK
+	utility *core.Utility
+	entopts map[string]any
+	data    map[string]any
+	match   map[string]any
+	entctx  *core.Context
+}
+
+func NewEntityNameEntity(client *core.ProjectNameSDK, entopts map[string]any) *EntityNameEntity {
+	if entopts == nil {
+		entopts = map[string]any{}
+	}
+	if _, ok := entopts["active"]; !ok {
+		entopts["active"] = true
+	} else if entopts["active"] == false {
+		// keep false
+	} else {
+		entopts["active"] = true
+	}
+
+	e := &EntityNameEntity{
+		name:    "entityname",
+		client:  client,
+		utility: client.GetUtility(),
+		entopts: entopts,
+		data:    map[string]any{},
+		match:   map[string]any{},
+	}
+
+	e.entctx = e.utility.MakeContext(map[string]any{
+		"entity":  e,
+		"entopts": entopts,
+	}, client.GetRootCtx())
+
+	e.utility.FeatureHook(e.entctx, "PostConstructEntity")
+
+	return e
+}
+
+func (e *EntityNameEntity) GetName() string { return e.name }
+
+func (e *EntityNameEntity) Make() core.Entity {
+	opts := map[string]any{}
+	for k, v := range e.entopts {
+		opts[k] = v
+	}
+	return NewEntityNameEntity(e.client, opts)
+}
+
+func (e *EntityNameEntity) Data(args ...any) any {
+	if len(args) > 0 && args[0] != nil {
+		e.data = core.ToMapAny(vs.Clone(args[0]))
+		if e.data == nil {
+			e.data = map[string]any{}
+		}
+		e.utility.FeatureHook(e.entctx, "SetData")
+	}
+
+	e.utility.FeatureHook(e.entctx, "GetData")
+	out := vs.Clone(e.data)
+	return out
+}
+
+func (e *EntityNameEntity) Match(args ...any) any {
+	if len(args) > 0 && args[0] != nil {
+		e.match = core.ToMapAny(vs.Clone(args[0]))
+		if e.match == nil {
+			e.match = map[string]any{}
+		}
+		e.utility.FeatureHook(e.entctx, "SetMatch")
+	}
+
+	e.utility.FeatureHook(e.entctx, "GetMatch")
+	out := vs.Clone(e.match)
+	return out
+}
+
+// #LoadOp
+
+// #ListOp
+
+// #CreateOp
+
+// #UpdateOp
+
+// #RemoveOp
+
+func (e *EntityNameEntity) runOp(ctx *core.Context, postDone func()) (any, error) {
+	utility := e.utility
+
+	// #PreSelection-Hook
+
+	target, err := utility.MakeTarget(ctx)
+	ctx.Out["target"] = target
+	if err != nil {
+		return utility.MakeError(ctx, err)
+	}
+
+	// #PreSpec-Hook
+
+	spec, err := utility.MakeSpec(ctx)
+	ctx.Out["spec"] = spec
+	if err != nil {
+		return utility.MakeError(ctx, err)
+	}
+
+	// #PreRequest-Hook
+
+	resp, err := utility.MakeRequest(ctx)
+	ctx.Out["request"] = resp
+	if err != nil {
+		return utility.MakeError(ctx, err)
+	}
+
+	// #PreResponse-Hook
+
+	resp2, err := utility.MakeResponse(ctx)
+	ctx.Out["response"] = resp2
+	if err != nil {
+		return utility.MakeError(ctx, err)
+	}
+
+	// #PreResult-Hook
+
+	result, err := utility.MakeResult(ctx)
+	ctx.Out["result"] = result
+	if err != nil {
+		return utility.MakeError(ctx, err)
+	}
+
+	// #PreDone-Hook
+
+	postDone()
+
+	return utility.Done(ctx)
+}

package/project/.sdk/src/cmp/go/fragment/EntityCreateOp.fragment.go

@@ -0,0 +1,35 @@
+package entity
+
+import (
+	"GOMODULE/core"
+
+	vs "github.com/voxgig/struct"
+)
+
+type entityCreateOp struct{}
+
+// EJECT-START
+
+func (e *EntityNameEntity) Create(reqdata map[string]any, ctrl map[string]any) (any, error) {
+	utility := e.utility
+	ctx := utility.MakeContext(map[string]any{
+		"opname":  "create",
+		"ctrl":    ctrl,
+		"match":   e.match,
+		"data":    e.data,
+		"reqdata": reqdata,
+	}, e.entctx)
+
+	return e.runOp(ctx, func() {
+		if ctx.Result != nil {
+			if ctx.Result.Resdata != nil {
+				e.data = core.ToMapAny(vs.Clone(ctx.Result.Resdata))
+				if e.data == nil {
+					e.data = map[string]any{}
+				}
+			}
+		}
+	})
+}
+
+// EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityListOp.fragment.go

@@ -0,0 +1,26 @@
+package entity
+
+type entityListOp struct{}
+
+// EJECT-START
+
+func (e *EntityNameEntity) List(reqmatch map[string]any, ctrl map[string]any) (any, error) {
+	utility := e.utility
+	ctx := utility.MakeContext(map[string]any{
+		"opname":   "list",
+		"ctrl":     ctrl,
+		"match":    e.match,
+		"data":     e.data,
+		"reqmatch": reqmatch,
+	}, e.entctx)
+
+	return e.runOp(ctx, func() {
+		if ctx.Result != nil {
+			if ctx.Result.Resmatch != nil {
+				e.match = ctx.Result.Resmatch
+			}
+		}
+	})
+}
+
+// EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityLoadOp.fragment.go

@@ -0,0 +1,38 @@
+package entity
+
+import (
+	"GOMODULE/core"
+
+	vs "github.com/voxgig/struct"
+)
+
+type entityLoadOp struct{}
+
+// EJECT-START
+
+func (e *EntityNameEntity) Load(reqmatch map[string]any, ctrl map[string]any) (any, error) {
+	utility := e.utility
+	ctx := utility.MakeContext(map[string]any{
+		"opname":   "load",
+		"ctrl":     ctrl,
+		"match":    e.match,
+		"data":     e.data,
+		"reqmatch": reqmatch,
+	}, e.entctx)
+
+	return e.runOp(ctx, func() {
+		if ctx.Result != nil {
+			if ctx.Result.Resmatch != nil {
+				e.match = ctx.Result.Resmatch
+			}
+			if ctx.Result.Resdata != nil {
+				e.data = core.ToMapAny(vs.Clone(ctx.Result.Resdata))
+				if e.data == nil {
+					e.data = map[string]any{}
+				}
+			}
+		}
+	})
+}
+
+// EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityRemoveOp.fragment.go

@@ -0,0 +1,38 @@
+package entity
+
+import (
+	"GOMODULE/core"
+
+	vs "github.com/voxgig/struct"
+)
+
+type entityRemoveOp struct{}
+
+// EJECT-START
+
+func (e *EntityNameEntity) Remove(reqmatch map[string]any, ctrl map[string]any) (any, error) {
+	utility := e.utility
+	ctx := utility.MakeContext(map[string]any{
+		"opname":   "remove",
+		"ctrl":     ctrl,
+		"match":    e.match,
+		"data":     e.data,
+		"reqmatch": reqmatch,
+	}, e.entctx)
+
+	return e.runOp(ctx, func() {
+		if ctx.Result != nil {
+			if ctx.Result.Resmatch != nil {
+				e.match = ctx.Result.Resmatch
+			}
+			if ctx.Result.Resdata != nil {
+				e.data = core.ToMapAny(vs.Clone(ctx.Result.Resdata))
+				if e.data == nil {
+					e.data = map[string]any{}
+				}
+			}
+		}
+	})
+}
+
+// EJECT-END

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

@@ -0,0 +1,38 @@
+package entity
+
+import (
+	"GOMODULE/core"
+
+	vs "github.com/voxgig/struct"
+)
+
+type entityUpdateOp struct{}
+
+// EJECT-START
+
+func (e *EntityNameEntity) Update(reqdata map[string]any, ctrl map[string]any) (any, error) {
+	utility := e.utility
+	ctx := utility.MakeContext(map[string]any{
+		"opname":  "update",
+		"ctrl":    ctrl,
+		"match":   e.match,
+		"data":    e.data,
+		"reqdata": reqdata,
+	}, e.entctx)
+
+	return e.runOp(ctx, func() {
+		if ctx.Result != nil {
+			if ctx.Result.Resmatch != nil {
+				e.match = ctx.Result.Resmatch
+			}
+			if ctx.Result.Resdata != nil {
+				e.data = core.ToMapAny(vs.Clone(ctx.Result.Resdata))
+				if e.data == nil {
+					e.data = map[string]any{}
+				}
+			}
+		}
+	})
+}
+
+// EJECT-END

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

@@ -0,0 +1,250 @@
+package core
+
+import (
+	vs "github.com/voxgig/struct"
+)
+
+type ProjectNameSDK struct {
+	Mode     string
+	options  map[string]any
+	utility  *Utility
+	Features []Feature
+	rootctx  *Context
+}
+
+func NewProjectNameSDK(options map[string]any) *ProjectNameSDK {
+	sdk := &ProjectNameSDK{
+		Mode:     "live",
+		Features: []Feature{},
+	}
+
+	sdk.utility = NewUtility()
+
+	config := MakeConfig()
+
+	sdk.rootctx = sdk.utility.MakeContext(map[string]any{
+		"client":  sdk,
+		"utility": sdk.utility,
+		"config":  config,
+		"options": options,
+		"shared":  map[string]any{},
+	}, nil)
+
+	sdk.options = sdk.utility.MakeOptions(sdk.rootctx)
+
+	if vs.GetPath([]any{"feature", "test", "active"}, sdk.options) == true {
+		sdk.Mode = "test"
+	}
+
+	sdk.rootctx.Options = sdk.options
+
+	// Add features from config.
+	featureOpts := ToMapAny(vs.GetProp(sdk.options, "feature"))
+	if featureOpts != nil {
+		for _, item := range vs.Items(featureOpts) {
+			fname, _ := item[0].(string)
+			fopts := ToMapAny(item[1])
+			if fopts != nil {
+				if active, ok := fopts["active"]; ok {
+					if ab, ok := active.(bool); ok && ab {
+						sdk.utility.FeatureAdd(sdk.rootctx, makeFeature(fname))
+					}
+				}
+			}
+		}
+	}
+
+	// Add extension features.
+	if extend := vs.GetProp(sdk.options, "extend"); extend != nil {
+		if extList, ok := extend.([]any); ok {
+			for _, f := range extList {
+				if feat, ok := f.(Feature); ok {
+					sdk.utility.FeatureAdd(sdk.rootctx, feat)
+				}
+			}
+		}
+	}
+
+	// Initialize features.
+	for _, f := range sdk.Features {
+		sdk.utility.FeatureInit(sdk.rootctx, f)
+	}
+
+	sdk.utility.FeatureHook(sdk.rootctx, "PostConstruct")
+
+	return sdk
+}
+
+func (sdk *ProjectNameSDK) OptionsMap() map[string]any {
+	out := vs.Clone(sdk.options)
+	if om, ok := out.(map[string]any); ok {
+		return om
+	}
+	return map[string]any{}
+}
+
+func (sdk *ProjectNameSDK) GetUtility() *Utility {
+	return CopyUtility(sdk.utility)
+}
+
+func (sdk *ProjectNameSDK) GetRootCtx() *Context {
+	return sdk.rootctx
+}
+
+func (sdk *ProjectNameSDK) Prepare(fetchargs map[string]any) (map[string]any, error) {
+	utility := sdk.utility
+
+	if fetchargs == nil {
+		fetchargs = map[string]any{}
+	}
+
+	var ctrl map[string]any
+	if c := vs.GetProp(fetchargs, "ctrl"); c != nil {
+		if cm, ok := c.(map[string]any); ok {
+			ctrl = cm
+		}
+	}
+	if ctrl == nil {
+		ctrl = map[string]any{}
+	}
+
+	ctx := utility.MakeContext(map[string]any{
+		"opname": "prepare",
+		"ctrl":   ctrl,
+	}, sdk.rootctx)
+
+	options := sdk.options
+
+	path, _ := vs.GetProp(fetchargs, "path").(string)
+	method, _ := vs.GetProp(fetchargs, "method").(string)
+	if method == "" {
+		method = "GET"
+	}
+
+	params := ToMapAny(vs.GetProp(fetchargs, "params"))
+	if params == nil {
+		params = map[string]any{}
+	}
+	query := ToMapAny(vs.GetProp(fetchargs, "query"))
+	if query == nil {
+		query = map[string]any{}
+	}
+
+	headers := utility.PrepareHeaders(ctx)
+
+	base, _ := vs.GetProp(options, "base").(string)
+	prefix, _ := vs.GetProp(options, "prefix").(string)
+	suffix, _ := vs.GetProp(options, "suffix").(string)
+
+	ctx.Spec = NewSpec(map[string]any{
+		"base":    base,
+		"prefix":  prefix,
+		"suffix":  suffix,
+		"path":    path,
+		"method":  method,
+		"params":  params,
+		"query":   query,
+		"headers": headers,
+		"body":    vs.GetProp(fetchargs, "body"),
+		"step":    "start",
+	})
+
+	// Merge user-provided headers.
+	if uh := vs.GetProp(fetchargs, "headers"); uh != nil {
+		if uhm, ok := uh.(map[string]any); ok {
+			for k, v := range uhm {
+				ctx.Spec.Headers[k] = v
+			}
+		}
+	}
+
+	_, err := utility.PrepareAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return utility.MakeFetchDef(ctx)
+}
+
+func (sdk *ProjectNameSDK) Direct(fetchargs map[string]any) (map[string]any, error) {
+	utility := sdk.utility
+
+	fetchdef, err := sdk.Prepare(fetchargs)
+	if err != nil {
+		return map[string]any{"ok": false, "err": err}, nil
+	}
+
+	if fetchargs == nil {
+		fetchargs = map[string]any{}
+	}
+
+	var ctrl map[string]any
+	if c := vs.GetProp(fetchargs, "ctrl"); c != nil {
+		if cm, ok := c.(map[string]any); ok {
+			ctrl = cm
+		}
+	}
+	if ctrl == nil {
+		ctrl = map[string]any{}
+	}
+
+	ctx := utility.MakeContext(map[string]any{
+		"opname": "direct",
+		"ctrl":   ctrl,
+	}, sdk.rootctx)
+
+	url, _ := fetchdef["url"].(string)
+	fetched, fetchErr := utility.Fetcher(ctx, url, fetchdef)
+
+	if fetchErr != nil {
+		return map[string]any{"ok": false, "err": fetchErr}, nil
+	}
+
+	if fetched == nil {
+		return map[string]any{
+			"ok":  false,
+			"err": ctx.MakeError("direct_no_response", "response: undefined"),
+		}, nil
+	}
+
+	if fm, ok := fetched.(map[string]any); ok {
+		status := ToInt(vs.GetProp(fm, "status"))
+		var jsonData any
+		if jf := vs.GetProp(fm, "json"); jf != nil {
+			if f, ok := jf.(func() any); ok {
+				jsonData = f()
+			}
+		}
+
+		return map[string]any{
+			"ok":      status >= 200 && status < 300,
+			"status":  status,
+			"headers": vs.GetProp(fm, "headers"),
+			"data":    jsonData,
+		}, nil
+	}
+
+	return map[string]any{"ok": false, "err": ctx.MakeError("direct_invalid", "invalid response type")}, nil
+}
+
+// <[SLOT]>
+
+func TestSDK(testopts map[string]any, sdkopts map[string]any) *ProjectNameSDK {
+	if sdkopts == nil {
+		sdkopts = map[string]any{}
+	}
+	sdkopts = vs.Clone(sdkopts).(map[string]any)
+
+	if testopts == nil {
+		testopts = map[string]any{}
+	}
+	testopts = vs.Clone(testopts).(map[string]any)
+	testopts["active"] = true
+
+	vs.SetPath(sdkopts, []any{"feature", "test"}, testopts)
+
+	sdk := NewProjectNameSDK(sdkopts)
+	sdk.Mode = "test"
+
+	return sdk
+}

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

@@ -0,0 +1,22 @@
+package ProjectNamePkg
+
+import "fmt"
+
+// ProjectNameError represents an SDK error.
+type ProjectNameError struct {
+	Code    string
+	Message string
+	SDK     string
+}
+
+func (e *ProjectNameError) Error() string {
+	return fmt.Sprintf("%s: %s: %s", e.SDK, e.Code, e.Message)
+}
+
+func NewProjectNameError(code string, msg string) *ProjectNameError {
+	return &ProjectNameError{
+		Code:    code,
+		Message: msg,
+		SDK:     "ProjectName",
+	}
+}

package/project/.sdk/src/cmp/go/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"
+  }
+}