@voxgig/sdkgen 0.24.0 → 0.26.1

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

@@ -1,47 +1,44 @@
 
+import { inspect } from 'node:util'
+
 import { ProjectNameSDK } from './ProjectNameSDK'
 
 import { Utility } from './utility/Utility'
+import { getprop, setprop, getpath } from './utility/StructUtility'
 
-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
-}
+
+
+
+// TODO: convert to classes
 
 
 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>
+  select: string
+  alts: Alt[]
+}
+
+
+type Alt = {
+  args: {
+    param: any[]
+  }
+  rename: {
+    param: Record<string, string>
   }
-  check: Record<string, any>
+  method: string
+  orig: string
+  parts: string[]
+  select: any
+  active: boolean
+  relations: any[]
 }
 
 
 type Spec = {
+  parts: string[]
+
   headers: Record<string, string>
   alias: any
   base: string
@@ -52,8 +49,20 @@ type Spec = {
   step: string
   method: string
   body: any
-  path: string
   url?: string
+
+  path?: string
+
+}
+
+
+type Response = {
+  status: number,
+  statusText: string,
+  headers: any,
+  json: Function,
+  err?: Error,
+  body?: any,
 }
 
 
@@ -76,6 +85,121 @@ type Control = {
 }
 
 
+// TODO: move to own file
+class Context {
+
+  id = 'C' + ('' + Math.random()).substring(2, 10)
+
+  // Store the output of each operation step.
+  out: Record<string, any> = {}
+
+  // Store for the current operation.
+  current: WeakMap<String, any> = new WeakMap()
+
+
+  ctrl: Record<string, any> = {}
+  meta: Record<string, any> = {}
+
+  client: ProjectNameSDK
+  utility: Utility
+
+  op: Operation
+  alt: any
+
+  config: Record<string, any>
+  entopts: Record<string, any>
+  options: Record<string, any>
+
+  opmap: Record<string, Operation>
+
+  response?: Response
+  result?: Result
+  spec?: Spec
+
+  data?: any
+  reqdata?: any
+  match?: any
+  reqmatch?: any
+
+  entity?: any
+
+  // Shared persistent store.
+  shared: WeakMap<String, any>
+
+
+  constructor(ctxmap: Record<string, any>, basectx?: Context) {
+    this.client = getprop(ctxmap, 'client', getprop(basectx, 'client'))
+    this.utility = getprop(ctxmap, 'utility', getprop(basectx, 'utility'))
+
+    this.ctrl = getprop(ctxmap, 'ctrl', getprop(basectx, 'ctrl', this.ctrl))
+    this.meta = getprop(ctxmap, 'meta', getprop(basectx, 'meta', this.meta))
+
+    this.config = getprop(ctxmap, 'config', getprop(basectx, 'config'))
+    this.entopts = getprop(ctxmap, 'entopts', getprop(basectx, 'entopts'))
+    this.options = getprop(ctxmap, 'options', getprop(basectx, 'options'))
+
+    this.entity = getprop(ctxmap, 'entity', getprop(basectx, 'entity'))
+    this.shared = getprop(ctxmap, 'shared', getprop(basectx, 'shared'))
+    this.opmap = getprop(ctxmap, 'opmap', getprop(basectx, 'opmap'))
+
+    this.data = getprop(ctxmap, 'data', {})
+    this.reqdata = getprop(ctxmap, 'reqdata', {})
+    this.match = getprop(ctxmap, 'match', {})
+    this.reqmatch = getprop(ctxmap, 'reqmatch', {})
+
+    const opname = getprop(ctxmap, 'opname')
+    this.op = this.resolveOp(opname)
+  }
+
+
+  resolveOp(opname: string): Operation {
+    let op: Operation = getprop(this.opmap, opname)
+
+    if (null == op && null != opname) {
+      const entname = getprop(this.entity, 'name', '')
+      const opcfg = getpath(this.config, ['entity', entname, 'op', opname])
+      let select = 'match'
+
+      if ('update' === opname || 'create' === opname) {
+        select = 'data'
+      }
+
+      op = {
+        entity: entname,
+        name: opname,
+        select,
+        alts: getprop(opcfg, 'alts', [])
+      }
+
+      setprop(this.opmap, opname, op)
+    }
+
+    return op
+  }
+
+
+  toJSON() {
+    return {
+      id: this.id,
+      op: this.op,
+      spec: this.spec,
+      entity: this.entity,
+      result: this.result,
+      meta: this.meta,
+    }
+  }
+
+  toString() {
+    return 'Context ' + (this as any).utility?.struct.jsonify(this.toJSON())
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
+}
+
+
 type FeatureOptions = Record<string, any> | {
   active: boolean
 }
@@ -103,12 +227,18 @@ interface Feature {
 }
 
 
+export {
+  Context
+}
+
 
 export type {
-  Context,
-  Operation,
-  Spec,
+  Alt,
   Control,
-  FeatureOptions,
   Feature,
+  FeatureOptions,
+  Operation,
+  Response,
+  Result,
+  Spec,
 }

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

@@ -1,5 +1,5 @@
 
-import { Context } from '../types'
+import { Context, Spec } from '../types'
 
 
 const HEADER_auth = 'authorization'
@@ -9,7 +9,7 @@ const OPTION_apikey = 'apikey'
 const NOTFOUND = ''
 
 
-function auth(ctx: Context) {
+function auth(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 new Error('Expected context spec property to be defined.')
+  }
+
+
+
   const headers = spec.headers
 
   const options = client.options()

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

@@ -2,18 +2,21 @@
 import { Context } from '../types'
 
 function body(ctx: Context) {
-  const { op, utility } = ctx
-  const { error, reqform } = utility
+  const op = ctx.op
+
+  const utility = ctx.utility
+  const error = utility.error
+  const reqform = utility.reqform
 
   let body = undefined
 
-  if ('req' === op.kind) {
+  if ('data' === op.select) {
     try {
       body = reqform(ctx)
 
-      if (op.check.nobody && null == body) {
-        return error(ctx, new Error('Request body is empty.'))
-      }
+      // if (alt.check.nobody && null == body) {
+      //   return error(ctx, new Error('Request body is empty.'))
+      // }
     }
     catch (err) {
       return error(ctx, err)

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/ContextUtility.ts

@@ -1,67 +1,27 @@
 
-import { getprop } from './StructUtility'
+import { ProjectNameSDK } from '../ProjectNameSDK'
 
+import { Utility } from './Utility'
 
-function contextify(ctxmap: Record<string, any>, basectx?: Context): any {
-  const ctx = new Context()
+import type {
+  Operation,
+  Spec,
+  Response,
+  Result,
+} from '../types'
 
-  ctx.ctrl = getprop(ctxmap, 'ctrl', getprop(basectx, 'ctrl', {}))
-  ctx.meta = getprop(ctxmap, 'meta', getprop(basectx, 'meta', {}))
-  ctx.work = getprop(ctxmap, 'work', getprop(basectx, 'work', {}))
+import {
+  Context
+} from '../types'
 
-  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'))
 
+function makeContext(ctxmap: Record<string, any>, basectx?: Context): any {
+  const ctx = new Context(ctxmap, basectx)
   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
+  makeContext,
 }

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

@@ -15,7 +15,7 @@ function done(ctx: Context) {
     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/ErrorUtility.ts

@@ -1,5 +1,5 @@
 
-import { Context } from '../types'
+import { Result, Context } from '../types'
 
 
 import { clean } from './CleanUtility'
@@ -13,7 +13,8 @@ function error(ctx: Context, err?: any) {
   const op = ctx.op || {}
   op.name = op.name || 'unknown operation'
 
-  const result = ctx.result = ctx.result || {}
+
+  const result = ctx.result || ({} as Result)
   result.ok = false
 
   const reserr = result.err
@@ -22,6 +23,9 @@ function error(ctx: Context, err?: any) {
   err = err || new Error('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

package/project/.sdk/tm/ts/src/utility/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/FetcherUtility.ts

@@ -1,9 +1,25 @@
 
-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 Error('Request blocked by mode: "' + ctx.client._mode +
+      '" (URL was: "' + fullurl + '")')
+  }
+
   const options = ctx.client.options()
+
+  if (true === ctx.utility.struct.getpath(options, 'feature.test.active')) {
+    return Error('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/FindparamUtility.ts

@@ -1,7 +1,7 @@
 
 import { Context } from '../types'
 
-import { getprop } from './StructUtility'
+import { setprop, getprop } from './StructUtility'
 
 
 /* Find value of a match parameter, possibly using an alias.
@@ -11,10 +11,14 @@ 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 findparam(ctx: Context, param: any) {
+  let { alt, spec, match, reqmatch, data, reqdata } = ctx
 
-  let akey = op.alias[key]
+  // TODO: review this search algorithm
+
+  const key = param.name
+
+  let akey = getprop(alt.alias, key)
 
   let val = getprop(reqmatch, key)
 
@@ -23,7 +27,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)
   }

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

@@ -1,16 +1,29 @@
 
 import { Context } from '../types'
 
-function fullurl(ctx: Context) {
+
+function fullurl(ctx: Context): Error | string {
   const utility = ctx.utility
-  // const findparam = utility.findparam
+  const spec = ctx.spec
+  const result = ctx.result
 
   const struct = utility.struct
-  const { escurl, escre, joinurl } = struct
+  const escurl = struct.escurl
+  const escre = struct.escre
+  const join = struct.join
+
 
-  const { spec, result } = ctx
+  if (null == spec) {
+    return new Error('Expected context spec property to be defined.')
+  }
 
-  let url = joinurl([spec.base, spec.prefix, spec.path, spec.suffix])
+  if (null == result) {
+    return new Error('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
@@ -23,6 +36,8 @@ function fullurl(ctx: Context) {
     }
   }
 
+
+  /* TODO: fix
   let qsep = '?'
   for (let key in spec.query) {
     if (null == spec.alias[key]) {
@@ -34,6 +49,7 @@ function fullurl(ctx: Context) {
       }
     }
   }
+  */
 
   result.resmatch = resmatch
 

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

@@ -4,7 +4,9 @@ import { Context, Feature } from '../types'
 
 function initfeature(ctx: Context, f: Feature) {
   const fopts = ctx.options.feature[f.name] || {}
-  f.init(ctx, fopts)
+  if (true === fopts.active) {
+    f.init(ctx, fopts)
+  }
 }
 
 

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

@@ -0,0 +1,23 @@
+
+import { Operation } from '../types'
+
+import { getprop } from './StructUtility'
+
+
+function makeOperation(opmap: Record<string, any>) {
+
+  const op: Operation = {
+    name: getprop(opmap, 'name', '_'),
+    entity: getprop(opmap, 'entity', '_'),
+    select: getprop(opmap, 'select', '_'),
+    alts: getprop(opmap, 'alts', []),
+  }
+
+  return op
+}
+
+
+
+export {
+  makeOperation,
+}