@voxgig/sdkgen 0.16.0 → 0.18.0

package/project/.sdk/tm/js/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ $$const.Name$$
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

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

@@ -0,0 +1,108 @@
+
+
+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
+
+    if(options.active) {
+      let logger = 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)
+      }
+      this.#logger = logger
+    }
+  }
+
+  options() {
+    return { ...this.#options }
+  }
+
+  client() {
+    return this.#client
+  }
+
+  
+  PostConstruct(ctx) {
+    this.#loghook('PostConstruct', ctx)
+  }
+
+  PostConstructEntity(ctx) {
+    this.#loghook('PostConstructEntity', ctx)
+  }
+
+  SetData(ctx) {
+    this.#loghook('SetData', ctx)
+  }
+  
+  GetData(ctx) {
+    this.#loghook('GetData', ctx)
+  }
+  
+  GetMatch(ctx) {
+    this.#loghook('GetMatch', ctx)
+  }
+
+
+  PreOperation(ctx) {
+    this.#loghook('PreOperation', ctx)
+  }
+
+  PreSpec(ctx) {
+    this.#loghook('PreSpec', ctx)
+  }
+
+  PreRequest(ctx) {
+    this.#loghook('PreRequest', ctx)
+  }
+
+  PreResponse(ctx) {
+    this.#loghook('PreResponse', ctx)
+  }
+
+  PreResult(ctx) {
+    this.#loghook('PreResult', ctx)
+  }
+ 
+  PostOperation(ctx) {
+    this.#loghook('PostOperation', ctx)
+  }
+
+  
+  #loghook(hook, ctx, level) {
+    level = level || 'info'
+    if(this.#logger) {
+      this.#logger[level]({hook,op:ctx.op,spec:ctx.spec,ctx})
+    }
+  }
+}
+
+
+module.exports = {
+  LogFeature
+}

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

@@ -0,0 +1,21 @@
+
+function auth(ctx) {
+  const { client, spec } = ctx
+  const { headers } = spec
+  
+  let options = client.options()
+
+  if(null != options.apikey && '' !== options.apikey) {
+    headers['authorization'] = 'Bearer '+options.apikey
+  }
+  else {
+    delete headers['authorization']
+  }
+  
+  return spec
+}
+
+
+module.exports = {
+  auth
+}

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

