@voxgig/sdkgen 0.25.0 → 0.28.0

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -5,6 +5,9 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
+const S_NOT_FOUND = 'Not found'
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -18,137 +21,188 @@ class TestFeature extends BaseFeature {
     this._client = ctx.client
     this._options = options
 
-    // console.log('TEST FEATURE', this._options)
-
-    const { struct } = ctx.utility
-    const { walk, size, setprop, stringify } = struct
+    const struct = ctx.utility.struct
+    const walk = struct.walk
+    const size = struct.size
+    const setprop = struct.setprop
 
     const entity = this._options.entity
 
-    // Set entity ids to correct values
-    walk(entity, (k: any, v: any, parent: any, path: any) => {
+    this._client._mode = 'test'
+
+    // Ensure entity ids are correct.
+    walk(entity, (k: any, v: any, _parent: any, path: any) => {
       if (2 === size(path)) {
         setprop(v, 'id', k)
       }
       return v
     })
 
-    if (entity) {
-      ctx.utility.fetcher = (ctx: any, _fullurl: string, _fetchdef: any) => {
-        const { findparam, struct } = ctx.utility
-        const { getprop, clone, merge, keysof, size, select, delprop } = struct
-
-
-        function respond(status: number, data?: any, res?: any) {
-          const out = merge([
-            {
-              status,
-              statusText: 'OK',
-              json: async () => data,
-            },
-            res || {}
-          ])
-
-          const headers: any = out.headers || {}
-          out.headers = {
-            forEach(callback: any) {
-              Object.keys(headers).forEach((key) => {
-                callback(headers[key], key, this)
-              })
-            }
+    const self = this
+
+    function testFetcher(ctx: any, _fullurl: string, _fetchdef: any) {
+      const struct = ctx.utility.struct
+      const param = ctx.utility.param
+
+      const getprop = struct.getprop
+      const clone = struct.clone
+      const merge = struct.merge
+      const getelem = struct.getelem
+      const select = struct.select
+      const delprop = struct.delprop
+      const getdef = struct.getdef
+
+      function respond(status: number, data?: any, res?: any) {
+        const out = merge([
+          {
+            status,
+            statusText: 'OK',
+            json: async () => data,
+            body: 'not-used',
+          },
+          getdef(res, {})
+        ])
+
+        const headers: any = getprop(out, 'headers', {})
+
+        // JS specific iterator.
+        out.headers = {
+          forEach(callback: any) {
+            Object.keys(headers).forEach((key) => {
+              callback(headers[key], key, this)
+            })
           }
-
-          return out
         }
 
+        return out
+      }
 
-        const op = ctx.op
-        const entmap = entity[op.entity]
-
-        const qand: any[] = []
-        const q = { '`$AND`': qand }
-
-        for (let k of keysof(ctx.reqmatch)) {
-          const v = findparam(ctx, k)
-          const ka = getprop(op.alias, k)
-
-          let qor: any = [{ [k]: v }]
-          if (null != ka) {
-            qor.push({ [ka]: v })
-          }
 
-          qor = { '`$OR`': qor }
+      const op = ctx.op
+      const entmap = getprop(entity, op.entity, {})
 
-          qand.push(qor)
+      if ('load' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
-
-        if (ctx.ctrl.explain) {
-          ctx.ctrl.explain.test = { query: q }
+        else {
+          delprop(ent, '$KEY')
+          const out = clone(ent)
+          return respond(200, out)
         }
-
-        if ('load' === op.name) {
-          const found = select(entmap, q)
-          const ent = found[0]
-          if (null == ent) {
-            return respond(404, undefined, { statusText: 'Not found' })
-          }
-          else {
-            delprop(ent, '$KEY')
-            return respond(200, clone(ent))
-          }
+      }
+      else if ('list' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        if (null == found) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
-        else if ('list' === op.name) {
-          const found = select(entmap, q)
-          if (null == found) {
-            return respond(404, undefined, { statusText: 'Not found' })
-          }
-          else {
-            found.map((ent: any) => delprop(ent, '$KEY'))
-            return respond(200, clone(found))
-          }
+        else {
+          found.map((ent: any) => delprop(ent, '$KEY'))
+          const out = clone(found)
+          return respond(200, out)
         }
-        else if ('update' === op.name) {
-          const found = select(entmap, q)
-          const ent = found[0]
-          if (null == ent) {
-            return respond(404, undefined, { statusText: 'Not found' })
-          }
-          else {
-            merge([ent, (ctx.reqdata || {})])
-            delprop(ent, '$KEY')
-            return respond(200, clone(ent))
-          }
+      }
+      else if ('update' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
-        else if ('remove' === op.name) {
-          const found = select(entmap, q)
-          const ent = found[0]
-          if (null == ent) {
-            return respond(404, undefined, { statusText: 'Not found' })
-          }
-          else {
-            delprop(entmap, getprop(ent, 'id'))
-            return respond(200)
-          }
+        else {
+          merge([ent, (ctx.reqdata || {})])
+          delprop(ent, '$KEY')
+          const out = clone(ent)
+          return respond(200, out)
         }
-        else if ('create' === op.name) {
-          const id = findparam(ctx, 'id')
-          if (null != id) {
-            const ent = clone(ctx.reqdata)
-            ent.id = id
-            setprop(entmap, 'id', ent)
-            delprop(ent, '$KEY')
-            return respond(200, clone(ent))
-          }
-          else {
-            return respond(400, undefined, { statusText: 'Missing id' })
-          }
+      }
+      else if ('remove' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
+        }
+        else {
+          delprop(entmap, getprop(ent, 'id'))
+          return respond(200)
+        }
+      }
+      else if ('create' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        let id = param(ctx, 'id')
+        if (null == id) {
+          id = ((1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16)).padEnd(16, '0')
         }
+
+        const ent = clone(ctx.reqdata)
+        setprop(ent, 'id', id)
+        setprop(entmap, id, ent)
+        delprop(ent, '$KEY')
+        const out = clone(ent)
+        return respond(200, out)
       }
     }
+
+    ctx.utility.fetcher = testFetcher
   }
-}
 
 
+  buildArgs(ctx: any, op: any, args: any): any {
+    const struct = ctx.utility.struct
+    const param = ctx.utility.param
+
+    const getprop = struct.getprop
+    const keysof = struct.keysof
+    const getpath = struct.getpath
+    const getelem = struct.getelem
+    const select = struct.select
+    const transform = struct.transform
+    const isempty = struct.isempty
+
+    const opname = getprop(op, 'name')
+    const target =
+      getelem(getpath(ctx.config, [
+        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'targets']), -1)
+
+    const reqd = transform(
+      select(getpath(target, ['args', 'params']), { reqd: true }),
+      ['`$EACH`', '', '`$KEY.name`']
+    )
+
+    const qand: any[] = []
+    const q = { '`$AND`': qand }
+
+    for (let k of keysof(args)) {
+      if ('id' === k || !isempty(select(reqd, k))) {
+        const v = param(ctx, k)
+        const ka = getprop(op.alias, k)
+
+        let qor: any = [{ [k]: v }]
+        if (null != ka) {
+          qor.push({ [ka]: v })
+        }
+
+        qor = { '`$OR`': qor }
+
+        qand.push(qor)
+      }
+    }
+
+    if (ctx.ctrl.explain) {
+      ctx.ctrl.explain.test = { query: q }
+    }
+
+    return q
+  }
+}
 
 
 export {

package/project/.sdk/tm/ts/src/types.ts

@@ -1,79 +1,13 @@
 
 import { ProjectNameSDK } from './ProjectNameSDK'
 
-import { Utility } from './utility/Utility'
-
-type Context = {
-  ctrl: any
-  client: ProjectNameSDK
-  op: Operation
-  spec: Spec
-  result: Result
-  utility: Utility
-  entopts: any
-  options: any
-  config: any
-  response: any
-  entity: any
-  data: any
-  match: any
-  reqdata: any
-  reqmatch: any
-  work: any
-}
-
-
-type Operation = {
-  kind: string
-  entity: string
-  name: string
-  path: string
-  pathalt: ({ path: string } & Record<string, boolean>)[],
-  params: string[],
-  alias: Record<string, string>
-  state: Record<string, any>
-  reqform: any
-  resform: any
-  validate: {
-    params: Record<string, any>
-  }
-  check: Record<string, any>
-}
-
-
-type Spec = {
-  headers: Record<string, string>
-  alias: any
-  base: string
-  prefix: string
-  suffix: string
-  params: Record<string, string>
-  query: Record<string, string>
-  step: string
-  method: string
-  body: any
-  path: string
-  url?: string
-}
-
-
-type Result = {
-  ok: boolean
-  status: number
-  statusText: string
-  headers: Record<string, string>
-  body?: any
-  err?: any
-  resdata?: any
-  resmatch?: any
-}
-
-
-type Control = {
-  throw?: boolean
-  err?: any
-  explain?: any
-}
+import { Target } from './Target'
+import { Context } from './Context'
+import { Control } from './Control'
+import { Operation } from './Operation'
+import { Response } from './Response'
+import { Result } from './Result'
+import { Spec } from './Spec'
 
 
 type FeatureOptions = Record<string, any> | {
@@ -94,7 +28,7 @@ interface Feature {
   GetData: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
   GetMatch: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
 
-  PreOperation: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PreTarget: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
   PreSpec: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
   PreRequest: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
   PreResponse: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
@@ -103,12 +37,18 @@ interface Feature {
 }
 
 
-
-export type {
+export {
+  Target,
   Context,
+  Control,
   Operation,
+  Response,
+  Result,
   Spec,
-  Control,
-  FeatureOptions,
+}
+
+
+export type {
   Feature,
+  FeatureOptions,
 }

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

@@ -3,45 +3,31 @@ import { Context } from '../types'
 
 
 import {
-  walk, getpath, escre, getprop, size, pad, slice, setprop, clone
+  walk, size, pad, slice, 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
-  })
+  const cleankeyre = options.__derived__.clean.keyre
+  const hintsize = 4
+
+  /*
+  if (null != cleankeyre) {
+    val = walk(clone(val), (key: any, subval: any) => {
+      if (cleankeyre.exec(key) && 'string' === typeof subval) {
+        const len = size(subval)
+        const hint = (hintsize * 4) < len ? slice(subval, 0, hintsize) : ''
+        subval = pad(hint, len, '*')
+      }
+      return subval
+    })
+  }
+  */
 
-  return out
+  return val
 }
 
 

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

@@ -4,18 +4,17 @@ import { Context } from '../types'
 
 import { clean } from './CleanUtility'
 
-import { delprop } from './StructUtility'
-
 
 function done(ctx: Context) {
-  const { error } = ctx.utility
+  const error = ctx.utility.makeError
+  const delprop = ctx.utility.struct.delprop
 
   if (ctx.ctrl.explain) {
     ctx.ctrl.explain = clean(ctx, ctx.ctrl.explain)
     delprop(ctx.ctrl.explain.result, 'err')
   }
 
-  if (ctx.result.ok) {
+  if (ctx.result && ctx.result.ok) {
     return ctx.result.resdata
   }
 

package/project/.sdk/tm/ts/src/utility/{AddfeatureUtility.ts → FeatureAddUtility.ts}

@@ -2,7 +2,7 @@
 import { Context, Feature } from '../types'
 
 
-function addfeature(ctx: Context, f: Feature) {
+function featureAdd(ctx: Context, f: Feature) {
   const client = ctx.client
   const struct = ctx.utility.struct
   const setprop = struct.setprop
@@ -43,5 +43,5 @@ function addfeature(ctx: Context, f: Feature) {
 
 
 export {
-  addfeature
+  featureAdd
 }

package/project/.sdk/tm/ts/src/utility/{FeaturehookUtility.ts → FeatureHookUtility.ts}

@@ -2,16 +2,19 @@
 import { Context, Feature } from '../types'
 
 
-function featurehook(ctx: Context, name: string) {
+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)
+    const fh = (f as any)[name]
+    if (null != fh) {
+      const fres = fh(ctx)
+      if (fres instanceof Promise) {
+        resp.push(fres)
+      }
     }
   }
 
@@ -22,5 +25,5 @@ function featurehook(ctx: Context, name: string) {
 
 
 export {
-  featurehook
+  featureHook
 }

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

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

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

@@ -1,9 +1,27 @@
 
-import { Context } from '../types'
+import { Context, Response } from '../types'
 
 // Make HTTP call using library. Replace this utility for mocking etc.
-async function fetcher(ctx: Context, fullurl: string, fetchdef: Record<string, any>) {
+async function fetcher(
+  ctx: Context,
+  fullurl: string,
+  fetchdef: Record<string, any>
+): Promise<Response | Error> {
+
+  if ('live' !== ctx.client._mode) {
+    return ctx.error('fetch_mode_block', 'Request blocked by mode: "' + ctx.client._mode +
+      '" (URL was: "' + fullurl + '")')
+  }
+
   const options = ctx.client.options()
+
+  const getpath = ctx.utility.struct.getpath
+
+  if (true === getpath(options, 'feature.test.active')) {
+    return ctx.error('fetch_test_block', 'Request blocked as test feature is active' +
+      ' (URL was: "' + fullurl + '")')
+  }
+
   const fetch = options.system.fetch
 
   const response = await fetch(fullurl, fetchdef)

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

@@ -0,0 +1,27 @@
+
+import { ProjectNameSDK } from '../ProjectNameSDK'
+
+import { Utility } from './Utility'
+
+import type {
+  Operation,
+  Spec,
+  Response,
+  Result,
+} from '../types'
+
+import {
+  Context
+} from '../types'
+
+
+function makeContext(ctxmap: Record<string, any>, basectx?: Context): any {
+  const ctx = new Context(ctxmap, basectx)
+  return ctx
+}
+
+
+
+export {
+  makeContext,
+}

package/project/.sdk/tm/ts/src/utility/{ErrorUtility.ts → MakeErrorUtility.ts}

@@ -1,5 +1,5 @@
 
-import { Context } from '../types'
+import { Result, Context } from '../types'
 
 
 import { clean } from './CleanUtility'
@@ -7,21 +7,25 @@ import { clean } from './CleanUtility'
 import { clone, delprop } from './StructUtility'
 
 
-function error(ctx: Context, err?: any) {
+function makeError(ctx: Context, err?: any) {
 
   ctx = ctx || {}
   const op = ctx.op || {}
   op.name = op.name || 'unknown operation'
 
-  const result = ctx.result = ctx.result || {}
+
+  const result = ctx.result || new Result({})
   result.ok = false
 
   const reserr = result.err
 
   err = undefined === err ? reserr : err
-  err = err || new Error('unknown error')
+  err = err || ctx.error('unknown', 'unknown error')
 
   const errmsg = err.message || 'unknown error'
+  // TODO: project name should come from config
+  // avoids spurious changes between template and generated utility
+  // applies for all utility files
   const msg = 'ProjectNameSDK: ' + op.name + ': ' + errmsg
   err.message = clean(ctx, msg)
 
@@ -46,7 +50,7 @@ function error(ctx: Context, err?: any) {
 
   // TODO: model option to return instead
   if (false === ctx.ctrl.throw) {
-    return ctx.result.resdata
+    return result.resdata
   }
   else {
     throw err
@@ -55,5 +59,5 @@ function error(ctx: Context, err?: any) {
 
 
 export {
-  error
+  makeError
 }