@voxgig/sdkgen 0.22.0 → 0.23.0

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

@@ -0,0 +1,88 @@
+
+/* 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 { 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 { StructUtility } from './StructUtility'
+
+
+class Utility {
+
+  addfeature = addfeature
+  auth = auth
+  body = body
+  clean = clean
+  contextify = contextify
+  done = done
+  error = error
+  featurehook = featurehook
+  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
+
+  struct = new StructUtility()
+}
+
+
+export {
+  Utility
+}
+

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

@@ -0,0 +1,17 @@
+
+import { test, describe } from 'node:test'
+import { equal } from 'node:assert'
+
+
+import { ProjectNameSDK } from '..'
+
+
+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

@@ -0,0 +1,402 @@
+// VERSION: @voxgig/struct 0.0.4
+// 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'
+
+const NULLMARK = '__NULL__' // Value is JSON null
+const UNDEFMARK = '__UNDEF__' // Value is not present (thus, undefined).
+const EXISTSMARK = '__EXISTS__' // Value exists (not undefined).
+
+
+type Subject = (...args: any[]) => any
+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
+  runsetflags: RunSetFlags
+  subject: Subject
+  client: any
+}
+
+type TestPack = {
+  name?: string
+  client: any
+  subject: Subject
+  utility: any
+}
+
+type Flags = Record<string, boolean>
+
+
+type Utility = {
+  struct: any
+  contextify: (ctxmap: Record<string, any>) => any
+}
+
+type Client = {
+  utility: () => Utility
+}
+
+
+async function makeRunner(testfile: string, client: Client) {
+
+  return async function runner(
+    name: string,
+    store?: any,
+  ): Promise<RunPack> {
+    store = store || {}
+
+    const utility = client.utility()
+    const structUtils = utility.struct
+
+    let spec = resolveSpec(name, testfile)
+    let clients = await resolveClients(client, spec, store, structUtils)
+    let subject = resolveSubject(name, utility)
+
+    let runsetflags: RunSetFlags = async (
+      testspec: any,
+      flags: Flags,
+      testsubject: Function
+    ) => {
+      subject = testsubject || subject
+      flags = resolveFlags(flags)
+      const testspecmap = fixJSON(testspec, flags)
+
+      const testset: any[] = testspecmap.set
+      for (let entry of testset) {
+        try {
+          entry = resolveEntry(entry, flags)
+
+          let testpack = resolveTestPack(name, entry, subject, client, clients)
+          let args = resolveArgs(entry, testpack, utility, structUtils)
+
+          let res = await testpack.subject(...args)
+          res = fixJSON(res, flags)
+          entry.res = res
+
+          checkResult(entry, res, structUtils)
+        }
+        catch (err: any) {
+          if (err instanceof AssertionError) {
+            throw err
+          }
+          handleError(entry, err, structUtils)
+        }
+      }
+    }
+
+    let runset: RunSet = async (
+      testspec: any,
+      testsubject: Function
+    ) => runsetflags(testspec, {}, testsubject)
+
+    const runpack: RunPack = {
+      spec,
+      runset,
+      runsetflags,
+      subject,
+      client,
+    }
+
+    return runpack
+  }
+}
+
+function resolveSpec(name: string, testfile: string): Record<string, any> {
+  const alltests =
+    JSON.parse(readFileSync(join(
+      __dirname, testfile), 'utf8'))
+
+  let spec = alltests.primary?.[name] || alltests[name] || alltests
+  return spec
+}
+
+
+async function resolveClients(
+  client: any,
+  spec: Record<string, any>,
+  store: any,
+  structUtils: Record<string, any>
+):
+  Promise<Record<string, any>> {
+
+  const clients: Record<string, any> = {}
+  if (spec.DEF && spec.DEF.client) {
+    for (let cn in spec.DEF.client) {
+      const cdef = spec.DEF.client[cn]
+      const copts = cdef.test.options || {}
+      if ('object' === typeof store && structUtils?.inject) {
+        structUtils.inject(copts, store)
+      }
+
+      clients[cn] = await client.tester(copts)
+    }
+  }
+  return clients
+}
+
+
+function resolveSubject(name: string, container: any) {
+  const subject = container[name] || container.struct[name]
+  return subject
+}
+
+
+function resolveFlags(flags?: Flags): Flags {
+  if (null == flags) {
+    flags = {}
+  }
+  flags.null = null == flags.null ? true : !!flags.null
+  return flags
+}
+
+
+function resolveEntry(entry: any, flags: Flags): any {
+  entry.out = null == entry.out && flags.null ? NULLMARK : entry.out
+  return entry
+}
+
+
+function checkResult(entry: 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))
+  }
+
+  if (entry.match) {
+    const result = { in: entry.in, out: entry.res, ctx: entry.ctx }
+    match(
+      entry.match,
+      result,
+      structUtils
+    )
+
+    matched = true
+  }
+
+  const out = entry.out
+
+  if (out === res) {
+    return
+  }
+
+  // NOTE: allow match with no out.
+  if (matched && (NULLMARK === out || null == out)) {
+    return
+  }
+
+  deepEqual(null != res ? JSON.parse(JSON.stringify(res)) : res, entry.out)
+}
+
+
+// Handle errors from test execution
+function handleError(entry: any, err: any, structUtils: Record<string, any>) {
+  entry.thrown = err
+
+  const entry_err = entry.err
+
+  if (null != entry_err) {
+    if (true === entry_err || matchval(entry_err, err.message, structUtils)) {
+      if (entry.match) {
+        match(
+          entry.match,
+          { in: entry.in, out: entry.res, ctx: entry.ctx, err: fixJSON(err, { null: true }) },
+          structUtils
+        )
+      }
+      return
+    }
+
+    fail('ERROR MATCH: [' + structUtils.stringify(entry_err) +
+      '] <=> [' + err.message + ']')
+  }
+
+  // Unexpected error (test didn't specify an error expectation)
+  else if (err instanceof AssertionError) {
+    fail(err.message + '\n\nENTRY: ' + JSON.stringify(entry, null, 2))
+  }
+  else {
+    fail(err.stack + '\\nnENTRY: ' + JSON.stringify(entry, null, 2))
+  }
+}
+
+
+function resolveArgs(
+  entry: any,
+  testpack: TestPack,
+  utility: Utility,
+  structUtils: Record<string, any>
+): any[] {
+  let args: any[] = []
+
+  if (entry.ctx) {
+    args = [entry.ctx]
+  }
+  else if (entry.args) {
+    args = entry.args
+  }
+  else {
+    args = [structUtils.clone(entry.in)]
+  }
+
+  if (entry.ctx || entry.args) {
+    let first = args[0]
+    if (structUtils.ismap(first)) {
+      first = structUtils.clone(first)
+      first = utility.contextify(first)
+      args[0] = first
+      entry.ctx = first
+
+      first.client = testpack.client
+      first.utility = testpack.utility
+    }
+  }
+
+  return args
+}
+
+
+function resolveTestPack(
+  name: string,
+  entry: any,
+  subject: Subject,
+  client: any,
+  clients: Record<string, any>
+) {
+  const testpack: TestPack = {
+    name,
+    client,
+    subject,
+    utility: client.utility(),
+  }
+
+  if (entry.client) {
+    testpack.client = clients[entry.client]
+    testpack.utility = testpack.client.utility()
+    testpack.subject = resolveSubject(name, testpack.utility)
+  }
+
+  return testpack
+}
+
+
+function match(
+  check: any,
+  basex: any,
+  structUtils: Record<string, any>
+) {
+  const cbase = structUtils.clone(basex)
+
+  structUtils.walk(check, (_key: any, val: any, _parent: any, path: any) => {
+    if (!structUtils.isnode(val)) {
+      let baseval = structUtils.getpath(cbase, path)
+
+      if (baseval === val) {
+        return val
+      }
+
+      // Explicit undefined expected
+      if (UNDEFMARK === val && undefined === baseval) {
+        return val
+      }
+
+      // Explicit defined expected
+      if (EXISTSMARK === val && null != baseval) {
+        return val
+      }
+
+      if (!matchval(val, baseval, structUtils)) {
+        fail('MATCH: ' + path.join('.') +
+          ': [' + structUtils.stringify(val) +
+          '] <=> [' + structUtils.stringify(baseval) + ']')
+      }
+    }
+
+    return val
+  })
+}
+
+
+function matchval(
+  check: any,
+  base: any,
+  structUtils: Record<string, any>
+) {
+  let pass = check === base
+
+  if (!pass) {
+
+    if ('string' === typeof check) {
+      let basestr = structUtils.stringify(base)
+
+      let rem = check.match(/^\/(.+)\/$/)
+      if (rem) {
+        pass = new RegExp(rem[1]).test(basestr)
+      }
+      else {
+        pass = basestr.toLowerCase().includes(structUtils.stringify(check).toLowerCase())
+      }
+    }
+    else if ('function' === typeof check) {
+      pass = true
+    }
+  }
+
+  return pass
+}
+
+
+function fixJSON(val: any, flags?: Flags): any {
+  if (null == val) {
+    return flags?.null ? NULLMARK : val
+  }
+
+  const replacer = (_k: string, v: any) => {
+    if (null == v && flags?.null) {
+      return NULLMARK
+    }
+
+    if (v instanceof Error) {
+      return {
+        ...v,
+        name: v.name,
+        message: v.message,
+      }
+    }
+
+    return v
+  }
+
+  return JSON.parse(JSON.stringify(val, replacer))
+}
+
+
+function nullModifier(
+  val: any,
+  key: any,
+  parent: any
+) {
+  if ("__NULL__" === val) {
+    parent[key] = null
+  }
+  else if ('string' === typeof val) {
+    parent[key] = val.replaceAll('__NULL__', 'null')
+  }
+}
+
+
+export {
+  NULLMARK,
+  EXISTSMARK,
+  nullModifier,
+  makeRunner,
+}
+

package/project/.sdk/tm/ts/test/tsconfig.json

@@ -8,6 +8,6 @@
     "resolveJsonModule": true,
     "sourceMap": true,
     "strict": true,
-    "target": "ES2021"
+    "target": "ES2022"
   }
 }

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

@@ -0,0 +1,62 @@
+
+import { test, describe } from 'node:test'
+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 u: any = client.utility()
+
+    equal(u.auth().util, 'AUTH')
+    equal(u.body().util, 'BODY')
+    equal(u.contextify().util, 'CONTEXTIFY')
+    equal(u.done().util, 'DONE')
+    equal(u.error().util, 'ERROR')
+    equal(u.findparam().util, 'FINDPARAM')
+    equal(u.fullurl().util, 'FULLURL')
+    equal(u.headers().util, 'HEADERS')
+    equal(u.method().util, 'METHOD')
+    equal(u.operator().util, 'OPERATOR')
+    equal(u.params().util, 'PARAMS')
+    equal(u.query().util, 'QUERY')
+    equal(u.reqform().util, 'REQFORM')
+    equal(u.resbasic().util, 'RESBASIC')
+    equal(u.resbody().util, 'RESBODY')
+    equal(u.resform().util, 'RESFORM')
+    equal(u.resheaders().util, 'RESHEADERS')
+    equal(u.response().util, 'RESPONSE')
+    equal(u.result().util, 'RESULT')
+    equal(u.spec().util, 'SPEC')
+  })
+})