@voxgig/sdkgen 0.22.0 → 0.23.0

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

@@ -0,0 +1,50 @@
+
+import { Context } from '../types'
+
+
+import {
+  walk, getpath, escre, getprop, size, pad, slice, setprop, clone
+} from './StructUtility'
+
+
+// Clean request data by partially hiding sensitive values.
+function clean(ctx: Context, val: any) {
+  const options = ctx.options
+  const work = ctx.work
+
+  let cleaners = getprop(work, 'cleaners')
+
+  if (null == cleaners) {
+    cleaners =
+      [
+        { p: 'apikey', s: 4 }
+      ]
+        .map((p: any) => (p.v = getpath(options, p.p), p))
+        .filter(p => null != p.v && 'string' === typeof p.v)
+        .map(
+          p => (
+            p.re = new RegExp(escre(p.v)),
+            p.v = pad(slice(p.v, 0, p.s), size(p.v), '*'),
+            p
+          )
+        )
+  }
+
+  setprop(work, 'cleaners', cleaners)
+
+  const out = walk(clone(val), (_k: any, v: any) => {
+    if ('string' === typeof v) {
+      cleaners.map((p: any) => {
+        v = v.replace(p.re, p.v)
+      })
+    }
+    return v
+  })
+
+  return out
+}
+
+
+export {
+  clean
+}

package/project/.sdk/tm/ts/src/utility/ContextUtility.ts

@@ -0,0 +1,67 @@
+
+import { getprop } from './StructUtility'
+
+
+function contextify(ctxmap: Record<string, any>, basectx?: Context): any {
+  const ctx = new Context()
+
+  ctx.ctrl = getprop(ctxmap, 'ctrl', getprop(basectx, 'ctrl', {}))
+  ctx.meta = getprop(ctxmap, 'meta', getprop(basectx, 'meta', {}))
+  ctx.work = getprop(ctxmap, 'work', getprop(basectx, 'work', {}))
+
+  ctx.client = getprop(ctxmap, 'client', getprop(basectx, 'client'))
+  ctx.config = getprop(ctxmap, 'config', getprop(basectx, 'config'))
+  ctx.entity = getprop(ctxmap, 'entity', getprop(basectx, 'entity'))
+  ctx.op = getprop(ctxmap, 'op', getprop(basectx, 'op'))
+  ctx.entopts = getprop(ctxmap, 'entopts', getprop(basectx, 'entopts'))
+  ctx.options = getprop(ctxmap, 'options', getprop(basectx, 'options'))
+  ctx.response = getprop(ctxmap, 'response', getprop(basectx, 'response'))
+  ctx.result = getprop(ctxmap, 'result', getprop(basectx, 'result'))
+  ctx.spec = getprop(ctxmap, 'spec', getprop(basectx, 'spec'))
+  ctx.utility = getprop(ctxmap, 'utility', getprop(basectx, 'utility'))
+  ctx.data = getprop(ctxmap, 'data', getprop(basectx, 'data'))
+  ctx.reqdata = getprop(ctxmap, 'reqdata', getprop(basectx, 'reqdata'))
+  ctx.match = getprop(ctxmap, 'match', getprop(basectx, 'match'))
+  ctx.reqmatch = getprop(ctxmap, 'reqmatch', getprop(basectx, 'reqmatch'))
+
+  return ctx
+}
+
+
+class Context {
+
+  ctrl = {}
+  meta = {}
+  work = {}
+
+  client = undefined
+  config = undefined
+  entity = undefined
+  op = undefined
+  entopts = undefined
+  options = undefined
+  response = undefined
+  result = undefined
+  spec = undefined
+  utility = undefined
+  data = undefined
+  reqdata = undefined
+  match = undefined
+  reqmatch = undefined
+
+  toJSON() {
+    return {
+      op: this.op,
+      spec: this.spec,
+      entity: this.entity,
+      result: this.result,
+      meta: this.meta,
+    }
+  }
+}
+
+
+export {
+  contextify,
+  Context
+}

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

@@ -0,0 +1,28 @@
+
+import { Context } from '../types'
+
+
+import { clean } from './CleanUtility'
+
+import { delprop } from './StructUtility'
+
+
+function done(ctx: Context) {
+  const { error } = ctx.utility
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain = clean(ctx, ctx.ctrl.explain)
+    delprop(ctx.ctrl.explain.result, 'err')
+  }
+
+  if (ctx.result.ok) {
+    return ctx.result.resdata
+  }
+
+  return error(ctx)
+}
+
+
+export {
+  done
+}

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

@@ -0,0 +1,59 @@
+
+import { Context } from '../types'
+
+
+import { clean } from './CleanUtility'
+
+import { clone, delprop } from './StructUtility'
+
+
+function error(ctx: Context, err?: any) {
+
+  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 = '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 ctx.result.resdata
+  }
+  else {
+    throw err
+  }
+}
+
+
+export {
+  error
+}

