@voxgig/sdkgen 0.35.2 → 0.37.0

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

@@ -0,0 +1,142 @@
+
+const { inspect } = require('node:util')
+
+const { ProjectNameError } = require('./ProjectNameError')
+
+const { getprop, setprop, getpath } = require('./utility/StructUtility')
+
+const { Operation } = require('./Operation')
+const { Response } = require('./Response')
+const { Result } = require('./Result')
+const { Spec } = require('./Spec')
+
+
+// TODO: move to own file
+class Context {
+
+  id = 'C' + ('' + Math.random()).substring(2, 10)
+
+  // Store the output of each operation step.
+  out = {}
+
+  // Store for the current operation.
+  current = new WeakMap()
+
+
+  ctrl = {}
+  meta = {}
+
+  client
+  utility
+
+  op
+  point
+
+  config
+  entopts
+  options
+
+  opmap
+
+  response
+  result
+  spec
+
+  data
+  reqdata
+  match
+  reqmatch
+
+  entity
+
+  // Shared persistent store.
+  shared
+
+
+  constructor(ctxmap, basectx) {
+    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.point = getprop(ctxmap, 'point', getprop(basectx, 'point'))
+    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) {
+    let op = 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,
+        points: getprop(opcfg, 'points', [])
+      })
+
+      setprop(this.opmap, opname, op)
+    }
+
+    return op
+  }
+
+
+  error(code, msg) {
+    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.utility?.struct.jsonify(this.toJSON())
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
+}
+
+
+module.exports = {
+  Context,
+}

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

@@ -0,0 +1,16 @@
+
+const { getprop } = require('./utility/StructUtility')
+
+
+class Control {
+  constructor(ctrlmap) {
+    this.throw = getprop(ctrlmap, 'throw')
+    this.err = getprop(ctrlmap, 'err')
+    this.explain = getprop(ctrlmap, 'explain')
+  }
+}
+
+
+module.exports = {
+  Control,
+}

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

@@ -0,0 +1,19 @@
+
+const { getprop } = require('./utility/StructUtility')
+
+const { Point } = require('./Point')
+
+
+class Operation {
+  constructor(opmap) {
+    this.entity = getprop(opmap, 'entity', '_')
+    this.name = getprop(opmap, 'name', '_')
+    this.input = getprop(opmap, 'input', '_')
+    this.points = getprop(opmap, 'points', [])
+  }
+}
+
+
+module.exports = {
+  Operation,
+}

package/project/.sdk/tm/js/src/Point.js

@@ -0,0 +1,24 @@
+
+const { getprop } = require('./utility/StructUtility')
+
+
+class Point {
+  constructor(altmap) {
+    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 })
+  }
+}
+
+
+module.exports = {
+  Point,
+}

package/project/.sdk/tm/js/src/README.md

@@ -0,0 +1 @@
+# src

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

@@ -0,0 +1,19 @@
+
+const { getprop } = require('./utility/StructUtility')
+
+
+class Response {
+  constructor(resmap) {
+    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')
+  }
+}
+
+
+module.exports = {
+  Response,
+}

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

@@ -0,0 +1,21 @@
+
+const { getprop } = require('./utility/StructUtility')
+
+
+class Result {
+  constructor(resmap) {
+    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')
+  }
+}
+
+
+module.exports = {
+  Result,
+}

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

@@ -0,0 +1,26 @@
+
+const { getprop } = require('./utility/StructUtility')
+
+
+class Spec {
+  constructor(specmap) {
+    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')
+  }
+}
+
+
+module.exports = {
+  Spec,
+}

package/project/.sdk/tm/js/src/feature/README.md

@@ -0,0 +1 @@
+# Feature

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

@@ -0,0 +1,45 @@
+
+
+class BaseFeature {
+  version = '0.0.1'
+  name = 'base'
+  active = true
+
+
+  init(_ctx, _options) { }
+
+
+  PostConstruct(_ctx) { }
+
+  PostConstructEntity(_ctx) { }
+
+
+  SetData(_ctx) { }
+
+  GetData(_ctx) { }
+
+  SetMatch(_ctx) { }
+
+  GetMatch(_ctx) { }
+
+
+  PrePoint(_ctx) { }
+
+  PreSpec(_ctx) { }
+
+  PreRequest(_ctx) { }
+
+  PreResponse(_ctx) { }
+
+  PreResult(_ctx) { }
+
+  PreDone(_ctx) { }
+
+  PreUnexpected(_ctx) { }
+
+}
+
+
+module.exports = {
+  BaseFeature
+}

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

