@voxgig/sdkgen 0.22.0 → 0.23.0

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

@@ -0,0 +1,66 @@
+
+import { Context } from '../types'
+
+
+async function request(ctx: Context) {
+  const { spec, utility } = ctx
+  const { fullurl, fetcher } = utility
+
+  let response: any = {}
+
+  let result = {
+    ok: false,
+    status: -1,
+    statusText: '',
+    headers: {},
+    body: undefined,
+    err: undefined,
+  }
+
+  ctx.result = result
+
+
+  try {
+    spec.step = 'prepare'
+
+    const url = spec.url = fullurl(ctx)
+
+    const fetchdef: any = {
+      method: spec.method,
+      headers: spec.headers,
+    }
+
+    if (null != spec.body) {
+      fetchdef.body =
+        'object' === typeof spec.body ? JSON.stringify(spec.body) : spec.body
+    }
+
+    if (ctx.ctrl.explain) {
+      ctx.ctrl.explain.fetchdef = fetchdef
+    }
+
+    spec.step = 'prerequest'
+
+    // TODO: see js code, use `native` prop here
+    response = await fetcher(ctx, url, fetchdef)
+
+    if (null == response) {
+      response = { err: new Error('response: undefined') }
+    }
+  }
+  catch (err) {
+    response = response || {}
+    response.err = err
+  }
+
+  spec.step = 'postrequest'
+
+  ctx.response = response
+
+  return response
+}
+
+
+export {
+  request
+}

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

@@ -0,0 +1,34 @@
+
+import { Context } from '../types'
+
+
+function resbasic(ctx: Context) {
+  const { response, result } = ctx
+
+  if (null != response) {
+    result.status = response.status || -1
+    result.statusText = response.statusText || 'no-status'
+
+    // TODO: use spec!
+    if (400 <= result.status) {
+      const msg = 'request: ' + result.status + ': ' + result.statusText
+      if (result.err) {
+        const prevmsg = null == result.err.message ? '' : result.err.message
+        result.err.message = prevmsg + ': ' + msg
+      }
+      else {
+        result.err = new Error(msg)
+      }
+    }
+    else if (response.err) {
+      result.err = response.err
+    }
+  }
+
+  return result
+}
+
+
+export {
+  resbasic
+}

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

@@ -0,0 +1,19 @@
+
+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
+  }
+
+  return result
+}
+
+
+export {
+  resbody
+}

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

@@ -0,0 +1,36 @@
+
+import { Context } from '../types'
+
+
+/* Convert data from respnse into a structure suitable for use as entity data.
+ *
+ * The operation (op) property `resform` is used to perform the data extraction.
+ */
+function resform(ctx: Context) {
+  const { spec, result, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+
+  if (spec) {
+    spec.step = 'resform'
+  }
+
+  if (!result.ok) {
+    return undefined
+  }
+
+  try {
+    const resform = ctx.op.resform
+    const resdata = isfunc(resform) ? resform(ctx) : transform(ctx.result, resform)
+    result.resdata = resdata
+    return resdata
+  }
+  catch (err) {
+    return error(ctx, err)
+  }
+}
+
+
+export {
+  resform
+}

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

@@ -0,0 +1,23 @@
+
+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 = {}
+  }
+
+  return result
+}
+
+
+export {
+  resheaders
+}

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

@@ -0,0 +1,30 @@
+
+import { Context } from '../types'
+
+
+async function response(ctx: Context) {
+  let { result, spec, utility } = ctx
+
+  const { resheaders, resbasic, resbody, resform } = utility
+
+  spec.step = 'response'
+
+  try {
+    resbasic(ctx)
+    resheaders(ctx)
+    await resbody(ctx)
+    resform(ctx)
+
+    if (null == result.err) {
+      result.ok = true
+    }
+  }
+  catch (err) {
+    result.err = err
+  }
+}
+
+
+export {
+  response
+}

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

@@ -0,0 +1,36 @@
+
+import { Context } from '../types'
+
+
+async function result(ctx: Context) {
+  let { op, spec, utility, entity, result } = ctx
+
+  const { resform } = utility
+
+  spec.step = 'result'
+
+  resform(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
+  }
+
+}
+
+
+export {
+  result
+}

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

@@ -0,0 +1,61 @@
+
+import { Context } 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
+
+  let options = client.options()
+
+  ctx.spec = {
+    base: options.base, // string, URL endpoint base prefix,
+    prefix: options.prefix,
+    path: op.path,
+    suffix: options.suffix,
+    method: 'get',
+    params: {},
+    query: {},
+    headers: {},
+    body: undefined,
+    step: 'start',
+    alias: {}
+  }
+
+  ctx.spec.method = method(ctx)
+  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
+      }
+    }
+  }
+
+  if (ctx.ctrl.explain) {
+    ctx.ctrl.explain.spec = ctx.spec
+  }
+
+  auth(ctx)
+}
+
+
+export {
+  spec
+}