@voxgig/sdkgen 0.25.0 → 0.28.0

package/project/.sdk/tm/ts/src/utility/{ReqformUtility.ts → TransformRequestUtility.ts}

@@ -5,17 +5,19 @@ 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 { struct, error } = utility
-  const { isfunc, transform } = struct
+function transformRequest(ctx: Context) {
+  const spec = ctx.spec
+  const utility = ctx.utility
+  const target = ctx.target
+  const isfunc = utility.struct.isfunc
+  const transform = utility.struct.transform
 
   if (spec) {
     spec.step = 'reqform'
   }
 
   try {
-    const reqform = ctx.op.reqform
+    const reqform = target.transform.req
     const reqdata = isfunc(reqform) ? reqform(ctx) : transform({
       reqdata: ctx.reqdata
     }, reqform)
@@ -23,11 +25,11 @@ function reqform(ctx: Context) {
     return reqdata
   }
   catch (err) {
-    return error(ctx, err)
+    return utility.makeError(ctx, err)
   }
 }
 
 
 export {
-  reqform
+  transformRequest
 }

package/project/.sdk/tm/ts/src/utility/{ResformUtility.ts → TransformResponseUtility.ts}

@@ -6,31 +6,34 @@ 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 { struct, error } = utility
-  const { isfunc, transform } = struct
+function transformResponse(ctx: Context) {
+  const spec = ctx.spec
+  const result = ctx.result
+  const utility = ctx.utility
+  const target = ctx.target
+  const isfunc = utility.struct.isfunc
+  const transform = utility.struct.transform
 
   if (spec) {
     spec.step = 'resform'
   }
 
-  if (!result.ok) {
+  if (null == result || !result.ok) {
     return undefined
   }
 
   try {
-    const resform = ctx.op.resform
+    const resform = target.transform.res
     const resdata = isfunc(resform) ? resform(ctx) : transform(ctx.result, resform)
     result.resdata = resdata
     return resdata
   }
   catch (err) {
-    return error(ctx, err)
+    return utility.makeError(ctx, err)
   }
 }
 
 
 export {
-  resform
+  transformResponse
 }

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

@@ -1,82 +1,69 @@
 
-/* Utility functions.
- *
- * Many of these functions expect the operation context as the first argument, and
- * assume the following top level properties of the context:
- *   * client: SDK client instance
- *   * op: operation definition
- *   * utility: map of these utility functions
- *   * entity?: SDK entity instance
- *   * spec?: request specification
- *   * response?: unprocessed response
- *   * result?: processed result built from response
- *   * config?: SDK builtin configuration
- *
- */
 
-
-
-import { addfeature } from './AddfeatureUtility'
-import { auth } from './AuthUtility'
-import { body } from './BodyUtility'
 import { clean } from './CleanUtility'
-import { contextify } from './ContextUtility'
 import { done } from './DoneUtility'
-import { error } from './ErrorUtility'
-import { featurehook } from './FeaturehookUtility'
+import { makeError } from './MakeErrorUtility'
+import { featureAdd } from './FeatureAddUtility'
+import { featureHook } from './FeatureHookUtility'
+import { featureInit } from './FeatureInitUtility'
 import { fetcher } from './FetcherUtility'
-import { findparam } from './FindparamUtility'
-import { fullurl } from './FullurlUtility'
-import { headers } from './HeadersUtility'
-import { initfeature } from './InitfeatureUtility'
-import { method } from './MethodUtility'
-import { operator, opify } from './OperatorUtility'
-import { options } from './OptionsUtility'
-import { params } from './ParamsUtility'
-import { query } from './QueryUtility'
-import { reqform } from './ReqformUtility'
-import { request } from './RequestUtility'
-import { resbasic } from './ResbasicUtility'
-import { resbody } from './ResbodyUtility'
-import { resform } from './ResformUtility'
-import { resheaders } from './ResheadersUtility'
-import { response } from './ResponseUtility'
-import { result } from './ResultUtility'
-import { spec } from './SpecUtility'
+import { makeFetchDef } from './MakeFetchDefUtility'
+import { makeContext } from './MakeContextUtility'
+import { makeOptions } from './MakeOptionsUtility'
+import { makeRequest } from './MakeRequestUtility'
+import { makeResponse } from './MakeResponseUtility'
+import { makeResult } from './MakeResultUtility'
+import { makeTarget } from './MakeTargetUtility'
+import { makeSpec } from './MakeSpecUtility'
+import { makeUrl } from './MakeUrlUtility'
+import { param } from './ParamUtility'
+import { prepareAuth } from './PrepareAuthUtility'
+import { prepareBody } from './PrepareBodyUtility'
+import { prepareHeaders } from './PrepareHeadersUtility'
+import { prepareMethod } from './PrepareMethodUtility'
+import { prepareParams } from './PrepareParamsUtility'
+import { preparePath } from './PreparePathUtility'
+import { prepareQuery } from './PrepareQueryUtility'
+import { resultBasic } from './ResultBasicUtility'
+import { resultBody } from './ResultBodyUtility'
+import { resultHeaders } from './ResultHeadersUtility'
+import { transformRequest } from './TransformRequestUtility'
+import { transformResponse } from './TransformResponseUtility'
 
 import { StructUtility } from './StructUtility'
 
 
 class Utility {
 
-  addfeature = addfeature
-  auth = auth
-  body = body
   clean = clean
-  contextify = contextify
   done = done
-  error = error
-  featurehook = featurehook
+  makeError = makeError
+  featureAdd = featureAdd
+  featureHook = featureHook
+  featureInit = featureInit
   fetcher = fetcher
-  findparam = findparam
-  fullurl = fullurl
-  headers = headers
-  initfeature = initfeature
-  method = method
-  operator = operator
-  opify = opify
-  options = options
-  params = params
-  query = query
-  reqform = reqform
-  request = request
-  resbasic = resbasic
-  resbody = resbody
-  resform = resform
-  resheaders = resheaders
-  response = response
-  result = result
-  spec = spec
+  makeFetchDef = makeFetchDef
+  makeContext = makeContext
+  makeOptions = makeOptions
+  makeRequest = makeRequest
+  makeResponse = makeResponse
+  makeResult = makeResult
+  makeTarget = makeTarget
+  makeSpec = makeSpec
+  makeUrl = makeUrl
+  param = param
+  prepareAuth = prepareAuth
+  prepareBody = prepareBody
+  prepareHeaders = prepareHeaders
+  prepareMethod = prepareMethod
+  prepareParams = prepareParams
+  preparePath = preparePath
+  prepareQuery = prepareQuery
+  resultBasic = resultBasic
+  resultBody = resultBody
+  resultHeaders = resultHeaders
+  transformRequest = transformRequest
+  transformResponse = transformResponse
 
   struct = new StructUtility()
 }

package/project/.sdk/tm/ts/test/exists.test.ts

@@ -10,7 +10,6 @@ describe('exists', async () => {
 
   test('test-mode', async () => {
     const testsdk = await ProjectNameSDK.test()
-    // console.log('testsdk', testsdk)
     equal(null !== testsdk, true)
   })
 

package/project/.sdk/tm/ts/test/runner.ts

@@ -1,10 +1,10 @@
-// VERSION: @voxgig/struct 0.0.4
+// VERSION: @voxgig/struct 0.0.10
 // This test utility runs the JSON-specified tests in build/test/test.json.
 // (or .sdk/test/test.json if used in a @voxgig/sdkgen project)
 
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { deepEqual, fail, AssertionError } from 'node:assert'
+import { deepStrictEqual, fail, AssertionError } from 'node:assert'
 
 const NULLMARK = '__NULL__' // Value is JSON null
 const UNDEFMARK = '__UNDEF__' // Value is not present (thus, undefined).
@@ -16,6 +16,7 @@ type RunSet = (testspec: any, testsubject: Function) => Promise<any>
 type RunSetFlags = (testspec: any, flags: Record<string, boolean>, testsubject: Function)
   => Promise<any>
 
+
 type RunPack = {
   spec: Record<string, any>
   runset: RunSet
@@ -24,6 +25,7 @@ type RunPack = {
   client: any
 }
 
+
 type TestPack = {
   name?: string
   client: any
@@ -36,9 +38,10 @@ type Flags = Record<string, boolean>
 
 type Utility = {
   struct: any
-  contextify: (ctxmap: Record<string, any>) => any
+  makeContext: (ctxmap: Record<string, any>, basectx?: any) => any
 }
 
+
 type Client = {
   utility: () => Utility
 }
@@ -80,7 +83,7 @@ async function makeRunner(testfile: string, client: Client) {
           res = fixJSON(res, flags)
           entry.res = res
 
-          checkResult(entry, res, structUtils)
+          checkResult(entry, args, res, structUtils)
         }
         catch (err: any) {
           if (err instanceof AssertionError) {
@@ -110,8 +113,7 @@ async function makeRunner(testfile: string, client: Client) {
 
 function resolveSpec(name: string, testfile: string): Record<string, any> {
   const alltests =
-    JSON.parse(readFileSync(join(
-      __dirname, testfile), 'utf8'))
+    JSON.parse(readFileSync(join(__dirname, testfile), 'utf8'))
 
   let spec = alltests.primary?.[name] || alltests[name] || alltests
   return spec
@@ -163,16 +165,16 @@ function resolveEntry(entry: any, flags: Flags): any {
 }
 
 
-function checkResult(entry: any, res: any, structUtils: Record<string, any>) {
+function checkResult(entry: any, args: any[], res: any, structUtils: Record<string, any>) {
   let matched = false
 
   if (entry.err) {
     return fail('Expected error did not occur: ' + entry.err +
-      '\n\nENTRY: ' + JSON.stringify(entry, null, 2))
+      '\n\nENTRY: ' + safeStringify(entry))
   }
 
   if (entry.match) {
-    const result = { in: entry.in, out: entry.res, ctx: entry.ctx }
+    const result = { in: entry.in, args, out: entry.res, ctx: entry.ctx }
     match(
       entry.match,
       result,
@@ -193,7 +195,7 @@ function checkResult(entry: any, res: any, structUtils: Record<string, any>) {
     return
   }
 
-  deepEqual(null != res ? JSON.parse(JSON.stringify(res)) : res, entry.out)
+  deepStrictEqual(null != res ? JSON.parse(safeStringify(res)) : res, entry.out)
 }
 
 
@@ -221,10 +223,10 @@ function handleError(entry: any, err: any, structUtils: Record<string, any>) {
 
   // Unexpected error (test didn't specify an error expectation)
   else if (err instanceof AssertionError) {
-    fail(err.message + '\n\nENTRY: ' + JSON.stringify(entry, null, 2))
+    fail(err.message + '\n\nENTRY: ' + safeStringify(entry))
   }
   else {
-    fail(err.stack + '\\nnENTRY: ' + JSON.stringify(entry, null, 2))
+    fail(err.stack + '\n\nENTRY: ' + safeStringify(entry))
   }
 }
 
@@ -251,7 +253,7 @@ function resolveArgs(
     let first = args[0]
     if (structUtils.ismap(first)) {
       first = structUtils.clone(first)
-      first = utility.contextify(first)
+      first = utility.makeContext(first)
       args[0] = first
       entry.ctx = first
 
@@ -354,11 +356,27 @@ function matchval(
 }
 
 
+function safeStringify(val: any): string {
+  const seen = new WeakSet()
+  return JSON.stringify(val, (_k, v) => {
+    if ('object' === typeof v && null !== v) {
+      if (seen.has(v)) return '[Circular]'
+      seen.add(v)
+    }
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message }
+    }
+    return v
+  }, 2)
+}
+
+
 function fixJSON(val: any, flags?: Flags): any {
   if (null == val) {
     return flags?.null ? NULLMARK : val
   }
 
+  const seen = new WeakSet()
   const replacer = (_k: string, v: any) => {
     if (null == v && flags?.null) {
       return NULLMARK
@@ -372,6 +390,11 @@ function fixJSON(val: any, flags?: Flags): any {
       }
     }
 
+    if ('object' === typeof v && null !== v) {
+      if (seen.has(v)) return '[Circular]'
+      seen.add(v)
+    }
+
     return v
   }
 

package/project/.sdk/tm/ts/test/utility/Custom.test.ts

@@ -4,38 +4,39 @@ import { equal } from 'node:assert'
 
 import { ProjectNameSDK } from '../..'
 
-const client = ProjectNameSDK.test({}, {
-  apikey: 'APIKEY01',
-
-  // NOTE: original utility.options must remain in place.
-  utility: {
-    auth: () => ({ util: 'AUTH' }),
-    body: () => ({ util: 'BODY' }),
-    contextify: () => ({ util: 'CONTEXTIFY' }),
-    done: () => ({ util: 'DONE' }),
-    error: () => ({ util: 'ERROR' }),
-    findparam: () => ({ util: 'FINDPARAM' }),
-    fullurl: () => ({ util: 'FULLURL' }),
-    headers: () => ({ util: 'HEADERS' }),
-    method: () => ({ util: 'METHOD' }),
-    operator: () => ({ util: 'OPERATOR' }),
-    params: () => ({ util: 'PARAMS' }),
-    query: () => ({ util: 'QUERY' }),
-    reqform: () => ({ util: 'REQFORM' }),
-    request: () => ({ util: 'REQUEST' }),
-    resbasic: () => ({ util: 'RESBASIC' }),
-    resbody: () => ({ util: 'RESBODY' }),
-    resform: () => ({ util: 'RESFORM' }),
-    resheaders: () => ({ util: 'RESHEADERS' }),
-    response: () => ({ util: 'RESPONSE' }),
-    result: () => ({ util: 'RESULT' }),
-    spec: () => ({ util: 'SPEC' }),
-  }
-})
-
 
 describe('Custom', () => {
+
   test('basic', async () => {
+    const client = ProjectNameSDK.test({}, {
+      apikey: 'APIKEY01',
+
+      // NOTE: original utility.options must remain in place.
+      utility: {
+        auth: () => ({ util: 'AUTH' }),
+        body: () => ({ util: 'BODY' }),
+        contextify: () => ({ util: 'CONTEXTIFY' }),
+        done: () => ({ util: 'DONE' }),
+        error: () => ({ util: 'ERROR' }),
+        findparam: () => ({ util: 'FINDPARAM' }),
+        fullurl: () => ({ util: 'FULLURL' }),
+        headers: () => ({ util: 'HEADERS' }),
+        method: () => ({ util: 'METHOD' }),
+        operator: () => ({ util: 'OPERATOR' }),
+        params: () => ({ util: 'PARAMS' }),
+        query: () => ({ util: 'QUERY' }),
+        reqform: () => ({ util: 'REQFORM' }),
+        request: () => ({ util: 'REQUEST' }),
+        resbasic: () => ({ util: 'RESBASIC' }),
+        resbody: () => ({ util: 'RESBODY' }),
+        resform: () => ({ util: 'RESFORM' }),
+        resheaders: () => ({ util: 'RESHEADERS' }),
+        response: () => ({ util: 'RESPONSE' }),
+        result: () => ({ util: 'RESULT' }),
+        spec: () => ({ util: 'SPEC' }),
+      }
+    })
+
     const u: any = client.utility()
 
     equal(u.auth().util, 'AUTH')