@voxgig/sdkgen 0.25.0 → 0.28.0

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

@@ -0,0 +1,46 @@
+
+import { Context, Result } from '../types'
+
+
+function makeFetchDef(ctx: Context): any | Error {
+  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: any = {
+    url,
+    method: spec.method,
+    headers: spec.headers,
+  }
+
+  if (null != spec.body) {
+    fetchdef.body =
+      'object' === typeof spec.body ? jsonify(spec.body) : spec.body
+  }
+
+  return fetchdef
+}
+
+
+export {
+  makeFetchDef
+}

package/project/.sdk/tm/ts/src/utility/{OptionsUtility.ts → MakeOptionsUtility.ts}

@@ -2,20 +2,23 @@
 import { Context } from '../types'
 
 
-function options(ctx: Context) {
-  const { options, utility } = ctx
+function makeOptions(ctx: Context) {
+  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 of Object.keys(customUtils)) {
-    setprop(utility, key, customUtils[key])
+  for (let [key, val] of items(customUtils)) {
+    setprop(utility, key, val)
   }
 
-  const { merge, validate } = utility.struct
-
   let config = ctx.config || {}
   let cfgopts = config.options || {}
 
@@ -31,6 +34,10 @@ function options(ctx: Context) {
     headers: {
       '`$CHILD`': '`$STRING`'
     },
+    allow: {
+      method: 'GET,PUT,POST,PATCH,DELETE,OPTIONS',
+      op: 'create,update,load,list,remove,command,direct'
+    },
     entity: {
       '`$CHILD`': {
         '`$OPEN`': true,
@@ -53,6 +60,9 @@ function options(ctx: Context) {
       entity: {
         '`$OPEN`': true,
       }
+    },
+    clean: {
+      keys: 'key,token,id'
     }
   }
 
@@ -63,10 +73,25 @@ function options(ctx: Context) {
 
   opts = validate(opts, optspec)
 
+  opts.__derived__ = {
+    clean: {
+      keyre: undefined
+    }
+  }
+
+  const keyre = opts.clean.keys
+    .split(/\s*,\s*/)
+    .filter((s: string) => null != s && '' !== s)
+    .map((key: string) => escre(key)).join('|')
+
+  if ('' != keyre) {
+    opts.__derived__.clean.keyre = keyre
+  }
+
   return opts
 }
 
 
 export {
-  options
+  makeOptions
 }

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

@@ -0,0 +1,66 @@
+
+import { Context, Response, Result } from '../types'
+
+
+async function makeRequest(ctx: Context): Promise<Response | Error> {
+  // 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'
+
+    // TODO: see js code, use `native` prop here
+    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 as Error
+  }
+
+  spec.step = 'postrequest'
+
+  ctx.response = response
+
+  return response
+}
+
+
+export {
+  makeRequest
+}

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

@@ -0,0 +1,61 @@
+
+import { Context, Response } from '../types'
+
+
+async function makeResponse(ctx: Context): Promise<Response | Error> {
+  // 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
+}
+
+
+export {
+  makeResponse
+}

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

@@ -0,0 +1,56 @@
+
+import { Result, Context } from '../types'
+
+
+function makeResult(ctx: Context): Result | Error {
+  // 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
+}
+
+
+export {
+  makeResult
+}

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

@@ -0,0 +1,61 @@
+
+import { Context, Spec } from '../types'
+
+
+// Create request specificaton.
+function makeSpec(ctx: Context): Spec | Error {
+  if (ctx.out.spec) {
+    return ctx.spec = ctx.out.spec
+  }
+
+  const target = ctx.target
+  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, // string, URL endpoint base prefix,
+    prefix: options.prefix,
+    parts: target.parts,
+    suffix: options.suffix,
+    step: 'start',
+  })
+
+  ctx.spec.method = prepareMethod(ctx)
+
+  // TODO: Add string utils to StructUtility
+  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
+}
+
+
+export {
+  makeSpec
+}

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

@@ -0,0 +1,76 @@
+
+import { Context, Target } from '../types'
+
+
+function makeTarget(ctx: Context): Target | Error {
+  if (ctx.out.target) {
+    return ctx.target = ctx.out.target
+  }
+
+  const getprop = ctx.utility.struct.getprop
+  const op = ctx.op
+  const options = ctx.options
+
+  if (!options.allow.op.includes(op.name)) {
+    ctx.error('target_op_allow', 'Operation "' + op.name +
+      '" not allowed by SDK option allow.op value: "' + options.allow.op + '"')
+  }
+
+  // Choose the appropriate operation alternate based on the match or data.
+  if (1 === op.targets.length) {
+    ctx.target = op.targets[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 target
+    for (let i = 0; i < op.targets.length; i++) {
+      target = op.targets[i]
+      const select = target.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 != target &&
+      reqselector.$action !== target.select.$action
+    ) {
+      return ctx.error('target_action_invalid', 'Operation "' + op.name +
+        '" action "' + reqselector.$action + '" is not valid.')
+    }
+
+    ctx.target = target
+  }
+
+  return ctx.target
+}
+
+
+export {
+  makeTarget,
+}

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

@@ -0,0 +1,61 @@
+
+import { Context } from '../types'
+
+
+function makeUrl(ctx: Context): Error | string {
+  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.')
+  }
+
+
+  // TODO: use parts to avoid regexp?
+  let url = join([spec.base, spec.prefix, spec.path, spec.suffix], '/', true)
+  let resmatch: Record<string, any> = {}
+
+  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
+    }
+  }
+
+
+  /* TODO: fix
+  let qsep = '?'
+  for (let [key, val] of items(spec.query)) {
+    if (null == spec.alias[key]) {
+      if (null != val) {
+        url += qsep + escurl(key) + '=' + escurl(val)
+        qsep = '&'
+        resmatch[key] = val
+      }
+    }
+  }
+  */
+
+  result.resmatch = resmatch
+
+  return url
+}
+
+
+export {
+  makeUrl
+}

