@voxgig/sdkgen 0.26.1 → 0.30.0

package/project/.sdk/tm/go/utility/transform_request.go

@@ -0,0 +1,32 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func transformRequestUtil(ctx *core.Context) any {
+	spec := ctx.Spec
+	target := ctx.Target
+
+	if spec != nil {
+		spec.Step = "reqform"
+	}
+
+	transform := core.ToMapAny(vs.GetProp(target, "transform"))
+	if transform == nil {
+		return ctx.Reqdata
+	}
+
+	reqform := vs.GetProp(transform, "req")
+	if reqform == nil {
+		return ctx.Reqdata
+	}
+
+	reqdata := vs.Transform(map[string]any{
+		"reqdata": ctx.Reqdata,
+	}, reqform)
+
+	return reqdata
+}

package/project/.sdk/tm/go/utility/transform_response.go

@@ -0,0 +1,45 @@
+package utility
+
+import (
+	vs "github.com/voxgig/struct"
+
+	"GOMODULE/core"
+)
+
+func transformResponseUtil(ctx *core.Context) any {
+	spec := ctx.Spec
+	result := ctx.Result
+	target := ctx.Target
+
+	if spec != nil {
+		spec.Step = "resform"
+	}
+
+	if result == nil || !result.Ok {
+		return nil
+	}
+
+	transform := core.ToMapAny(vs.GetProp(target, "transform"))
+	if transform == nil {
+		return nil
+	}
+
+	resform := vs.GetProp(transform, "res")
+	if resform == nil {
+		return nil
+	}
+
+	resdata := vs.Transform(map[string]any{
+		"ok":         result.Ok,
+		"status":     result.Status,
+		"statusText": result.StatusText,
+		"headers":    result.Headers,
+		"body":       result.Body,
+		"err":        result.Err,
+		"resdata":    result.Resdata,
+		"resmatch":   result.Resmatch,
+	}, resform)
+
+	result.Resdata = resdata
+	return resdata
+}

package/project/.sdk/tm/js/src/feature/log/LogFeature.js

@@ -69,8 +69,8 @@ class LogFeature {
   }
 
 
