@voxgig/sdkgen 0.16.0 → 0.17.0

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

@@ -0,0 +1,104 @@
+
+
+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)
+  }
+
+  SetData(ctx) {
+    this.#loghook('SetData', ctx)
+  }
+  
+  GetData(ctx) {
+    this.#loghook('GetData', ctx)
+  }
+  
+  GetQuery(ctx) {
+    this.#loghook('GetQuery', ctx)
+  }
+
+
+  PreOperation(ctx) {
+    this.#loghook('PreOperation', ctx)
+  }
+
+  ModifyOp(ctx) {
+    this.#loghook('ModifyOp', ctx)
+  }
+
+  PreFetch(ctx) {
+    this.#loghook('PreFetch', ctx)
+  }
+
+  PostFetch(ctx) {
+    this.#loghook('PostFetch', ctx)
+  }
+
+  ModifyResult(ctx) {
+    this.#loghook('ModifyResult', 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/generate/tm/js/src/utility/AuthUtility.js

@@ -0,0 +1,16 @@
+
+function auth(ctx, spec) {
+  const { client } = ctx
+  const { headers } = spec
+  
+  let options = client.options()
+
+  headers['authorization'] = 'Bearer '+options.apikey
+  
+  return spec
+}
+
+
+module.exports = {
+  auth
+}

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

@@ -0,0 +1,27 @@
+
+const { error } = require('./ErrorUtility')
+
+
+function body(ctx) {
+  const { op } = ctx
+
+  let body = undefined
+
+  if('req' === op.kind) {
+    try {
+      body = ctx.op.outward(ctx)
+    }
+    catch (err) {
+      // TDOD: need error codes and err msg text
+      ctx.result.ok = false
+      ctx.result.err = err
+      return error(ctx)
+    }
+  }
+
+  return body
+}
+
+module.exports = {
+  body
+}

package/project/generate/tm/js/src/utility/EmptyUtility.js

@@ -0,0 +1,8 @@
+
+function empty(s) {
+  return null == s || '' === s
+}
+
+module.exports = {
+  empty
+}

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

@@ -0,0 +1,15 @@
+
+function error(ctx) {
+
+  const err = new Error('Error: '+ctx.op.name+': '+(ctx.result.err?.message||'unknown'))
+  err.result = ctx.result
+  err.spec = ctx.spec
+
+  // TODO: model option to return instead
+  throw err
+}
+
+
+module.exports = {
+  error
+}

package/project/generate/tm/js/src/utility/EscreUtility.js

@@ -0,0 +1,8 @@
+
+function escre(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+module.exports = {
+  escre
+}

package/project/generate/tm/js/src/utility/EscurlUtility.js

@@ -0,0 +1,8 @@
+
+function escurl(s) {
+  return encodeURIComponent(s)
+}
+
+module.exports = {
+  escurl
+}

package/project/generate/tm/js/src/utility/FetchUtility.js

@@ -0,0 +1,33 @@
+
+const { fullurl }  = require('./FullurlUtility')
+
+// Make HTTP request.
+async function fetch(ctx) {
+  const {op, spec} = ctx
+  let response = {}
+  
+  try {
+    const url = spec.url = fullurl(ctx)
+    
+    const fetchReq = {
+      method: spec.method,
+      headers: spec.headers,
+    }
+
+    if(null != spec.body) {
+      fetchReq.body =
+        'object' === typeof spec.body ? JSON.stringify(spec.body) : spec.body
+    }
+
+    response = global.fetch(url, fetchReq)
+  }
+  catch(err) {
+    response.err = err
+  }
+  
+  return response
+}
+
+module.exports = {
+  fetch
+}

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

@@ -0,0 +1,41 @@
+
+const { joinurl }  = require('./JoinurlUtility')
+const { escurl }  = require('./EscurlUtility')
+const { escre }  = require('./EscreUtility')
+
+
+function fullurl(ctx) {
+  const { op, spec } = ctx
+  const { query, data } = op
+  
+  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] = 'res' === op.kind ? query[key] : data[key]
+    }
+  }
+  
+  for(let key in params) {
+    const val = spec.params[key]
+    if(null != val) { 
+      url = url.replace(RegExp('{'+escre(key)+'}'), escurl(val))
+    }
+  }
+
+  let qsep = '?'
+  for(let key in spec.query) {
+    const val = spec.query[key]
+    if(null != val) { 
+      url += qsep + escurl(key) + '=' + escurl(val)
+      qsep = '&'
+    }
+  }
+  
+  return url
+}
+
+module.exports = {
+  fullurl
+}

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