package/project/.sdk/tm/ts/src/utility/{FindparamUtility.ts → ParamUtility.ts}

@@ -1,9 +1,6 @@
 
 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
@@ -11,10 +8,30 @@ import { getprop } from './StructUtility'
  *
  * This function returns `undefined` rather than failing.
  */
-function findparam(ctx: Context, key: string) {
-  let { op, spec, match, reqmatch, data, reqdata } = ctx
+function param(ctx: Context, paramdef: any) {
+  const target = ctx.target
+  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
 
-  let akey = op.alias[key]
+  const pt = typify(paramdef)
+
+  // TODO: review this search algorithm
+
+  const key = 0 < (T_string & pt) ? paramdef : getprop(paramdef, 'name')
+
+  let akey = getprop(target.alias, key)
 
   let val = getprop(reqmatch, key)
 
@@ -23,7 +40,10 @@ function findparam(ctx: Context, key: string) {
   }
 
   if (null == val && null != akey) {
-    spec.alias[akey] = key
+
+    if (null != spec) {
+      setprop(spec.alias, akey, key)
+    }
 
     val = getprop(reqmatch, akey)
   }
@@ -49,6 +69,6 @@ function findparam(ctx: Context, key: string) {
 
 
 export {
-  findparam
+  param
 }
 

package/project/.sdk/tm/ts/src/utility/{AuthUtility.ts → PrepareAuthUtility.ts}

@@ -1,15 +1,15 @@
 
-import { Context } from '../types'
+import { Context, Spec } from '../types'
 
 
 const HEADER_auth = 'authorization'
 
 const OPTION_apikey = 'apikey'
 
-const NOTFOUND = ''
+const NOTFOUND = '__NOTFOUND__'
 
 
-function auth(ctx: Context) {
+function prepareAuth(ctx: Context): Spec | Error {
   const utility = ctx.utility
 
   const struct = utility.struct
@@ -20,6 +20,12 @@ function auth(ctx: Context) {
   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()
@@ -38,5 +44,5 @@ function auth(ctx: Context) {
 
 
 export {
-  auth
+  prepareAuth
 }

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

@@ -0,0 +1,32 @@
+
+import { Context } from '../types'
+
+function prepareBody(ctx: Context) {
+  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)
+
+      // if (target.check.nobody && null == body) {
+      //   return error(ctx, new Error('Request body is empty.'))
+      // }
+    }
+    catch (err) {
+      return error(ctx, err)
+    }
+  }
+
+  return body
+}
+
+export {
+  prepareBody
+}
+

package/project/.sdk/tm/ts/src/utility/{HeadersUtility.ts → PrepareHeadersUtility.ts}

@@ -2,12 +2,10 @@
 import { Context } from '../types'
 
 
-import { getprop } from './StructUtility'
-
-
-function headers(ctx: Context) {
-  const utility = ctx.utility
-  const clone = utility.struct.clone
+function prepareHeaders(ctx: Context) {
+  const struct = ctx.utility.struct
+  const clone = struct.clone
+  const getprop = struct.getprop
 
   const client = ctx.client
 
@@ -20,5 +18,5 @@ function headers(ctx: Context) {
 
 
 export {
-  headers
+  prepareHeaders
 }

package/project/.sdk/tm/ts/src/utility/{MethodUtility.ts → PrepareMethodUtility.ts}

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