@voxgig/sdkgen 0.26.1 → 0.28.0

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

@@ -1,203 +1,13 @@
 
-import { inspect } from 'node:util'
-
 import { ProjectNameSDK } from './ProjectNameSDK'
 
-import { Utility } from './utility/Utility'
-import { getprop, setprop, getpath } from './utility/StructUtility'
-
-
-
-
-// TODO: convert to classes
-
-
-type Operation = {
-  entity: string
-  name: string
-  select: string
-  alts: Alt[]
-}
-
-
-type Alt = {
-  args: {
-    param: any[]
-  }
-  rename: {
-    param: Record<string, string>
-  }
-  method: string
-  orig: string
-  parts: string[]
-  select: any
-  active: boolean
-  relations: any[]
-}
-
-
-type Spec = {
-  parts: string[]
-
-  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
-  url?: string
-
-  path?: string
-
-}
-
-
-type Response = {
-  status: number,
-  statusText: string,
-  headers: any,
-  json: Function,
-  err?: Error,
-  body?: any,
-}
-
-
-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
-}
-
-
-// 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()
-  }
-
-}
+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> | {
@@ -218,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>
@@ -228,17 +38,17 @@ interface Feature {
 
 
 export {
-  Context
+  Target,
+  Context,
+  Control,
+  Operation,
+  Response,
+  Result,
+  Spec,
 }
 
 
 export type {
-  Alt,
-  Control,
   Feature,
   FeatureOptions,
-  Operation,
-  Response,
-  Result,
-  Spec,
 }

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

@@ -4,11 +4,10 @@ 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)

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/{InitfeatureUtility.ts → FeatureInitUtility.ts}

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

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

@@ -9,14 +9,16 @@ async function fetcher(
 ): Promise<Response | Error> {
 
   if ('live' !== ctx.client._mode) {
-    return Error('Request blocked by mode: "' + ctx.client._mode +
+    return ctx.error('fetch_mode_block', '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' +
+  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 + '")')
   }
 

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

@@ -7,20 +7,20 @@ 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 || ({} as 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
@@ -59,5 +59,5 @@ function error(ctx: Context, err?: any) {
 
 
 export {
-  error
+  makeError
 }

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) {
+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)) {
-    struct.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 || {}
 
@@ -79,7 +82,7 @@ function options(ctx: Context) {
   const keyre = opts.clean.keys
     .split(/\s*,\s*/)
     .filter((s: string) => null != s && '' !== s)
-    .map((key: string) => struct.escre(key)).join('|')
+    .map((key: string) => escre(key)).join('|')
 
   if ('' != keyre) {
     opts.__derived__.clean.keyre = keyre
@@ -90,5 +93,5 @@ function options(ctx: Context) {
 
 
 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/{ResultUtility.ts → MakeResultUtility.ts}

@@ -2,14 +2,14 @@
 import { Result, Context } from '../types'
 
 
-function result(ctx: Context): Result | Error {
+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 resform = utility.resform
+  const transformResponse = utility.transformResponse
 
   const op = ctx.op
   const entity = ctx.entity
@@ -18,16 +18,16 @@ function result(ctx: Context): Result | Error {
   const result = ctx.result
 
   if (null == spec) {
-    return new Error('Expected context spec property to be defined.')
+    return ctx.error('result_no_spec', 'Expected context spec property to be defined.')
   }
 
   if (null == result) {
-    return new Error('Expected context result property to be defined.')
+    return ctx.error('result_no_result', 'Expected context result property to be defined.')
   }
 
   spec.step = 'result'
 
-  resform(ctx)
+  transformResponse(ctx)
 
   if ('list' == op.name) {
     const resdata = result.resdata
@@ -52,5 +52,5 @@ function result(ctx: Context): Result | Error {
 
 
 export {
-  result
+  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
+}