@@ -0,0 +1,12 @@
+
+function headers(ctx) {
+  const out = {}
+
+  out['content-type'] =  'application/json'
+  
+  return out
+}
+
+module.exports = {
+  headers
+}

package/project/generate/tm/js/src/utility/InwardUtility.js

@@ -0,0 +1,23 @@
+
+const { error } = require('./ErrorUtility')
+
+function inward(ctx) {
+  if (!ctx.result.ok) {
+    return undefined
+  }
+
+  try {
+    return ctx.op.inward(ctx)
+  }
+  catch (err) {
+    // TDOD: need error codes and err msg text
+    ctx.result.ok = false
+    ctx.result.err = err
+    return error(ctx)
+  }
+}
+
+
+module.exports = {
+  inward
+}

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

@@ -0,0 +1,12 @@
+
+function joinurl(...s) {
+  return s
+    .filter(s=>null!=s&&''!==s)
+    .map(s=>s.replace(/^\/+/,'').replace(/\/+$/,''))
+    .filter(s=>null!=s&&''!==s)
+    .join('/')
+}
+
+module.exports = {
+  joinurl
+}

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

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

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

@@ -0,0 +1,36 @@
+
+
+// NOTE: duplicated in @voxgig/apidef - dedup to @voxgig/util?
+const OPKIND = {
+  create: 'req',
+  update: 'req',
+  remove: 'req',
+  load: 'res',
+  list: 'res',
+}
+
+
+// Ensure standard operation definition.
+function operator(ctx) {
+  const { op } = ctx
+  
+  let out = {
+    name: op.name,
+    kind: OPKIND[op.name],
+    entity: op.entity,
+    path: op.path,
+    params: op.params || [],
+    query: {...op.query} || {},
+    data: {...op.data} || {},
+    state: op.state,
+    inward: op.inward,
+    outward: op.outward,
+  }
+
+  return out
+}
+
+
+module.exports = {
+  operator
+}

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

@@ -0,0 +1,22 @@
+
+const { empty }  = require('./EmptyUtility')
+
+function options(ctx) {
+  let config = ctx.config || {}
+  let copts = config.options || {}
+  
+  let options = { ...(ctx.options||{}) }
+
+  options.base = empty(options.base) ?
+    empty(copts.base) ? 'http://localhost:8000' :
+    copts.base : options.base
+
+  options.prefix = empty(options.prefix) ? '' : options.prefix
+  options.suffix = empty(options.suffix) ? '' : options.suffix
+  
+  return options
+}
+
+module.exports = {
+  options
+}

package/project/generate/tm/js/src/utility/OutwardUtility.js

@@ -0,0 +1,23 @@
+
+const { error } = require('./ErrorUtility')
+
+function outward(ctx) {
+  if (!ctx.result.ok) {
+    return undefined
+  }
+
+  try {
+    return ctx.op.outward(ctx)
+  }
+  catch (err) {
+    // TDOD: need error codes and err msg text
+    ctx.result.ok = false
+    ctx.result.err = err
+    return error(ctx)
+  }
+}
+
+
+module.exports = {
+  outward
+}

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

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

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

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

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

@@ -0,0 +1,17 @@
+
+function resbasic(response, fetchResponse) {
+  response.status = fetchResponse.status
+  response.statusText = fetchResponse.statusText || 'no-status'
+
+  // TODO: use spec!
+  if(400 <= response.status) {
+    response.ok = false
+    response.err = new Error(response.status+': '+response.statusText)
+  }
+  
+  return response
+}
+
+module.exports = {
+  resbasic
+}

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

