@voxgig/sdkgen 0.24.0 → 0.26.1

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

@@ -3,15 +3,15 @@ import { Context } from '../types'
 
 
 function options(ctx: Context) {
-  const { options, utility } = ctx
+  const utility = ctx.utility
+  const options = ctx.options
   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])
+    struct.setprop(utility, key, customUtils[key])
   }
 
   const { merge, validate } = utility.struct
@@ -31,6 +31,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 +57,9 @@ function options(ctx: Context) {
       entity: {
         '`$OPEN`': true,
       }
+    },
+    clean: {
+      keys: 'key,token,id'
     }
   }
 
@@ -63,6 +70,21 @@ 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) => struct.escre(key)).join('|')
+
+  if ('' != keyre) {
+    opts.__derived__.clean.keyre = keyre
+  }
+
   return opts
 }
 

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

@@ -6,26 +6,26 @@ function params(ctx: Context) {
   const utility = ctx.utility
   const findparam = utility.findparam
 
-  const struct = utility.struct
-  const { validate } = struct
+  // const struct = utility.struct
+  // const { validate } = struct
 
+  const alt = ctx.alt
 
-  const { op } = ctx
+  let param = alt.args.param
+  let reqmatch = ctx.reqmatch
 
-  let { params } = op
-  let { reqmatch } = ctx
-
-  params = params || []
+  param = param || []
   reqmatch = reqmatch || {}
 
   let out: any = {}
-  for (let key of params) {
-    let val = findparam(ctx, key)
+  for (let pd of param) {
+    let val = findparam(ctx, pd)
     if (null != val) {
-      out[key] = val
+      out[pd.name] = val
     }
   }
 
+  // TODO: review
   // out = validate(out, op.validate.params)
 
   return out

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

@@ -0,0 +1,18 @@
+
+import { Context } from '../types'
+
+import { join } from './StructUtility'
+
+
+function preparePath(ctx: Context) {
+  const { alt } = ctx
+
+  const path = join(alt.parts, '/', true)
+
+  return path
+}
+
+
+export {
+  preparePath
+}

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

@@ -3,8 +3,8 @@ import { Context } from '../types'
 
 
 function query(ctx: Context) {
-  const { op } = ctx
-  let { params } = op
+  const { alt } = ctx
+  let { params } = alt
   let { reqmatch } = ctx
 
   params = params || []

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

@@ -6,7 +6,7 @@ import { Context } from '../types'
  * The operation (op) property `reqform` is used to perform the data preparation.
  */
 function reqform(ctx: Context) {
-  const { spec, utility } = ctx
+  const { spec, utility, alt } = ctx
   const { struct, error } = utility
   const { isfunc, transform } = struct
 
@@ -15,7 +15,7 @@ function reqform(ctx: Context) {
   }
 
   try {
-    const reqform = ctx.op.reqform
+    const reqform = alt.transform.req
     const reqdata = isfunc(reqform) ? reqform(ctx) : transform({
       reqdata: ctx.reqdata
     }, reqform)

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

@@ -1,8 +1,13 @@
 
-import { Context } from '../types'
+import { Context, Response } from '../types'
 
 
-async function request(ctx: Context) {
+async function request(ctx: Context): Promise<Response | Error> {
+  // PreRequest feature hook has already provided a result.
+  if (ctx.out.request) {
+    return ctx.out.request
+  }
+
   const { spec, utility } = ctx
   const { fullurl, fetcher } = utility
 
@@ -19,11 +24,20 @@ async function request(ctx: Context) {
 
   ctx.result = result
 
+  if (null == spec) {
+    return new Error('Expected context spec property to be defined.')
+  }
+
 
   try {
     spec.step = 'prepare'
 
-    const url = spec.url = fullurl(ctx)
+    const url = fullurl(ctx)
+    if (url instanceof Error) {
+      throw url
+    }
+
+    spec.url = url
 
     const fetchdef: any = {
       method: spec.method,
@@ -47,6 +61,9 @@ async function request(ctx: Context) {
     if (null == response) {
       response = { err: new Error('response: undefined') }
     }
+    else if (response instanceof Error) {
+      response = { err: response }
+    }
   }
   catch (err) {
     response = response || {}

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

@@ -5,7 +5,7 @@ import { Context } from '../types'
 function resbasic(ctx: Context) {
   const { response, result } = ctx
 
-  if (null != response) {
+  if (null != result && null != response) {
     result.status = response.status || -1
     result.statusText = response.statusText || 'no-status'
 

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

@@ -5,9 +5,11 @@ import { Context } from '../types'
 async function resbody(ctx: Context) {
   const { response, result } = ctx
 
-  if (response && response.json) {
-    const json = await response.json()
-    result.body = json
+  if (result) {
+    if (response && response.json && null != response.body) {
+      const json = await response.json()
+      result.body = json
+    }
   }
 
   return result

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

@@ -7,7 +7,7 @@ import { Context } from '../types'
  * The operation (op) property `resform` is used to perform the data extraction.
  */
 function resform(ctx: Context) {
-  const { spec, result, utility } = ctx
+  const { spec, result, utility, alt } = ctx
   const { struct, error } = utility
   const { isfunc, transform } = struct
 
@@ -15,12 +15,12 @@ function resform(ctx: Context) {
     spec.step = 'resform'
   }
 
-  if (!result.ok) {
+  if (null == result || !result.ok) {
     return undefined
   }
 
   try {
-    const resform = ctx.op.resform
+    const resform = alt.transform.res
     const resdata = isfunc(resform) ? resform(ctx) : transform(ctx.result, resform)
     result.resdata = resdata
     return resdata

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

@@ -5,13 +5,15 @@ import { Context } from '../types'
 function resheaders(ctx: Context) {
   const { response, result } = ctx
 
-  if (response && response.headers && response.headers.forEach) {
-    const headers: any = {}
-    response.headers.forEach((v: any, k: any) => headers[k] = v)
-    result.headers = headers
-  }
-  else {
-    result.headers = {}
+  if (result) {
+    if (response && response.headers && response.headers.forEach) {
+      const headers: any = {}
+      response.headers.forEach((v: any, k: any) => headers[k] = v)
+      result.headers = headers
+    }
+    else {
+      result.headers = {}
+    }
   }
 
   return result

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

@@ -1,11 +1,36 @@
 
-import { Context } from '../types'
+import { Context, Response } from '../types'
 
 
-async function response(ctx: Context) {
-  let { result, spec, utility } = ctx
+async function response(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 resbasic = utility.resbasic
+  const resheaders = utility.resheaders
+  const resbody = utility.resbody
+  const resform = utility.resform
+
+  const spec = ctx.spec
+  const result = ctx.result
+  const response = ctx.response
+
+
+  if (null == spec) {
+    return new Error('Expected context spec property to be defined.')
+  }
+
+  if (null == response) {
+    return new Error('Expected context response property to be defined.')
+  }
+
+  if (null == result) {
+    return new Error('Expected context result property to be defined.')
+  }
 
-  const { resheaders, resbasic, resbody, resform } = utility
 
   spec.step = 'response'
 
@@ -22,6 +47,12 @@ async function response(ctx: Context) {
   catch (err) {
     result.err = err
   }
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.result = result
+  }
+
+  return response
 }
 
 

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

@@ -1,11 +1,29 @@
 
-import { Context } from '../types'
+import { Result, Context } from '../types'
 
 
-async function result(ctx: Context) {
-  let { op, spec, utility, entity, result } = ctx
+function result(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 resform = utility.resform
+
+  const op = ctx.op
+  const entity = ctx.entity
+
+  const spec = ctx.spec
+  const result = ctx.result
 
-  const { resform } = utility
+  if (null == spec) {
+    return new Error('Expected context spec property to be defined.')
+  }
+
+  if (null == result) {
+    return new Error('Expected context result property to be defined.')
+  }
 
   spec.step = 'result'
 
@@ -28,6 +46,8 @@ async function result(ctx: Context) {
     ctx.ctrl.explain.result = result
   }
 
+  // NOTE: returns processesd result.
+  return result
 }
 
 

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

@@ -0,0 +1,78 @@
+
+import { Context, Alt } from '../types'
+
+import { getprop } from './StructUtility'
+
+
+// Ensure standard operation definition.
+// TODO: rename to alt
+function selection(ctx: Context): Alt | Error {
+  if (ctx.out.selected) {
+    return ctx.alt = ctx.out.selected
+  }
+
+  const { op, options } = ctx
+
+  if (!options.allow.op.includes(op.name)) {
+    return Error('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.alts.length) {
+    ctx.alt = op.alts[0]
+  }
+  else {
+    // Operation argument has priority, but also look in current data or match.
+    const reqselector = getprop(ctx, 'req' + op.select)
+    const selector = getprop(ctx, op.select)
+
+    let alt
+    for (let i = 0; i < op.alts.length; i++) {
+      alt = op.alts[i]
+      const select = alt.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 != alt &&
+      reqselector.$action !== alt.select.$action
+    ) {
+      return Error('Operation "' + op.name +
+        '" action "' + reqselector.$action + '" is not valid.')
+    }
+
+    ctx.alt = alt
+  }
+
+  return ctx.alt
+}
+
+
+export {
+  selection,
+}

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

@@ -1,23 +1,33 @@
 
-import { Context } from '../types'
+import { Context, Spec } from '../types'
 
 
 // Create request specificaton.
-function spec(ctx: Context) {
-  const { client, op, utility } = ctx
-  const struct = utility.struct
-  const size = struct.size
-  const select = struct.select
-  const { method, params, query, headers, body, auth } = utility
+function spec(ctx: Context): Spec | Error {
+  if (ctx.out.spec) {
+    return ctx.spec = ctx.out.spec
+  }
+
+  const alt = ctx.alt
+  const options = ctx.options
+  const utility = ctx.utility
 
-  let options = client.options()
+  const method = utility.method
+  const params = utility.params
+  const query = utility.query
+  const headers = utility.headers
+  const body = utility.body
+  // TODO: rename others to prepareNAME
+  const preparePath = utility.preparePath
+  const auth = utility.auth
 
   ctx.spec = {
     base: options.base, // string, URL endpoint base prefix,
     prefix: options.prefix,
-    path: op.path,
+    // path: op.path,
+    parts: alt.parts,
     suffix: options.suffix,
-    method: 'get',
+    method: 'GET',
     params: {},
     query: {},
     headers: {},
@@ -27,32 +37,29 @@ function spec(ctx: Context) {
   }
 
   ctx.spec.method = method(ctx)
+
+  if (!options.allow.method.includes(ctx.spec.method)) {
+    return Error('Method "' + ctx.spec.method +
+      '" not allowed by SDK option allow.method value: "' + options.allow.method + '"')
+  }
+
   ctx.spec.params = params(ctx)
   ctx.spec.query = query(ctx)
   ctx.spec.headers = headers(ctx)
   ctx.spec.body = body(ctx)
-
-  if (1 < size(op.pathalt)) {
-    let hasQuery = false
-    const paramQuery: any = {}
-    for (let paramName of op.params) {
-      paramQuery[paramName] = null == ctx.spec.params[paramName] ? undefined : true
-      hasQuery = true
-    }
-    if (hasQuery) {
-      const foundParamAlts = select(op.pathalt, paramQuery)
-      console.log('PQ', paramQuery, foundParamAlts)
-      if (0 < size(foundParamAlts)) {
-        ctx.spec.path = foundParamAlts[0].path
-      }
-    }
-  }
+  ctx.spec.path = preparePath(ctx)
 
   if (ctx.ctrl.explain) {
     ctx.ctrl.explain.spec = ctx.spec
   }
 
-  auth(ctx)
+  const spec = auth(ctx)
+
+  if (!(spec instanceof Error)) {
+    ctx.spec = spec
+  }
+
+  return spec
 }