@voxgig/sdkgen 0.36.0 → 0.37.0

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

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

@@ -0,0 +1,40 @@
+
+function makeUrl(ctx) {
+  const utility = ctx.utility
+  const spec = ctx.spec
+  const result = ctx.result
+
+  const struct = utility.struct
+  const escurl = struct.escurl
+  const escre = struct.escre
+  const join = struct.join
+  const items = struct.items
+
+  if (null == spec) {
+    return ctx.error('url_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  if (null == result) {
+    return ctx.error('url_no_result', 'Expected context result property to be defined.')
+  }
+
+  let url = join([spec.base, spec.prefix, spec.path, spec.suffix], '/', true)
+  let resmatch = {}
+
+  const params = spec.params
+
+  for (let [key, val] of items(params)) {
+    if (null != val) {
+      url = url.replace(RegExp('{' + escre(key) + '}'), escurl(val))
+      resmatch[key] = val
+    }
+  }
+
+  result.resmatch = resmatch
+
+  return url
+}
+
+module.exports = {
+  makeUrl
+}

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

@@ -0,0 +1,61 @@
+
+function param(ctx, paramdef) {
+  const point = ctx.point
+  const spec = ctx.spec
+  const match = ctx.match
+  const reqmatch = ctx.reqmatch
+  const data = ctx.data
+  const reqdata = ctx.reqdata
+
+  const utility = ctx.utility
+  const struct = utility.struct
+
+  const getprop = struct.getprop
+  const setprop = struct.setprop
+
+  const typify = struct.typify
+  const T_string = struct.T_string
+
+  const pt = typify(paramdef)
+
+  const key = 0 < (T_string & pt) ? paramdef : getprop(paramdef, 'name')
+
+  let akey = getprop(point.alias, key)
+
+  let val = getprop(reqmatch, key)
+
+  if (null == val) {
+    val = getprop(match, key)
+  }
+
+  if (null == val && null != akey) {
+
+    if (null != spec) {
+      setprop(spec.alias, akey, key)
+    }
+
+    val = getprop(reqmatch, akey)
+  }
+
+  if (null == val) {
+    val = getprop(reqdata, key)
+  }
+
+  if (null == val) {
+    val = getprop(data, key)
+  }
+
+  if (null == val && null != akey) {
+    val = getprop(reqdata, akey)
+
+    if (null == val) {
+      val = getprop(data, akey)
+    }
+  }
+
+  return val
+}
+
+module.exports = {
+  param
+}

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

@@ -0,0 +1,41 @@
+
+const HEADER_auth = 'authorization'
+
+const OPTION_apikey = 'apikey'
+
+const NOTFOUND = '__NOTFOUND__'
+
+function prepareAuth(ctx) {
+  const utility = ctx.utility
+
+  const struct = utility.struct
+  const getprop = struct.getprop
+  const setprop = struct.setprop
+  const delprop = struct.delprop
+
+  const client = ctx.client
+  const spec = ctx.spec
+
+  if (null == spec) {
+    return ctx.error('auth_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  const headers = spec.headers
+
+  const options = client.options()
+
+  const apikey = getprop(options, OPTION_apikey, NOTFOUND)
+
+  if (NOTFOUND === apikey) {
+    delprop(headers, HEADER_auth)
+  }
+  else {
+    setprop(headers, HEADER_auth, options.auth.prefix + ' ' + apikey)
+  }
+
+  return spec
+}
+
+module.exports = {
+  prepareAuth
+}

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

@@ -0,0 +1,25 @@
+
+function prepareBody(ctx) {
+  const op = ctx.op
+
+  const utility = ctx.utility
+  const error = utility.makeError
+  const transformRequest = utility.transformRequest
+
+  let body = undefined
+
+  if ('data' === op.input) {
+    try {
+      body = transformRequest(ctx)
+    }
+    catch (err) {
+      return error(ctx, err)
+    }
+  }
+
+  return body
+}
+
+module.exports = {
+  prepareBody
+}

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

@@ -0,0 +1,18 @@
+
+function prepareHeaders(ctx) {
+  const struct = ctx.utility.struct
+  const clone = struct.clone
+  const getprop = struct.getprop
+
+  const client = ctx.client
+
+  const options = client.options()
+
+  let out = clone(getprop(options, 'headers', {}))
+
+  return out
+}
+
+module.exports = {
+  prepareHeaders
+}