@@ -0,0 +1,10 @@
+
+async function resbody(response, fetchResponse) {
+  const json = await fetchResponse.json()
+  response.body = json
+  return response
+}
+
+module.exports = {
+  resbody
+}

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

@@ -0,0 +1,11 @@
+
+function resheaders(response, fetchResponse) {
+  out = {}
+  fetchResponse.headers.forEach((v,k)=>out[k]=v)
+  response.headers = out
+  return response
+}
+
+module.exports = {
+  resheaders
+}

package/project/generate/tm/js/src/utility/ResponseUtility.js

@@ -0,0 +1,36 @@
+
+const { resheaders }  = require('./ResheadersUtility')
+const { resbasic }  = require('./ResbasicUtility')
+const { resbody }  = require('./ResbodyUtility')
+
+async function response(ctx) {
+  let { response } = ctx
+  
+  let result = {
+    ok: false,
+    status: -1,
+    statusText: '',
+    headers: {},
+    body: undefined,
+    err: response.err,
+  }
+
+  try {
+    result = resbasic(result, response)
+    result = resheaders(result, response)
+    result = await resbody(result, response)
+    
+    if(null == result.err) {
+      result.ok = true
+    }
+  }
+  catch(err) {
+    result.err = err
+  }
+  
+  return result
+}
+
+module.exports = {
+  response
+}

package/project/generate/tm/js/src/utility/SpecUtility.js

@@ -0,0 +1,41 @@
+
+const { method }  = require('./MethodUtility')
+const { params }  = require('./ParamsUtility')
+const { query }  = require('./QueryUtility')
+const { headers }  = require('./HeadersUtility')
+const { body }  = require('./BodyUtility')
+const { auth }  = require('./AuthUtility')
+
+// Create request specificaton.
+function spec(ctx) {
+  const {client, op} = ctx
+  
+  let options = client.options()
+
+  const reqMethod = method(ctx)
+  const reqParams = params(ctx)
+  const reqQuery = query(ctx)
+  const reqHeaders = headers(ctx)
+  const reqBody = body(ctx)
+
+  let spec = {
+    base: options.base, // string, URL endpoint base prefix,
+    prefix: options.prefix,
+    path: op.path,
+    suffix: options.suffix,
+    method: reqMethod,
+    params: reqParams,
+    query: reqQuery,
+    headers: reqHeaders,
+    body: reqBody,
+  }
+
+  spec = auth(ctx, spec)
+  
+  return spec
+}
+
+
+module.exports = {
+  spec
+}

package/project/generate/tm/js/src/utility/Utility.js

@@ -0,0 +1,55 @@
+
+const { auth } = require('./AuthUtility')
+const { body } = require('./BodyUtility')
+const { empty } = require('./EmptyUtility')
+const { error } = require('./ErrorUtility')
+const { escre } = require('./EscreUtility')
+const { escurl } = require('./EscurlUtility')
+const { fetch } = require('./FetchUtility')
+const { fullurl } = require('./FullurlUtility')
+const { headers } = require('./HeadersUtility')
+const { inward } = require('./InwardUtility')
+const { joinurl } = require('./JoinurlUtility')
+const { method } = require('./MethodUtility')
+const { operator } = require('./OperatorUtility')
+const { options } = require('./OptionsUtility')
+const { outward } = require('./outwardUtility')
+const { params } = require('./ParamsUtility')
+const { query } = require('./QueryUtility')
+const { resbasic } = require('./ResbasicUtility')
+const { resbody } = require('./ResbodyUtility')
+const { resheaders } = require('./ResheadersUtility')
+const { response } = require('./ResponseUtility')
+const { spec } = require('./SpecUtility')
+
+
+const Utility = {
+  auth,
+  body,
+  empty,
+  error,
+  escre,
+  escurl,
+  fetch,
+  fullurl,
+  headers,
+  inward,
+  joinurl,
+  method,
+  operator,
+  options,
+  outward,
+  params,
+  query,
+  resbasic,
+  resbody,
+  resheaders,
+  response,
+  spec,
+}
+
+
+module.exports = {
+  Utility
+}
+