@voxgig/sdkgen 0.36.0 → 0.38.1

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

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

@@ -0,0 +1,55 @@
+
+const { Result } = require('../Result')
+
+const { clean } = require('./CleanUtility')
+const { clone, delprop } = require('./StructUtility')
+
+function makeError(ctx, err) {
+
+  ctx = ctx || {}
+  const op = ctx.op || {}
+  op.name = op.name || 'unknown operation'
+
+  const result = ctx.result || new Result({})
+  result.ok = false
+
+  const reserr = result.err
+
+  err = undefined === err ? reserr : err
+  err = err || ctx.error('unknown', 'unknown error')
+
+  const errmsg = err.message || 'unknown error'
+  const msg = 'ProjectNameSDK: ' + op.name + ': ' + errmsg
+  err.message = clean(ctx, msg)
+
+  if (result.err) {
+    delprop(result, 'err')
+  }
+
+  const spec = ctx.spec || {}
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.err = {
+      ...clone({ err }).err,
+      message: err.message,
+      stack: err.stack,
+    }
+  }
+
+  err.result = clean(ctx, result)
+  err.spec = clean(ctx, spec)
+
+  ctx.ctrl.err = err
+
+  // TODO: model option to return instead
+  if (false === ctx.ctrl.throw) {
+    return result.resdata
+  }
+  else {
+    throw err
+  }
+}
+
+module.exports = {
+  makeError
+}

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