-  PreOperation(ctx) {
-    this.#loghook('PreOperation', ctx)
+  PreTarget(ctx) {
+    this.#loghook('PreTarget', ctx)
   }
 
   PreSpec(ctx) {

package/project/.sdk/tm/ts/src/Context.ts

@@ -0,0 +1,144 @@
+
+import { inspect } from 'node:util'
+
+import { ProjectNameSDK } from './ProjectNameSDK'
+import { ProjectNameError } from './ProjectNameError'
+
+import { Utility } from './utility/Utility'
+import { getprop, setprop, getpath } from './utility/StructUtility'
+
+import { Operation } from './Operation'
+import { Response } from './Response'
+import { Result } from './Result'
+import { Spec } from './Spec'
+
+
+// TODO: move to own file
+class Context {
+
+  id = 'C' + ('' + Math.random()).substring(2, 10)
+
+  // Store the output of each operation step.
+  out: Record<string, any> = {}
+
+  // Store for the current operation.
+  current: WeakMap<String, any> = new WeakMap()
+
+
+  ctrl: Record<string, any> = {}
+  meta: Record<string, any> = {}
+
+  client: ProjectNameSDK
+  utility: Utility
+
+  op: Operation
+  target: any
+
+  config: Record<string, any>
+  entopts: Record<string, any>
+  options: Record<string, any>
+
+  opmap: Record<string, Operation>
+
+  response?: Response
+  result?: Result
+  spec?: Spec
+
+  data?: any
+  reqdata?: any
+  match?: any
+  reqmatch?: any
+
+  entity?: any
+
+  // Shared persistent store.
+  shared: WeakMap<String, any>
+
+
+  constructor(ctxmap: Record<string, any>, basectx?: Context) {
+    this.client = getprop(ctxmap, 'client', getprop(basectx, 'client'))
+    this.utility = getprop(ctxmap, 'utility', getprop(basectx, 'utility'))
+
+    this.ctrl = getprop(ctxmap, 'ctrl', getprop(basectx, 'ctrl', this.ctrl))
+    this.meta = getprop(ctxmap, 'meta', getprop(basectx, 'meta', this.meta))
+
+    this.config = getprop(ctxmap, 'config', getprop(basectx, 'config'))
+    this.entopts = getprop(ctxmap, 'entopts', getprop(basectx, 'entopts'))
+    this.options = getprop(ctxmap, 'options', getprop(basectx, 'options'))
+
+    this.entity = getprop(ctxmap, 'entity', getprop(basectx, 'entity'))
+    this.shared = getprop(ctxmap, 'shared', getprop(basectx, 'shared'))
+    this.opmap = getprop(ctxmap, 'opmap', getprop(basectx, 'opmap'))
+
+    this.data = getprop(ctxmap, 'data', {})
+    this.reqdata = getprop(ctxmap, 'reqdata', {})
+    this.match = getprop(ctxmap, 'match', {})
+    this.reqmatch = getprop(ctxmap, 'reqmatch', {})
+
+    this.target = getprop(ctxmap, 'target', getprop(basectx, 'target'))
+    this.spec = getprop(ctxmap, 'spec', getprop(basectx, 'spec'))
+    this.result = getprop(ctxmap, 'result', getprop(basectx, 'result'))
+    this.response = getprop(ctxmap, 'response', getprop(basectx, 'response'))
+
+    const opname = getprop(ctxmap, 'opname')
+    this.op = this.resolveOp(opname)
+  }
+
+
+  resolveOp(opname: string): Operation {
+    let op: Operation = getprop(this.opmap, opname)
+
+    if (null == op && null != opname) {
+      const entname = getprop(this.entity, 'name', '')
+      const opcfg = getpath(this.config, ['entity', entname, 'op', opname])
+      let input = 'match'
+
+      if ('update' === opname || 'create' === opname) {
+        input = 'data'
+      }
+
+      op = new Operation({
+        entity: entname,
+        name: opname,
+        input,
+        targets: getprop(opcfg, 'targets', [])
+      })
+
+      setprop(this.opmap, opname, op)
+    }
+
+    return op
+  }
+
+
+  error(code: string, msg: string) {
+    return new ProjectNameError(code, msg, this)
+  }
+
+
+  toJSON() {
+    return {
+      id: this.id,
+      op: this.op,
+      spec: this.spec,
+      entity: this.entity,
+      result: this.result,
+      response: this.response,
+      meta: this.meta,
+    }
+  }
+
+  toString() {
+    return 'Context ' + (this as any).utility?.struct.jsonify(this.toJSON())
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
+}
+
+
+export {
+  Context,
+}

package/project/.sdk/tm/ts/src/Control.ts

@@ -0,0 +1,20 @@
+
+import { getprop } from './utility/StructUtility'
+
+
+class Control {
+  throw?: boolean
+  err?: any
+  explain?: any
+
+  constructor(ctrlmap: Record<string, any>) {
+    this.throw = getprop(ctrlmap, 'throw')
+    this.err = getprop(ctrlmap, 'err')
+    this.explain = getprop(ctrlmap, 'explain')
+  }
+}
+
+
+export {
+  Control,
+}

package/project/.sdk/tm/ts/src/Operation.ts

@@ -0,0 +1,24 @@
+
+import { getprop } from './utility/StructUtility'
+
+import { Target } from './Target'
+
+
+class Operation {
+  entity: string
+  name: string
+  input: string
+  targets: Target[]
+
+  constructor(opmap: Record<string, any>) {
+    this.entity = getprop(opmap, 'entity', '_')
+    this.name = getprop(opmap, 'name', '_')
+    this.input = getprop(opmap, 'input', '_')
+    this.targets = getprop(opmap, 'targets', [])
+  }
+}
+
+
+export {
+  Operation,
+}

package/project/.sdk/tm/ts/src/Response.ts

@@ -0,0 +1,26 @@
+
+import { getprop } from './utility/StructUtility'
+
+
+class Response {
+  status: number
+  statusText: string
+  headers: any
+  json: Function
+  err?: Error
+  body?: any
+
+  constructor(resmap: Record<string, any>) {
+    this.status = getprop(resmap, 'status', -1)
+    this.statusText = getprop(resmap, 'statusText', '')
+    this.headers = getprop(resmap, 'headers')
+    this.json = resmap.json ? resmap.json.bind(resmap) : async () => undefined
+    this.body = getprop(resmap, 'body')
+    this.err = getprop(resmap, 'err')
+  }
+}
+
+
+export {
+  Response,
+}

package/project/.sdk/tm/ts/src/Result.ts

@@ -0,0 +1,30 @@
+
+import { getprop } from './utility/StructUtility'
+
+
+class Result {
+  ok: boolean
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  body?: any
+  err?: any
+  resdata?: any
+  resmatch?: any
+
+  constructor(resmap: Record<string, any>) {
+    this.ok = getprop(resmap, 'ok', false)
+    this.status = getprop(resmap, 'status', -1)
+    this.statusText = getprop(resmap, 'statusText', '')
+    this.headers = getprop(resmap, 'headers', {})
+    this.body = getprop(resmap, 'body')
+    this.err = getprop(resmap, 'err')
+    this.resdata = getprop(resmap, 'resdata')
+    this.resmatch = getprop(resmap, 'resmatch')
+  }
+}
+
+
+export {
+  Result,
+}

package/project/.sdk/tm/ts/src/Spec.ts

@@ -0,0 +1,40 @@
+
+import { getprop } from './utility/StructUtility'
+
+
+class Spec {
+  parts: string[]
+  headers: Record<string, string>
+  alias: any
+  base: string
+  prefix: string
+  suffix: string
+  params: Record<string, string>
+  query: Record<string, string>
+  step: string
+  method: string
+  body: any
+  url?: string
+  path?: string
+
+  constructor(specmap: Record<string, any>) {
+    this.parts = getprop(specmap, 'parts', [])
+    this.headers = getprop(specmap, 'headers', {})
+    this.alias = getprop(specmap, 'alias', {})
+    this.base = getprop(specmap, 'base', '')
+    this.prefix = getprop(specmap, 'prefix', '')
+    this.suffix = getprop(specmap, 'suffix', '')
+    this.params = getprop(specmap, 'params', {})
+    this.query = getprop(specmap, 'query', {})
+    this.step = getprop(specmap, 'step', '')
+    this.method = getprop(specmap, 'method', 'GET')
+    this.body = getprop(specmap, 'body')
+    this.url = getprop(specmap, 'url')
+    this.path = getprop(specmap, 'path')
+  }
+}
+
+
+export {
+  Spec,
+}

package/project/.sdk/tm/ts/src/Target.ts

@@ -0,0 +1,36 @@
+
+import { getprop } from './utility/StructUtility'
+
+
+class Target {
+  args: { params: any[] }
+  rename: { params: Record<string, string> }
+  method: string
+  orig: string
+  parts: string[]
+  params: string[]
+  select: any
+  active: boolean
+  relations: any[]
+  alias: Record<string, string>
+  transform: { req: any, res: any }
+
+  constructor(altmap: Record<string, any>) {
+    this.args = getprop(altmap, 'args', { params: [] })
+    this.rename = getprop(altmap, 'rename', { params: {} })
+    this.method = getprop(altmap, 'method', '')
+    this.orig = getprop(altmap, 'orig', '')
+    this.parts = getprop(altmap, 'parts', [])
+    this.params = getprop(altmap, 'params', [])
+    this.select = getprop(altmap, 'select')
+    this.active = getprop(altmap, 'active', false)
+    this.relations = getprop(altmap, 'relations', [])
+    this.alias = getprop(altmap, 'alias', {})
+    this.transform = getprop(altmap, 'transform', { req: undefined, res: undefined })
+  }
+}
+
+
+export {
+  Target,
+}

package/project/.sdk/tm/ts/src/feature/base/BaseFeature.ts

@@ -23,7 +23,7 @@ class BaseFeature implements Feature {
   GetMatch(this: any, _ctx: any) { }
 
 
-  PreOperation(this: any, _ctx: any) { }
+  PreTarget(this: any, _ctx: any) { }
 
   PreSpec(this: any, _ctx: any) { }
 

package/project/.sdk/tm/ts/src/feature/log/LogFeature.ts

@@ -65,8 +65,8 @@ class LogFeature extends BaseFeature {
   }
 
 
-  PreOperation(this: any, ctx: any) {
-    this._loghook('PreOperation', ctx)
+  PreTarget(this: any, ctx: any) {
+    this._loghook('PreTarget', ctx)
   }
 
   PreSpec(this: any, ctx: any) {

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -42,7 +42,7 @@ class TestFeature extends BaseFeature {
 
     function testFetcher(ctx: any, _fullurl: string, _fetchdef: any) {
       const struct = ctx.utility.struct
-      const findparam = ctx.utility.findparam
+      const param = ctx.utility.param
 
       const getprop = struct.getprop
       const clone = struct.clone
@@ -134,7 +134,7 @@ class TestFeature extends BaseFeature {
       }
       else if ('create' === op.name) {
         const args = self.buildArgs(ctx, op, ctx.reqdata)
-        let id = findparam(ctx, 'id')
+        let id = param(ctx, 'id')
         if (null == id) {
           id = ((1e4 * Math.random() | 0).toString(16) +
             (1e4 * Math.random() | 0).toString(16) +
@@ -157,7 +157,7 @@ class TestFeature extends BaseFeature {
 
   buildArgs(ctx: any, op: any, args: any): any {
     const struct = ctx.utility.struct
-    const findparam = ctx.utility.findparam
+    const param = ctx.utility.param
 
     const getprop = struct.getprop
     const keysof = struct.keysof
@@ -168,12 +168,12 @@ class TestFeature extends BaseFeature {
     const isempty = struct.isempty
 
     const opname = getprop(op, 'name')
-    const alt =
+    const target =
       getelem(getpath(ctx.config, [
-        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'alts']), -1)
+        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'targets']), -1)
 
     const reqd = transform(
-      select(getpath(alt, ['args', 'param']), { reqd: true }),
+      select(getpath(target, ['args', 'params']), { reqd: true }),
       ['`$EACH`', '', '`$KEY.name`']
     )
 
@@ -182,7 +182,7 @@ class TestFeature extends BaseFeature {
 
     for (let k of keysof(args)) {
       if ('id' === k || !isempty(select(reqd, k))) {
-        const v = findparam(ctx, k)
+        const v = param(ctx, k)
         const ka = getprop(op.alias, k)
 
         let qor: any = [{ [k]: v }]