@@ -0,0 +1,29 @@
+
+
+function body(ctx) {
+  const { op, result, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+  
+  let body = undefined
+
+  if('req' === op.kind) {
+    try {
+      const reqform = op.reqform
+      body = isfunc(reqform) ? reqform(ctx) : transform(op, op.reqform)
+
+      if(op.check.nobody && null == body) {
+        return error(ctx, new Error('Request body is empty.'))
+      }
+    }
+    catch (err) {
+      return error(ctx, err)
+    }
+  }
+
+  return body
+}
+
+module.exports = {
+  body
+}

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

@@ -0,0 +1,15 @@
+
+function done(ctx) {
+  const { error } = ctx.utility
+  
+  if(ctx.result.ok) {
+    return ctx.result.resdata
+  }
+
+  return error(ctx)
+}
+
+
+module.exports = {
+  done
+}

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

@@ -0,0 +1,33 @@
+
+function error(ctx, err) {
+
+  ctx = ctx || {}
+  const op = ctx.op || {}
+  op.name = op.name || 'unknown operation'
+
+  const result = ctx.result = ctx.result || {}
+  result.ok = false
+  
+  const reserr = result.err
+  
+  err = undefined === err ? reserr : err
+  err = err || new Error('unknown error')
+  
+  const errmsg = err.message || 'unknown error'
+  const msg = 'StatuspageSDK: '+op.name+': '+errmsg
+  err.message = msg
+  // result.err = {...err}
+  
+  const spec = ctx.spec || {}
+
+  err.result = ctx.result
+  err.spec = spec
+
+  // TODO: model option to return instead
+  throw err
+}
+
+
+module.exports = {
+  error
+}

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

@@ -0,0 +1,31 @@
+
+/* Find value of a match parameter, possibly using an alias.
+ *
+ * The match parameter may have an alias key. For example, the parameter `foo_id` may be
+ * aliased to `id` in the entity data.
+ *
+ * This function returns `undefined` rather than failing.
+ */
+function findparam(ctx, key) {
+  let { op, spec } = ctx
+  let { match, data, alias } = op
+
+  let source = ('res' === op.kind ? match : data) || {}
+  let val = source[key]
+
+  if(null == val) {
+    alias = alias || {}
+    let akey = alias[key]
+    val = source[akey]
+
+    spec = spec || {}
+    spec.alias = spec.alias || {}
+    spec.alias[akey] = key
+  }
+
+  return val
+}
+
+module.exports = {
+  findparam
+}

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

@@ -0,0 +1,39 @@
+
+
+function fullurl(ctx) {
+  const { op, spec, utility: { struct, findparam } } = ctx
+  const { escurl, escre, joinurl } = struct
+  
+  let url = joinurl([spec.base, spec.prefix, spec.path, spec.suffix])
+
+  const params = spec.params
+  for(let key of op.params) {
+    if(null == params[key]) {
+      params[key] = findparam(ctx, key)
+    }
+  }
+  
+  for(let key in params) {
+    const val = params[key]
+    if(null != val) { 
+      url = url.replace(RegExp('{'+escre(key)+'}'), escurl(val))
+    }
+  }
+
+  let qsep = '?'
+  for(let key in spec.query) {
+    if(null == spec.alias[key]) {
+      const val = spec.query[key]
+      if(null != val) { 
+        url += qsep + escurl(key) + '=' + escurl(val)
+        qsep = '&'
+      }
+    }
+  }
+
+  return url
+}
+
+module.exports = {
+  fullurl
+}

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

@@ -0,0 +1,13 @@
+
+function headers(ctx) {
+  const out = {}
+
+  // TODO: should come from options via config
+  out['content-type'] = 'application/json'
+  
+  return out
+}
+
+module.exports = {
+  headers
+}

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

@@ -0,0 +1,14 @@
+
+// TODO: MOVE TO STRUCT
+function joinurl(...s) {
+  return s
+    .filter(s=>null!=s&&''!==s)
+    .map((s,i)=> 0===i ? s.replace(/([^\/])\/+/,'$1/').replace(/\/+$/,'') :
+        s.replace(/([^\/])\/+/,'$1/').replace(/^\/+/,'').replace(/\/+$/,''))
+    .filter(s=>''!==s)
+    .join('/')
+}
+
+module.exports = {
+  joinurl
+}

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

@@ -0,0 +1,22 @@
+
+function method(ctx) {
+  const { op } = ctx
+  const opname = op.name
+  
+  let key = opname
+
+  // TODO: options
+  const mmap = {
+    create: 'POST',
+    update: 'PUT',
+    load: 'GET',
+    list: 'GET',
+    remove: 'DELETE',
+  }
+
+  return mmap[key]
+}
+
+module.exports = {
+  method
+}

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

@@ -0,0 +1,44 @@
+
+
+const OPKIND = {
+  create: 'req',
+  update: 'req',
+  remove: 'req',
+  load: 'res',
+  list: 'res',
+}
+
+
+// Ensure standard operation definition.
+function operator(ctx) {
+  const { op, utility } = ctx
+  const { validate } = utility.struct
+
+  const opspec = {
+
+    // Required.
+    name: '`$STRING`',
+    kind: ['`$ONE`','req','res'],
+    path: '`$STRING`',
+    entity: '`$STRING`',
+    reqform: ['`$ONE`','`$STRING`','`$OBJECT`','`$FUNCTION`'],
+    resform: ['`$ONE`','`$STRING`','`$OBJECT`','`$FUNCTION`'],
+
+    // Optional.
+    params: ['`$CHILD`', '`$STRING`'],
+    alias: {'`$CHILD`': '`$STRING`' },
+    match: {},
+    data: ['`$ONE`',{}, []],
+    state: {},
+    check: {},
+  }
+
+  ctx.op.kind = OPKIND[op.name]
+  
+  ctx.op = validate(ctx.op, opspec)
+}
+
+
+module.exports = {
+  operator
+}

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

@@ -0,0 +1,54 @@
+
+function options(ctx) {
+  const { options, utility } = ctx
+  
+  let opts = { ...(options||{}) }
+  
+  const customUtils = opts.utility || {}
+  for(let key of Object.keys(customUtils)) {
+    utility[key] = customUtils[key]
+  }
+  
+  const { isempty, merge, validate } = utility.struct
+
+  let config = ctx.config || {}
+  let cfgopts = config.options || {}
+  
+  // Standard SDK option values.
+  const optspec = {
+    apikey: '',
+    base: 'http://localhost:8000',
+    prefix: '',
+    suffix: '',
+    entity: {
+      '`$CHILD`': {
+        '`$OPEN`': true, 
+        active: false,
+        alias: {}
+      }
+    },
+    feature: {
+      '`$CHILD`': {
+        '`$OPEN`': true,
+        active: false, 
+      }
+    },
+    utility: {},
+    system: {},
+  }
+
+  // JavaScript specific option values.
+  optspec.system.fetch = optspec.system.fetch || global.fetch
+
+  opts = merge([{},cfgopts,opts])
+
+  opts = validate(opts, optspec)
+
+  return opts
+}
+
+
+
+module.exports = {
+  options
+}

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

@@ -0,0 +1,21 @@
+
+function params(ctx) {
+  const { op } = ctx
+  let { params, match } = op
+  params = params || []
+  match = match || {}
+  
+  const out = {}
+  for(let key of params) {
+    let val = match[key]
+    if(null!=val) {
+      out[key] = val
+    }
+  }
+
+  return out
+}
+
+module.exports = {
+  params
+}

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

@@ -0,0 +1,21 @@
+
+function query(ctx) {
+  const { op } = ctx
+  let { params, match } = op
+  params = params || []
+  match = match || {}
+  
+  const out = {}
+  for(let key of Object.keys(match)) {
+    let val = match[key]
+    if(null!=val && !params.includes(key)) {
+      out[key] = val
+    }
+  }
+
+  return out
+}
+
+module.exports = {
+  query
+}

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

@@ -0,0 +1,32 @@
+
+/* Convert entity data or match query into a srtucture suitable for use as request data.
+ *
+ * The operation (op) property `reqform` is used to perform the data preparation.
+ */
+function reqform(ctx) {
+  const { op, spec, result, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+
+  if(spec) {
+    spec.step = 'reqform'
+  }
+  
+  // if (!result.ok) {
+  //   return undefined
+  // }
+
+  try {
+    const reqform = ctx.op.reqform
+    const reqdata = isfunc(reqform) ? reqform(ctx) : transform(ctx.op, reqform)
+    return reqdata
+  }
+  catch (err) {
+    return error(ctx, err)
+  }
+}
+
+
+module.exports = {
+  reqform
+}

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

@@ -0,0 +1,48 @@
+
+
+async function request(ctx) {
+  const { spec, utility, client } = ctx
+  const { fullurl, error } = utility
+  
+  let response = {}
+
+  try {
+    spec.step = 'prepare'
+
+    const options = client.options()
+    const url = spec.url = fullurl(ctx)
+
+    const fetch = options.system.fetch
+    
+    const fetchdef = {
+      method: spec.method,
+      headers: spec.headers,
+    }
+
+    if(null != spec.body) {
+      fetchdef.body =
+        'object' === typeof spec.body ? JSON.stringify(spec.body) : spec.body
+    }
+
+    spec.step = 'prerequest'
+    response = await fetch(url, fetchdef)
+
+    if(null == response) {
+      response = { err: new Error('response: undefined') }
+    }
+  }
+  catch(err) {
+    response = response || {}
+    response.err = err
+  }
+
+  spec.step = 'postrequest'
+  
+  ctx.response = response
+
+  return response
+}
+
+module.exports = {
+  request
+}

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

@@ -0,0 +1,27 @@
+
+function resbasic(ctx) {
+  const { response, result } = ctx
+
+  if(null != response) {
+    result.status = response.status || -1
+    result.statusText = response.statusText || 'no-status'
+  
+    // TODO: use spec!
+    if(400 <= result.status) {
+      const msg = 'request: '+result.status+': '+result.statusText
+      if(result.err) {
+        const prevmsg = null == result.err.message ? '' : result.err.message
+        result.err.message = prevmsg+': '+msg
+      }
+      else {
+        result.err = new Error(msg)
+      }
+    }
+  }
+
+  return result
+}
+
+module.exports = {
+  resbasic
+}

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

@@ -0,0 +1,15 @@
+
+async function resbody(ctx) {
+  const { response, result } = ctx
+
+  if(response && response.json) {
+    const json = await response.json()
+    result.body = json
+  }
+
+  return result
+}
+
+module.exports = {
+  resbody
+}

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

@@ -0,0 +1,34 @@
+
+/* Convert data from respnse into a structure suitable for use as entity data.
+ *
+ * The operation (op) property `resform` is used to perform the data extraction.
+ */
+function resform(ctx) {
+  const { op, spec, result, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+
+  if(spec) {
+    spec.step = 'resform'
+  }
+  
+  if (!result.ok) {
+    return undefined
+  }
+
+  try {
+    const resform = ctx.op.resform
+    const resdata = isfunc(resform) ? resform(ctx) : transform(ctx.result, resform)
+    result.resdata = resdata
+
+    return resdata
+  }
+  catch (err) {
+    return error(ctx, err)
+  }
+}
+
+
+module.exports = {
+  resform
+}

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

@@ -0,0 +1,19 @@
+
+function resheaders(ctx) {
+  const { response, result } = ctx
+
+  if(response && response.headers && response.headers.forEach) {
+    const headers = {}
+    response.headers.forEach((v,k)=>headers[k]=v)
+    result.headers = headers
+  }
+  else {
+    result.headers = {}
+  }
+  
+  return result
+}
+
+module.exports = {
+  resheaders
+}