@@ -1,98 +1,97 @@
 
 
+const { BaseFeature } = require('../base/BaseFeature')
+
+
 const Pino = require('pino')
 const PinoPretty = require('pino-pretty')
 
 
-class LogFeature {
-  version = 'FEATURE_VERSION'
-  
-  #client // SDK client instance
-  #options // SDK client feature options
-  #config // Feature config from model
-  #logger // Pino-style interface
-  
-  constructor(client, options, config) {
-    // TOOD: make this a default for all features
-    options = options || {}
-    options.active = false !== options.active
 
-    this.#client = client
-    this.#options = options
-    this.#config = config
+class LogFeature extends BaseFeature {
+  version = '0.0.1'
+  name = 'log'
+  active = true
+
+  _client
+  _options
+  _logger
+
 
-    if(options.active) {
-      let logger = options.logger
+  init(ctx, options) {
+    this._client = ctx.client
+    this._options = options
+    this.active = options.active
 
-      if(null ==logger) {
+    if (this.active) {
+      let logger = this._options.logger
+
+      if (null == logger) {
         let pretty = PinoPretty({
           sync: true,
           ignore: 'ctx',
         })
 
-        let name = options.name || 'FEATURE_Name'
-        let level = options.level || 'info'
-        
-        logger = Pino({ name, level }, pretty)
+        let level = this._options.level || 'info'
+
+        logger = Pino({ name: 'log', level }, pretty)
+
+        this._logger = logger
       }
-      this.#logger = logger
     }
   }
 
-  options() {
-    return { ...this.#options }
-  }
-
-  client() {
-    return this.#client
-  }
 
-  
   PostConstruct(ctx) {
-    this.#loghook('PostConstruct', ctx)
+    this._loghook('PostConstruct', ctx)
   }
 
   PostConstructEntity(ctx) {
-    this.#loghook('PostConstructEntity', ctx)
+    this._loghook('PostConstructEntity', ctx)
   }
 
   SetData(ctx) {
-    this.#loghook('SetData', ctx)
+    this._loghook('SetData', ctx)
   }
-  
+
   GetData(ctx) {
-    this.#loghook('GetData', ctx)
+    this._loghook('GetData', ctx)
   }
-  
+
   GetMatch(ctx) {
-    this.#loghook('GetMatch', ctx)
+    this._loghook('GetMatch', ctx)
   }
 
 
   PrePoint(ctx) {
-    this.#loghook('PrePoint', ctx)
+    this._loghook('PrePoint', ctx)
   }
 
   PreSpec(ctx) {
-    this.#loghook('PreSpec', ctx)
+    this._loghook('PreSpec', ctx)
   }
 
   PreRequest(ctx) {
-    this.#loghook('PreRequest', ctx)
+    this._loghook('PreRequest', ctx)
   }
 
   PreResponse(ctx) {
-    this.#loghook('PreResponse', ctx)
+    this._loghook('PreResponse', ctx)
   }
 
   PreResult(ctx) {
-    this.#loghook('PreResult', ctx)
+    this._loghook('PreResult', ctx)
   }
- 
-  #loghook(hook, ctx, level) {
+
+  _loghook(hook, ctx, level) {
     level = level || 'info'
-    if(this.#logger) {
-      this.#logger[level]({hook,op:ctx.op,spec:ctx.spec,ctx})
+    if (this._logger) {
+      this._logger[level]({
+        hook,
+        op: ctx.op,
+        spec: ctx.spec,
+        ctx
+      })
     }
   }
 }

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

@@ -0,0 +1,207 @@
+
+const { BaseFeature } = require('../base/BaseFeature')
+
+
+const S_NOT_FOUND = 'Not found'
+
+
+class TestFeature extends BaseFeature {
+  version = '0.0.1'
+  name = 'test'
+  active = true
+
+  _client
+  _options
+
+
+  init(ctx, options) {
+    this._client = ctx.client
+    this._options = options
+
+    const struct = ctx.utility.struct
+    const walk = struct.walk
+    const size = struct.size
+    const setprop = struct.setprop
+
+    const entity = this._options.entity
+
+    this._client._mode = 'test'
+
+    // Ensure entity ids are correct.
+    walk(entity, (k, v, _parent, path) => {
+      if (2 === size(path)) {
+        setprop(v, 'id', k)
+      }
+      return v
+    })
+
+    const self = this
+
+    function testFetcher(ctx, _fullurl, _fetchdef) {
+      const struct = ctx.utility.struct
+      const param = ctx.utility.param
+
+      const getprop = struct.getprop
+      const clone = struct.clone
+      const merge = struct.merge
+      const getelem = struct.getelem
+      const select = struct.select
+      const delprop = struct.delprop
+      const getdef = struct.getdef
+
+      function respond(status, data, res) {
+        const out = merge([
+          {
+            status,
+            statusText: 'OK',
+            json: async () => data,
+            body: 'not-used',
+          },
+          getdef(res, {})
+        ])
+
+        const headers = getprop(out, 'headers', {})
+
+        // JS specific iterator.
+        out.headers = {
+          forEach(callback) {
+            Object.keys(headers).forEach((key) => {
+              callback(headers[key], key, this)
+            })
+          }
+        }
+
+        return out
+      }
+
+
+      const op = ctx.op
+      const entmap = getprop(entity, op.entity, {})
+
+      if ('load' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
+        }
+        else {
+          delprop(ent, '$KEY')
+          const out = clone(ent)
+          return respond(200, out)
+        }
+      }
+      else if ('list' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        if (null == found) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
+        }
+        else {
+          found.map((ent) => delprop(ent, '$KEY'))
+          const out = clone(found)
+          return respond(200, out)
+        }
+      }
+      else if ('update' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
+        }
+        else {
+          merge([ent, (ctx.reqdata || {})])
+          delprop(ent, '$KEY')
+          const out = clone(ent)
+          return respond(200, out)
+        }
+      }
+      else if ('remove' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
+        }
+        else {
+          delprop(entmap, getprop(ent, 'id'))
+          return respond(200)
+        }
+      }
+      else if ('create' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        let id = param(ctx, 'id')
+        if (null == id) {
+          id = ((1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16)).padEnd(16, '0')
+        }
+
+        const ent = clone(ctx.reqdata)
+        setprop(ent, 'id', id)
+        setprop(entmap, id, ent)
+        delprop(ent, '$KEY')
+        const out = clone(ent)
+        return respond(200, out)
+      }
+    }
+
+    ctx.utility.fetcher = testFetcher
+  }
+
+
+  buildArgs(ctx, op, args) {
+    const struct = ctx.utility.struct
+    const param = ctx.utility.param
+
+    const getprop = struct.getprop
+    const keysof = struct.keysof
+    const getpath = struct.getpath
+    const getelem = struct.getelem
+    const select = struct.select
+    const transform = struct.transform
+    const isempty = struct.isempty
+
+    const opname = getprop(op, 'name')
+    const point =
+      getelem(getpath(ctx.config, [
+        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'points']), -1)
+
+    const reqd = transform(
+      select(getpath(point, ['args', 'params']), { reqd: true }),
+      ['`$EACH`', '', '`$KEY.name`']
+    )
+
+    const qand = []
+    const q = { '`$AND`': qand }
+
+    for (let k of keysof(args)) {
+      if ('id' === k || !isempty(select(reqd, k))) {
+        const v = param(ctx, k)
+        const ka = getprop(op.alias, k)
+
+        let qor = [{ [k]: v }]
+        if (null != ka) {
+          qor.push({ [ka]: v })
+        }
+
+        qor = { '`$OR`': qor }
+
+        qand.push(qor)
+      }
+    }
+
+    if (ctx.ctrl.explain) {
+      ctx.ctrl.explain.test = { query: q }
+    }
+
+    return q
+  }
+}
+
+
+module.exports = {
+  TestFeature
+}

package/project/.sdk/tm/js/src/types.js

@@ -0,0 +1,22 @@
+
+const { ProjectNameEntityBase } = require('./ProjectNameEntityBase')
+
+const { Point } = require('./Point')
+const { Context } = require('./Context')
+const { Control } = require('./Control')
+const { Operation } = require('./Operation')
+const { Response } = require('./Response')
+const { Result } = require('./Result')
+const { Spec } = require('./Spec')
+
+
+module.exports = {
+  Point,
+  Context,
+  Control,
+  Operation,
+  Response,
+  Result,
+  Spec,
+  ProjectNameEntityBase,
+}