@voxgig/sdkgen 0.36.0 → 0.37.0

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

package/project/.sdk/tm/js/src/utility/CleanUtility.js

@@ -0,0 +1,31 @@
+
+const {
+  walk, size, pad, slice, clone
+} = require('./StructUtility')
+
+// Clean request data by partially hiding sensitive values.
+function clean(ctx, val) {
+  const options = ctx.options
+
+  const cleankeyre = options?.__derived__?.clean?.keyre
+  const hintsize = 4
+
+  /*
+  if (null != cleankeyre) {
+    val = walk(clone(val), (key, subval) => {
+      if (cleankeyre.exec(key) && 'string' === typeof subval) {
+        const len = size(subval)
+        const hint = (hintsize * 4) < len ? slice(subval, 0, hintsize) : ''
+        subval = pad(hint, len, '*')
+      }
+      return subval
+    })
+  }
+  */
+
+  return val
+}
+
+module.exports = {
+  clean
+}

package/project/.sdk/tm/js/src/utility/DoneUtility.js

@@ -1,15 +1,22 @@
 
+const { clean } = require('./CleanUtility')
+
 function done(ctx) {
-  const { error } = ctx.utility
-  
-  if(ctx.result.ok) {
+  const error = ctx.utility.makeError
+  const delprop = ctx.utility.struct.delprop
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain = clean(ctx, ctx.ctrl.explain)
+    delprop(ctx.ctrl.explain.result, 'err')
+  }
+
+  if (ctx.result && ctx.result.ok) {
     return ctx.result.resdata
   }
 
   return error(ctx)
 }
 
-
 module.exports = {
   done
 }

package/project/.sdk/tm/js/src/utility/FeatureAddUtility.js

@@ -0,0 +1,42 @@
+
+function featureAdd(ctx, f) {
+  const client = ctx.client
+  const struct = ctx.utility.struct
+  const setprop = struct.setprop
+  const getprop = struct.getprop
+
+  const fopts = getprop(f, '_options', {})
+  let added = false
+  const features = client._features
+
+  if (fopts.__before__ || fopts.__after__ || fopts.__replace__) {
+
+    for (let i = 0; i < features.length; i++) {
+      let ef = client._features[i]
+      if (fopts.__before__ === ef.name) {
+        client._features = [...features.slice(0, i), f, ...features.slice(i)]
+        added = true
+        break
+      }
+      else if (fopts.__after__ === ef.name) {
+        client._features = [...features.slice(0, ++i), f, ...features.slice(i)]
+        added = true
+        break
+      }
+      else if (fopts.__replace__ === ef.name) {
+        client._features = setprop(features, i, f)
+        added = true
+        break
+      }
+    }
+  }
+
+  if (!added) {
+    client._features = setprop(features, features.length, f)
+  }
+
+}
+
+module.exports = {
+  featureAdd
+}

package/project/.sdk/tm/js/src/utility/FeatureHookUtility.js

@@ -0,0 +1,25 @@
+
+function featureHook(ctx, name) {
+  const client = ctx.client
+
+  let resp = []
+  const features = client._features || []
+
+  for (let f of features) {
+    const fh = f[name]
+    if (null != fh) {
+      const fres = fh(ctx)
+      if (fres instanceof Promise) {
+        resp.push(fres)
+      }
+    }
+  }
+
+  if (0 < resp.length) {
+    return Promise.all(resp)
+  }
+}
+
+module.exports = {
+  featureHook
+}

package/project/.sdk/tm/js/src/utility/FeatureInitUtility.js

@@ -0,0 +1,11 @@
+
+function featureInit(ctx, f) {
+  const fopts = ctx.options.feature[f.name] || {}
+  if (true === fopts.active) {
+    f.init(ctx, fopts)
+  }
+}
+
+module.exports = {
+  featureInit
+}

package/project/.sdk/tm/js/src/utility/FetcherUtility.js

@@ -0,0 +1,28 @@
+
+// Make HTTP call using library. Replace this utility for mocking etc.
+async function fetcher(ctx, fullurl, fetchdef) {
+
+  if ('live' !== ctx.client._mode) {
+    return ctx.error('fetch_mode_block', 'Request blocked by mode: "' + ctx.client._mode +
+      '" (URL was: "' + fullurl + '")')
+  }
+
+  const options = ctx.client.options()
+
+  const getpath = ctx.utility.struct.getpath
+
+  if (true === getpath(options, 'feature.test.active')) {
+    return ctx.error('fetch_test_block', 'Request blocked as test feature is active' +
+      ' (URL was: "' + fullurl + '")')
+  }
+
+  const fetch = options.system.fetch
+
+  const response = await fetch(fullurl, fetchdef)
+
+  return response
+}
+
+module.exports = {
+  fetcher
+}

package/project/.sdk/tm/js/src/utility/MakeContextUtility.js

@@ -0,0 +1,11 @@
+
+const { Context } = require('../Context')
+
+function makeContext(ctxmap, basectx) {
+  const ctx = new Context(ctxmap, basectx)
+  return ctx
+}
+
+module.exports = {
+  makeContext,
+}