package/project/.sdk/tm/ts/src/utility/FeaturehookUtility.ts

@@ -0,0 +1,26 @@
+
+import { Context, Feature } from '../types'
+
+
+function featurehook(ctx: Context, name: string) {
+  const client = ctx.client
+
+  let resp: Promise<any>[] = []
+  const features: Feature[] = client._features || []
+
+  for (let f of features) {
+    let fres = (f as any)[name](ctx)
+    if (fres instanceof Promise) {
+      resp.push(fres)
+    }
+  }
+
+  if (0 < resp.length) {
+    return Promise.all(resp)
+  }
+}
+
+
+export {
+  featurehook
+}

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

@@ -0,0 +1,17 @@
+
+import { Context } from '../types'
+
+// Make HTTP call using library. Replace this utility for mocking etc.
+async function fetcher(ctx: Context, fullurl: string, fetchdef: Record<string, any>) {
+  const options = ctx.client.options()
+  const fetch = options.system.fetch
+
+  const response = await fetch(fullurl, fetchdef)
+
+  return response
+}
+
+
+export {
+  fetcher
+}

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

@@ -0,0 +1,54 @@
+
+import { Context } from '../types'
+
+import { getprop } from './StructUtility'
+
+
+/* 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: Context, key: string) {
+  let { op, spec, match, reqmatch, data, reqdata } = ctx
+
+  let akey = op.alias[key]
+
+  let val = getprop(reqmatch, key)
+
+  if (null == val) {
+    val = getprop(match, key)
+  }
+
+  if (null == val && null != akey) {
+    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
+}
+
+
+export {
+  findparam
+}
+

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

@@ -0,0 +1,46 @@
+
+import { Context } from '../types'
+
+function fullurl(ctx: Context) {
+  const utility = ctx.utility
+  // const findparam = utility.findparam
+
+  const struct = utility.struct
+  const { escurl, escre, joinurl } = struct
+
+  const { spec, result } = ctx
+
+  let url = joinurl([spec.base, spec.prefix, spec.path, spec.suffix])
+  let resmatch: Record<string, any> = {}
+
+  const params = spec.params
+
+  for (let key in params) {
+    const val = params[key]
+    if (null != val) {
+      url = url.replace(RegExp('{' + escre(key) + '}'), escurl(val))
+      resmatch[key] = 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 = '&'
+        resmatch[key] = val
+      }
+    }
+  }
+
+  result.resmatch = resmatch
+
+  return url
+}
+
+
+export {
+  fullurl
+}

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

@@ -0,0 +1,24 @@
+
+import { Context } from '../types'
+
+
+import { getprop } from './StructUtility'
+
+
+function headers(ctx: Context) {
+  const utility = ctx.utility
+  const clone = utility.struct.clone
+
+  const client = ctx.client
+
+  const options = client.options()
+
+  let out = clone(getprop(options, 'headers', {}))
+
+  return out
+}
+
+
+export {
+  headers
+}

package/project/.sdk/tm/ts/src/utility/InitfeatureUtility.ts

@@ -0,0 +1,13 @@
+
+import { Context, Feature } from '../types'
+
+
+function initfeature(ctx: Context, f: Feature) {
+  const fopts = ctx.options.feature[f.name] || {}
+  f.init(ctx, fopts)
+}
+
+
+export {
+  initfeature
+}

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

@@ -0,0 +1,15 @@
+
+// TODO: MOVE TO STRUCT
+function joinurl(...s: string[]) {
+  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('/')
+}
+
+
+export {
+  joinurl
+}

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

@@ -0,0 +1,25 @@
+
+import { Context } from '../types'
+
+function method(ctx: Context) {
+  const { op } = ctx
+  const opname = op.name
+
+  let key = opname
+
+  // TODO: options
+  const mmap: any = {
+    create: 'POST',
+    update: 'PUT',
+    load: 'GET',
+    list: 'GET',
+    remove: 'DELETE',
+  }
+
+  return mmap[key]
+}
+
+
+export {
+  method
+}

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

@@ -0,0 +1,90 @@
+
+import { Context, Operation } from '../types'
+
+import { getprop } from './StructUtility'
+
+
+const OPKIND: any = {
+  create: 'req',
+  update: 'req',
+  remove: 'req',
+  load: 'res',
+  list: 'res',
+}
+
+
+function opify(opmap: Record<string, any>) {
+
+  const validate = getprop(opmap, 'validate', {})
+
+  const op: Operation = {
+    name: getprop(opmap, 'name', '_'),
+    kind: getprop(opmap, 'kind', '_'),
+    path: getprop(opmap, 'path', '_'),
+    pathalt: getprop(opmap, 'pathalt', []),
+    entity: getprop(opmap, 'entity', '_'),
+    reqform: getprop(opmap, 'reqform', '_'),
+    resform: getprop(opmap, 'resform', '_'),
+    validate: {
+      params: getprop(validate, 'params', { '`$OPEN`': true }),
+    },
+
+    params: getprop(opmap, 'params', []),
+    alias: getprop(opmap, 'alias', {}),
+    state: getprop(opmap, 'state', {}),
+    check: getprop(opmap, 'check', {}),
+  }
+
+  return op
+}
+
+
+// Ensure standard operation definition.
+function operator(ctx: Context): Operation {
+  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`', '`$ARRAY`', '`$FUNCTION`'],
+    resform: ['`$ONE`', '`$STRING`', '`$OBJECT`', '`$ARRAY`', '`$FUNCTION`'],
+    validate: {
+      params: '`$OBJECT`'
+    },
+
+    // Optional.
+    pathalt: ['`$CHILD`', {
+      path: '`$STRING`',
+      '`$OPEN`': true,
+      // '`$CHILD`': '`$BOOLEAN`'
+    }],
+    params: ['`$CHILD`', '`$STRING`'],
+    alias: { '`$CHILD`': '`$STRING`' },
+    state: {},
+    check: {},
+  }
+
+  ctx.op.kind = OPKIND[op.name]
+
+  const opv = ctx.op.validate
+  ctx.op = validate(ctx.op, opspec)
+
+  ctx.op.validate = opv
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.op = ctx.op
+  }
+
+  return ctx.op
+}
+
+
+export {
+  opify,
+  operator,
+}

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

@@ -0,0 +1,72 @@
+
+import { Context } from '../types'
+
+
+function options(ctx: Context) {
+  const { options, utility } = ctx
+  const struct = utility.struct
+  const setprop = struct.setprop
+
+  let opts = { ...(options || {}) }
+
+  const customUtils = opts.utility || {}
+  for (let key of Object.keys(customUtils)) {
+    setprop(utility, key, customUtils[key])
+  }
+
+  const { 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: '',
+    auth: {
+      prefix: ''
+    },
+    headers: {
+      '`$CHILD`': '`$STRING`'
+    },
+    entity: {
+      '`$CHILD`': {
+        '`$OPEN`': true,
+        active: false,
+        alias: {}
+      }
+    },
+    feature: {
+      '`$CHILD`': {
+        '`$OPEN`': true,
+        active: false,
+      }
+    },
+    utility: {},
+    system: {
+      fetch: undefined as any
+    },
+    test: {
+      active: false,
+      entity: {
+        '`$OPEN`': true,
+      }
+    }
+  }
+
+  // JavaScript specific option values.
+  optspec.system.fetch = opts.system?.fetch || global.fetch
+
+  opts = merge([{}, cfgopts, opts])
+
+  opts = validate(opts, optspec)
+
+  return opts
+}
+
+
+export {
+  options
+}

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

@@ -0,0 +1,37 @@
+
+import { Context } from '../types'
+
+
+function params(ctx: Context) {
+  const utility = ctx.utility
+  const findparam = utility.findparam
+
+  const struct = utility.struct
+  const { validate } = struct
+
+
+  const { op } = ctx
+
+  let { params } = op
+  let { reqmatch } = ctx
+
+  params = params || []
+  reqmatch = reqmatch || {}
+
+  let out: any = {}
+  for (let key of params) {
+    let val = findparam(ctx, key)
+    if (null != val) {
+      out[key] = val
+    }
+  }
+
+  // out = validate(out, op.validate.params)
+
+  return out
+}
+
+
+export {
+  params
+}

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

@@ -0,0 +1,27 @@
+
+import { Context } from '../types'
+
+
+function query(ctx: Context) {
+  const { op } = ctx
+  let { params } = op
+  let { reqmatch } = ctx
+
+  params = params || []
+  reqmatch = reqmatch || {}
+
+  const out: any = {}
+  for (let key of Object.keys(reqmatch)) {
+    let val = reqmatch[key]
+    if (null != val && !params.includes(key)) {
+      out[key] = val
+    }
+  }
+
+  return out
+}
+
+
+export {
+  query
+}

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

@@ -0,0 +1,33 @@
+
+import { Context } from '../types'
+
+/* 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: Context) {
+  const { spec, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+
+  if (spec) {
+    spec.step = 'reqform'
+  }
+
+  try {
+    const reqform = ctx.op.reqform
+    const reqdata = isfunc(reqform) ? reqform(ctx) : transform({
+      reqdata: ctx.reqdata
+    }, reqform)
+
+    return reqdata
+  }
+  catch (err) {
+    return error(ctx, err)
+  }
+}
+
+
+export {
+  reqform
+}