@@ -0,0 +1,44 @@
+
+const { Result } = require('../Result')
+
+function makeFetchDef(ctx) {
+  const spec = ctx.spec
+  const utility = ctx.utility
+  const makeUrl = utility.makeUrl
+  const struct = utility.struct
+  const jsonify = struct.jsonify
+
+  if (null == spec) {
+    return ctx.error('fetchdef_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  if (null == ctx.result) {
+    ctx.result = new Result({})
+  }
+
+  spec.step = 'prepare'
+
+  const url = makeUrl(ctx)
+  if (url instanceof Error) {
+    return url
+  }
+
+  spec.url = url
+
+  const fetchdef = {
+    url,
+    method: spec.method,
+    headers: spec.headers,
+  }
+
+  if (null != spec.body) {
+    fetchdef.body =
+      'object' === typeof spec.body ? jsonify(spec.body) : spec.body
+  }
+
+  return fetchdef
+}
+
+module.exports = {
+  makeFetchDef
+}

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

@@ -0,0 +1,93 @@
+
+function makeOptions(ctx) {
+  const utility = ctx.utility
+  const options = ctx.options
+  const struct = utility.struct
+  const items = struct.items
+  const setprop = struct.setprop
+  const merge = struct.merge
+  const validate = struct.validate
+  const escre = struct.escre
+
+  let opts = { ...(options || {}) }
+
+  const customUtils = opts.utility || {}
+  for (let [key, val] of items(customUtils)) {
+    setprop(utility, key, val)
+  }
+
+  let config = ctx.config || {}
+  let cfgopts = config.options || {}
+
+  // Standard SDK option values.
+  const optspec = {
+    apikey: '',
+    base: 'http://localhost:8000',
+    prefix: '',
+    suffix: '',
+    auth: {
+      prefix: ''
+    },
+    headers: {
+      '`$CHILD`': '`$STRING`'
+    },
+    allow: {
+      method: 'GET,PUT,POST,PATCH,DELETE,OPTIONS',
+      op: 'create,update,load,list,remove,command,direct'
+    },
+    entity: {
+      '`$CHILD`': {
+        '`$OPEN`': true,
+        active: false,
+        alias: {}
+      }
+    },
+    feature: {
+      '`$CHILD`': {
+        '`$OPEN`': true,
+        active: false,
+      }
+    },
+    utility: {},
+    system: {
+      fetch: undefined
+    },
+    test: {
+      active: false,
+      entity: {
+        '`$OPEN`': true,
+      }
+    },
+    clean: {
+      keys: 'key,token,id'
+    }
+  }
+
+  // JavaScript specific option values.
+  optspec.system.fetch = opts.system?.fetch || global.fetch
+
+  opts = merge([{}, cfgopts, opts])
+
+  opts = validate(opts, optspec)
+
+  opts.__derived__ = {
+    clean: {
+      keyre: undefined
+    }
+  }
+
+  const keyre = opts.clean.keys
+    .split(/\s*,\s*/)
+    .filter((s) => null != s && '' !== s)
+    .map((key) => escre(key)).join('|')
+
+  if ('' != keyre) {
+    opts.__derived__.clean.keyre = keyre
+  }
+
+  return opts
+}
+
+module.exports = {
+  makeOptions
+}

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

@@ -0,0 +1,77 @@
+
+function makePoint(ctx) {
+  if (ctx.out.point) {
+    return ctx.point = ctx.out.point
+  }
+
+  const getprop = ctx.utility.struct.getprop
+  const op = ctx.op
+  const options = ctx.options
+
+  if (!options.allow.op.includes(op.name)) {
+    return ctx.error('point_op_allow', 'Operation "' + op.name +
+      '" not allowed by SDK option allow.op value: "' + options.allow.op + '"')
+  }
+
+  if (0 === op.points.length) {
+    return ctx.error('point_no_points',
+      'Operation "' + op.name + '" has no endpoint definitions.')
+  }
+
+  // Choose the appropriate point based on the match or data.
+  if (1 === op.points.length) {
+    ctx.point = op.points[0]
+  }
+  else {
+    // Operation argument has priority, but also look in current data or match.
+    const reqselector = getprop(ctx, 'req' + op.input)
+    const selector = getprop(ctx, op.input)
+
+    let point
+    for (let i = 0; i < op.points.length; i++) {
+      point = op.points[i]
+      const select = point.select
+      let found = true
+
+      if (selector && select.exist) {
+        for (let j = 0; j < select.exist.length; j++) {
+          const existkey = select.exist[j]
+
+          if (
+            undefined === getprop(reqselector, existkey)
+            && undefined === getprop(selector, existkey)
+          ) {
+            found = false
+            break
+          }
+        }
+      }
+
+      // Action is only in operation argument.
+      if (found && reqselector.$action !== select.$action) {
+        found = false
+      }
+
+      if (found) {
+        break
+      }
+    }
+
+    if (
+      null != reqselector.$action &&
+      null != point &&
+      reqselector.$action !== point.select.$action
+    ) {
+      return ctx.error('point_action_invalid', 'Operation "' + op.name +
+        '" action "' + reqselector.$action + '" is not valid.')
+    }
+
+    ctx.point = point
+  }
+
+  return ctx.point
+}
+
+module.exports = {
+  makePoint,
+}

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

@@ -0,0 +1,63 @@
+
+const { Response } = require('../Response')
+const { Result } = require('../Result')
+
+async function makeRequest(ctx) {
+  // PreRequest feature hook has already provided a result.
+  if (ctx.out.request) {
+    return ctx.out.request
+  }
+
+  const spec = ctx.spec
+  const utility = ctx.utility
+  const fetcher = utility.fetcher
+  const makeFetchDef = utility.makeFetchDef
+
+  let response = new Response({})
+
+  let result = new Result({})
+
+  ctx.result = result
+
+  if (null == spec) {
+    return ctx.error('request_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  try {
+    const fetchdef = makeFetchDef(ctx)
+    if (fetchdef instanceof Error) {
+      throw fetchdef
+    }
+
+    if (ctx.ctrl.explain) {
+      ctx.ctrl.explain.fetchdef = fetchdef
+    }
+
+    spec.step = 'prerequest'
+
+    const fetched = await fetcher(ctx, fetchdef.url, fetchdef)
+
+    if (null == fetched) {
+      response = new Response({ err: ctx.error('request_no_response', 'response: undefined') })
+    }
+    else if (fetched instanceof Error) {
+      response = new Response({ err: fetched })
+    }
+    else {
+      response = new Response(fetched)
+    }
+  }
+  catch (err) {
+    response.err = err
+  }
+
+  spec.step = 'postrequest'
+
+  ctx.response = response
+
+  return response
+}
+
+module.exports = {
+  makeRequest
+}

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

@@ -0,0 +1,55 @@
+
+async function makeResponse(ctx) {
+  // PreResponse feature hook has already provided a result.
+  if (ctx.out.response) {
+    return ctx.out.response
+  }
+
+  const utility = ctx.utility
+  const resultBasic = utility.resultBasic
+  const resultHeaders = utility.resultHeaders
+  const resultBody = utility.resultBody
+  const transformResponse = utility.transformResponse
+
+  const spec = ctx.spec
+  const result = ctx.result
+  const response = ctx.response
+
+  if (null == spec) {
+    return ctx.error('response_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  if (null == response) {
+    return ctx.error('response_no_response', 'Expected context response property to be defined.')
+  }
+
+  if (null == result) {
+    return ctx.error('response_no_result', 'Expected context result property to be defined.')
+  }
+
+  spec.step = 'response'
+
+  try {
+    resultBasic(ctx)
+    resultHeaders(ctx)
+    await resultBody(ctx)
+    transformResponse(ctx)
+
+    if (null == result.err) {
+      result.ok = true
+    }
+  }
+  catch (err) {
+    result.err = err
+  }
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.result = result
+  }
+
+  return response
+}
+
+module.exports = {
+  makeResponse
+}

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

@@ -0,0 +1,54 @@
+
+const { Result } = require('../Result')
+
+function makeResult(ctx) {
+  // PreResult feature hook has already provided a result.
+  if (ctx.out.result) {
+    return ctx.out.result
+  }
+
+  const utility = ctx.utility
+  const transformResponse = utility.transformResponse
+
+  const op = ctx.op
+  const entity = ctx.entity
+
+  const spec = ctx.spec
+  const result = ctx.result
+
+  if (null == spec) {
+    return ctx.error('result_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  if (null == result) {
+    return ctx.error('result_no_result', 'Expected context result property to be defined.')
+  }
+
+  spec.step = 'result'
+
+  transformResponse(ctx)
+
+  if ('list' == op.name) {
+    const resdata = result.resdata
+    result.resdata = []
+
+    if (null != resdata && 0 < resdata.length) {
+      for (let entry of resdata) {
+        const ent = entity.make()
+        ent.data(entry)
+        result.resdata.push(ent)
+      }
+    }
+  }
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.result = result
+  }
+
+  // NOTE: returns processesd result.
+  return result
+}
+
+module.exports = {
+  makeResult
+}

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

@@ -0,0 +1,58 @@
+
+const { Spec } = require('../Spec')
+
+// Create request specificaton.
+function makeSpec(ctx) {
+  if (ctx.out.spec) {
+    return ctx.spec = ctx.out.spec
+  }
+
+  const point = ctx.point
+  const options = ctx.options
+  const utility = ctx.utility
+
+  const prepareMethod = utility.prepareMethod
+  const prepareParams = utility.prepareParams
+  const prepareQuery = utility.prepareQuery
+  const prepareHeaders = utility.prepareHeaders
+  const prepareBody = utility.prepareBody
+  const preparePath = utility.preparePath
+  const prepareAuth = utility.prepareAuth
+
+  ctx.spec = new Spec({
+    base: options.base,
+    prefix: options.prefix,
+    parts: point.parts,
+    suffix: options.suffix,
+    step: 'start',
+  })
+
+  ctx.spec.method = prepareMethod(ctx)
+
+  if (!options.allow.method.includes(ctx.spec.method)) {
+    return ctx.error('spec_method_allow', 'Method "' + ctx.spec.method +
+      '" not allowed by SDK option allow.method value: "' + options.allow.method + '"')
+  }
+
+  ctx.spec.params = prepareParams(ctx)
+  ctx.spec.query = prepareQuery(ctx)
+  ctx.spec.headers = prepareHeaders(ctx)
+  ctx.spec.body = prepareBody(ctx)
+  ctx.spec.path = preparePath(ctx)
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.spec = ctx.spec
+  }
+
+  const spec = prepareAuth(ctx)
+
+  if (!(spec instanceof Error)) {
+    ctx.spec = spec
+  }
+
+  return spec
+}
+
+module.exports = {
+  makeSpec
+}