@voxgig/sdkgen 0.26.1 → 0.28.0

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

@@ -1,6 +1,7 @@
 
 import { test, describe, before } from 'node:test'
-import { equal } from 'node:assert'
+import { equal, deepStrictEqual, ok } from 'node:assert'
+import assert from 'node:assert'
 
 import {
   makeRunner,
@@ -12,239 +13,449 @@ import {
 } from './index'
 
 
-
 describe('PrimaryUtility', async () => {
 
+  let spec: any
+  let runset: any
+  let runsetflags: any
   let client: any
-  let runner: any
-  let runners: any
+  let utility: any
+  let struct: any
+
+
+  // Ensure ctx has options derived from client when needed.
+  function fixctx(ctx: any) {
+    if (ctx && ctx.client && null == ctx.options) {
+      ctx.options = ctx.client.options()
+    }
+  }
+
 
   before(async () => {
-    client = SDK.test()
-    runner = await makeRunner(TEST_JSON_FILE, client)
-
-    runners = {
-      auth: await runner('auth'),
-      body: await runner('body'),
-      // makeContext: await runner('makeContext'),
-      done: await runner('done'),
-      error: await runner('error'),
-      findparam: await runner('findparam'),
-      fullurl: await runner('fullurl'),
-      headers: await runner('headers'),
-      method: await runner('method'),
-      operator: await runner('operator'),
-      options: await runner('options'),
-      params: await runner('params'),
-      query: await runner('query'),
-      reqform: await runner('reqform'),
-      request: await runner('request', { fetch: MockFetch }),
-      resbasic: await runner('resbasic'),
-      resbody: await runner('resbody'),
-      resform: await runner('resform'),
-      resheaders: await runner('resheaders'),
-      response: await runner('response'),
-      spec: await runner('spec'),
+    const runner = await makeRunner(TEST_JSON_FILE, await SDK.test())
+    const run = await runner('primary')
+
+    spec = run.spec
+    runset = run.runset
+    runsetflags = run.runsetflags
+    client = run.client
+    utility = client.utility()
+    struct = utility.struct
+  })
+
+
+  test('exists', () => {
+    const fns = [
+      'clean', 'done', 'makeError', 'featureAdd', 'featureHook', 'featureInit',
+      'fetcher', 'makeFetchDef', 'makeContext', 'makeOptions', 'makeRequest',
+      'makeResponse', 'makeResult', 'makeTarget', 'makeSpec', 'makeUrl',
+      'param', 'prepareAuth', 'prepareBody', 'prepareHeaders', 'prepareMethod',
+      'prepareParams', 'preparePath', 'prepareQuery', 'resultBasic',
+      'resultBody', 'resultHeaders', 'transformRequest', 'transformResponse',
+    ]
+
+    for (const fn of fns) {
+      equal('function', typeof utility[fn], fn + ' should be a function')
     }
+  })
+
+
+  test('context-basic', async () => {
+    await runset(spec.makeContext.basic, utility.makeContext)
+  })
+
+
+  test('method-basic', async () => {
+    await runset(spec.prepareMethod.basic, utility.prepareMethod)
+  })
+
+
+  test('headers-basic', async () => {
+    await runset(spec.prepareHeaders.basic, utility.prepareHeaders)
+  })
+
+
+  test('auth-basic', async () => {
+    const sdkopts = spec.prepareAuth?.DEF?.setup?.a || {}
+    const authClient = SDK.test({}, sdkopts)
+    await runset(spec.prepareAuth.basic, (ctx: any) => {
+      ctx.client = authClient
+      fixctx(ctx)
+      return utility.prepareAuth(ctx)
+    })
+  })
+
+
+  test('params-basic', async () => {
+    await runset(spec.prepareParams.basic, utility.prepareParams)
+  })
+
+
+  test('query-basic', async () => {
+    await runset(spec.prepareQuery.basic, utility.prepareQuery)
+  })
+
+
+  test('body-basic', async () => {
+    await runset(spec.prepareBody.basic, (ctx: any) => {
+      fixctx(ctx)
+      return utility.prepareBody(ctx)
+    })
+  })
+
+
+  test('findparam-basic', async () => {
+    await runset(spec.param.basic, utility.param)
+  })
+
+
+  test('fullurl-basic', async () => {
+    await runset(spec.makeUrl.basic, utility.makeUrl)
+  })
+
+
+  test('operator-basic', async () => {
+    await runset(spec.operator.basic, (opmap: any) => ({
+      entity: opmap.entity || '_',
+      name: opmap.name || '_',
+      input: opmap.input || '_',
+      targets: opmap.targets || [],
+    }))
+  })
+
+
+  test('options-basic', async () => {
+    await runset(spec.makeOptions.basic, (vin: any) => {
+      const ctx = utility.makeContext({ options: vin.options, config: vin.config })
+      ctx.client = client
+      ctx.utility = utility
+      return utility.makeOptions(ctx)
+    })
+  })
+
 
+  test('spec-basic', async () => {
+    const sdkopts = spec.makeSpec?.DEF?.setup?.a || {}
+    const specClient = SDK.test({}, sdkopts)
+    await runset(spec.makeSpec.basic, (ctx: any) => {
+      ctx.client = specClient
+      ctx.options = specClient.options()
+      return utility.makeSpec(ctx)
+    })
   })
 
 
-  async function MockFetch(url: string, fetchdef: any) {
-    return {
+  test('reqform-basic', async () => {
+    await runset(spec.transformRequest.basic, utility.transformRequest)
+  })
+
+
+  test('resform-basic', async () => {
+    await runset(spec.transformResponse.basic, utility.transformResponse)
+  })
+
+
+  test('resbasic-basic', async () => {
+    await runset(spec.resultBasic.basic, (ctx: any) => {
+      fixctx(ctx)
+      return utility.resultBasic(ctx)
+    })
+  })
+
+
+  test('resheaders-basic', async () => {
+    await runset(spec.resultHeaders.basic, (ctx: any) => {
+      // Convert plain headers map to forEach-based (browser Response API)
+      if (ctx.response?.headers && !ctx.response.headers.forEach) {
+        const h = ctx.response.headers
+        ctx.response.headers = {
+          forEach: (cb: any) => Object.entries(h).forEach(([k, v]) => cb(v, k.toLowerCase()))
+        }
+      }
+      return utility.resultHeaders(ctx)
+    })
+  })
+
+
+  test('resbody-basic', async () => {
+    await runset(spec.resultBody.basic, async (ctx: any) => {
+      if (ctx.response && !ctx.response.json) {
+        const body = ctx.response.body
+        ctx.response.json = async () => body
+      }
+      return utility.resultBody(ctx)
+    })
+  })
+
+
+  test('request-basic', async () => {
+    const mockFetch = async (url: string, init: any) => ({
       status: 200,
       statusText: 'OK',
-    }
-  }
+      headers: { forEach: (cb: any) => { cb('application/json', 'content-type', {}) } },
+      json: async () => ({ id: 'res01' }),
+      body: 'present',
+    })
+    const reqClient = new (SDK as any)({
+      system: { fetch: mockFetch }
+    })
+    const reqUtility = reqClient.utility()
+    await runset(spec.makeRequest.basic, async (ctx: any) => {
+      ctx.client = reqClient
+      ctx.utility = reqUtility
+      ctx.options = reqClient.options()
+      return reqUtility.makeRequest(ctx)
+    })
+  })
 
 
-  function MockResponse(resdef: any) {
-    const mres = {
-      native: {
-        status: resdef.native.status,
-        statusText: resdef.native.reason,
-        json: async () => resdef.native.body,
-        headers: {
-          forEach(callback: any) {
-            Object.keys(resdef.native.headers).forEach((key) => {
-              callback(resdef.native.headers[key], key, this)
-            })
-          }
+  test('response-basic', async () => {
+    await runset(spec.makeResponse.basic, async (ctx: any) => {
+      fixctx(ctx)
+      // Add json() and forEach to response for proper TS handling
+      if (ctx.response && !ctx.response.json) {
+        const body = ctx.response.body
+        ctx.response.json = async () => body
+      }
+      if (ctx.response?.headers && !ctx.response.headers.forEach) {
+        const h = ctx.response.headers
+        ctx.response.headers = {
+          forEach: (cb: any) => Object.entries(h).forEach(([k, v]) => cb(v, k.toLowerCase()))
         }
-      },
-      err: resdef.err
-    }
-    return mres
-  }
+      }
+      return utility.makeResponse(ctx)
+    })
+  })
 
 
-  test('exists', async () => {
-    equal('function', typeof runners.auth.subject)
-    equal('function', typeof runners.body.subject)
-    // equal('function', typeof runners.makeContext.subject)
-    equal('function', typeof runners.done.subject)
-    equal('function', typeof runners.error.subject)
-    equal('function', typeof runners.findparam.subject)
-    equal('function', typeof runners.fullurl.subject)
-    equal('function', typeof runners.method.subject)
-    // equal('function', typeof runners.operator.subject)
-    equal('function', typeof runners.options.subject)
-    equal('function', typeof runners.params.subject)
-    equal('function', typeof runners.query.subject)
-    equal('function', typeof runners.reqform.subject)
-    equal('function', typeof runners.request.subject)
-    equal('function', typeof runners.resbasic.subject)
-    equal('function', typeof runners.resbody.subject)
-    equal('function', typeof runners.resform.subject)
-    equal('function', typeof runners.resheaders.subject)
-    equal('function', typeof runners.response.subject)
-    equal('function', typeof runners.spec.subject)
+  test('done-basic', async () => {
+    await runset(spec.done.basic, (ctx: any) => {
+      fixctx(ctx)
+      return utility.done(ctx)
+    })
   })
 
 
-  // test('auth-basic', async () => {
-  //   const { runset, spec, subject } = runners.auth
-  //   await runset(spec.basic, undefined, (subject: any) => (vin: any) => {
-  //     return subject(vin, vin.spec)
-  //   })
-  // })
+  test('error-basic', async () => {
+    await runset(spec.makeError.basic, (...args: any[]) => {
+      const ctx = args[0]
+      fixctx(ctx)
+      return utility.makeError(...args)
+    })
+  })
 
 
-  // // NOTE: the name utilbody avoids conflict with resbody when running individual tests.
-  // test('utilbody-basic', async () => {
-  //   const { runset, spec, subject } = runners.body
-  //   await runset(spec.basic, subject)
-  // })
+  test('makeTarget-single', () => {
+    const ctx = makeCtx()
+    const target = {
+      parts: ['items', '{id}'],
+      args: { params: [] },
+      params: [],
+      alias: {},
+      select: {},
+      active: true,
+      transform: { req: undefined, res: undefined },
+    }
+    ctx.op.targets = [target]
 
+    const result = utility.makeTarget(ctx)
+    ok(!(result instanceof Error))
+    equal(ctx.target, target)
+  })
 
-  // test('makeContext-basic', async () => {
-  //   const { runset, spec, subject } = runners.makeContext
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('makeFetchDef', () => {
+    const ctx = makeFullCtx()
+    ctx.spec = {
+      base: 'http://localhost:8080',
+      prefix: '/api',
+      path: 'items/{id}',
+      suffix: '',
+      params: { id: 'item01' },
+      query: {},
+      headers: { 'content-type': 'application/json' },
+      method: 'GET',
+      step: 'start',
+      body: undefined,
+    } as any
+
+    const fetchdef = utility.makeFetchDef(ctx)
+    ok(!(fetchdef instanceof Error), 'should not be error')
+    equal(fetchdef.method, 'GET')
+    ok(fetchdef.url.includes('/api/items/item01'))
+    equal(fetchdef.headers['content-type'], 'application/json')
+    ok(null == fetchdef.body)
+  })
 
-  // test('done-basic', async () => {
-  //   const { runset, spec, subject } = runners.done
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('makeFetchDef-with-body', () => {
+    const ctx = makeFullCtx()
+    ctx.spec = {
+      base: 'http://localhost:8080',
+      prefix: '',
+      path: 'items',
+      suffix: '',
+      params: {},
+      query: {},
+      headers: {},
+      method: 'POST',
+      step: 'start',
+      body: { name: 'test' },
+    } as any
+
+    const fetchdef = utility.makeFetchDef(ctx)
+    ok(!(fetchdef instanceof Error))
+    equal(fetchdef.method, 'POST')
+    equal(fetchdef.body, JSON.stringify({ name: 'test' }, null, 2))
+  })
 
-  // test('error-basic', async () => {
-  //   const { runset, spec, subject } = runners.error
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('featureAdd', () => {
+    const ctx = makeCtx()
+    const startLen = client._features.length
 
-  // test('findparam-basic', async () => {
-  //   const { runset, spec, subject } = runners.findparam
-  //   await runset(spec.basic, subject)
-  // })
+    const feature = {
+      version: '0.0.1',
+      name: 'testfeat',
+      active: true,
+      init: () => { },
+    }
 
+    utility.featureAdd(ctx, feature)
+    equal(client._features.length, startLen + 1)
+    equal(client._features[client._features.length - 1].name, 'testfeat')
+  })
 
-  // test('fullurl-basic', async () => {
-  //   const { runset, spec, subject } = runners.fullurl
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('featureHook', () => {
+    const ctx = makeCtx()
 
-  // test('utilheaders-basic', async () => {
-  //   const { runset, spec, subject } = runners.headers
-  //   await runset(spec.basic, subject)
-  // })
+    let called = false
+    client._features = [{
+      name: 'hookfeat',
+      TestHook: () => { called = true },
+    }]
 
+    utility.featureHook(ctx, 'TestHook')
+    equal(called, true)
+  })
 
-  // test('method-basic', async () => {
-  //   const { runset, spec, subject } = runners.method
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('featureInit', () => {
+    const ctx = makeCtx()
 
-  // test('operator-basic', async () => {
-  //   const { runset, spec, subject } = runners.operator
-  //   await runset(spec.basic, subject)
-  // })
+    let initCalled = false
+    const feature: any = {
+      name: 'initfeat',
+      active: true,
+      init: () => { initCalled = true },
+    }
 
+    ctx.options.feature.initfeat = { active: true }
 
-  // test('options-basic', async () => {
-  //   const { runset, spec, subject, client } = runners.options
-  //   await runset(spec.basic, (vin: any) => {
-  //     vin.prep.utility = client.utility()
-  //     return subject(vin.prep)
-  //   })
-  // })
+    utility.featureInit(ctx, feature)
+    equal(initCalled, true)
+  })
 
 
-  // test('params-basic', async () => {
-  //   const { runset, spec, subject } = runners.params
-  //   await runset(spec.basic, subject)
-  // })
+  test('featureInit-inactive', () => {
+    const ctx = makeCtx()
 
+    let initCalled = false
+    const feature: any = {
+      name: 'nofeat',
+      active: false,
+      init: () => { initCalled = true },
+    }
 
-  // test('query-basic', async () => {
-  //   const { runset, spec, subject } = runners.query
-  //   await runset(spec.basic, subject)
-  // })
+    ctx.options.feature.nofeat = { active: false }
 
+    utility.featureInit(ctx, feature)
+    equal(initCalled, false)
+  })
 
-  // test('reqform-basic', async () => {
-  //   const { runset, spec, subject } = runners.reqform
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('fetcher-live', async () => {
+    const calls: any[] = []
+    const liveClient = new (SDK as any)({
+      system: {
+        fetch: async (url: string, init: any) => {
+          calls.push({ url, init })
+          return { status: 200, statusText: 'OK' }
+        }
+      }
+    })
+    const liveUtility = liveClient.utility()
+    const ctx = liveUtility.makeContext({ opname: 'load' }, liveClient._rootctx)
+    ctx.client = liveClient
+
+    const fetchdef = { method: 'GET', headers: {} }
+    const response = await liveUtility.fetcher(ctx, 'http://example.com/test', fetchdef)
+    ok(!(response instanceof Error))
+    equal(calls.length, 1)
+    equal(calls[0].url, 'http://example.com/test')
+  })
 
-  // test('request-basic', async () => {
-  //   const { runset, spec, subject } = runners.request
-  //   await runset(spec.basic, subject)
-  // })
 
+  test('fetcher-blocked-test-mode', async () => {
+    const blockedClient = new (SDK as any)({
+      system: { fetch: async () => ({}) }
+    })
+    blockedClient._mode = 'test'
 
-  // test('resbasic-basic', async () => {
-  //   const { runset, spec, subject } = runners.resbasic
-  //   await runset(spec.basic, (ctx: any) => {
-  //     ctx.response = MockResponse(ctx.response)
-  //     return subject(ctx)
-  //   })
-  // })
+    const blockedUtility = blockedClient.utility()
+    const ctx = blockedUtility.makeContext({ opname: 'load' }, blockedClient._rootctx)
+    ctx.client = blockedClient
+    const fetchdef = { method: 'GET', headers: {} }
 
+    const result = await blockedUtility.fetcher(ctx, 'http://example.com/test', fetchdef)
+    ok(result instanceof Error)
+    ok((result as Error).message.includes('mode'))
+  })
 
-  // test('resbody-basic', async () => {
-  //   const { runset, spec, subject } = runners.resbody
-  //   await runset(spec.basic, (ctx: any) => {
-  //     ctx.response = MockResponse(ctx.response)
-  //     return subject(ctx)
-  //   })
-  // })
 
+  test('makeError-no-throw', () => {
+    const ctx = makeFullCtx()
+    ctx.ctrl.throw = false
+    ctx.result = { ok: false, resdata: { id: 'safe01' } } as any
 
-  // test('resform-basic', async () => {
-  //   const { runset, spec, subject } = runners.resform
-  //   await runset(spec.basic, subject)
-  // })
+    const out = utility.makeError(ctx, ctx.error('test_code', 'test message'))
+    deepStrictEqual(out, { id: 'safe01' })
+  })
 
 
-  // test('resheaders-basic', async () => {
-  //   const { runset, spec, subject } = runners.resheaders
-  //   await runset(spec.basic, (ctx: any) => {
-  //     ctx.response = MockResponse(ctx.response)
-  //     return subject(ctx)
-  //   })
-  // })
+  test('clean', () => {
+    const ctx = makeFullCtx()
+    const val = { key: 'secret123', name: 'test' }
+    const cleaned = utility.clean(ctx, val)
+    ok(null != cleaned)
+  })
 
 
-  // test('response-basic', async () => {
-  //   const { runset, spec, subject } = runners.response
-  //   await runset(spec.basic, (ctx: any) => {
-  //     ctx.response = MockResponse(ctx.response)
-  //     return subject(ctx)
-  //   })
-  // })
+  // Helper functions for manual tests
+  function makeCtx(overrides?: any) {
+    return utility.makeContext({
+      opname: 'load',
+      ...overrides,
+    }, client._rootctx)
+  }
 
 
-  // test('spec-basic', async () => {
-  //   const { runset, spec, subject } = runners.spec
-  //   await runset(spec.basic, subject)
-  // })
+  function makeFullCtx(overrides?: any) {
+    const ctx = makeCtx(overrides)
+    ctx.target = {
+      parts: ['items', '{id}'],
+      args: { params: [{ name: 'id', reqd: true }] },
+      params: ['id'],
+      alias: {},
+      select: {},
+      active: true,
+      relations: [],
+      transform: { req: undefined, res: undefined },
+    }
+    ctx.match = { id: 'item01' }
+    ctx.reqmatch = { id: 'item01' }
+    return ctx
+  }
 
 })
-
-

package/src/cmp/Feature.ts

@@ -5,16 +5,18 @@ const Feature = cmp(function Feature(props: any) {
   const { target, feature, ctx$ } = props
   const { log } = ctx$
 
-  Folder({ name: 'src/feature/' + feature.name }, () => {
-    // TODO: Copy should just warn if from not found
-    Copy({
-      from: 'tm/' + target.name + '/src/feature/' + feature.name,
-      replace: {
-        FEATURE_VERSION: feature.version,
-        FEATURE_Name: feature.Name,
-      }
+  if (false !== target.srcfeature) {
+    Folder({ name: 'src/feature/' + feature.name }, () => {
+      // TODO: Copy should just warn if from not found
+      Copy({
+        from: 'tm/' + target.name + '/src/feature/' + feature.name,
+        replace: {
+          FEATURE_VERSION: feature.version,
+          FEATURE_Name: feature.Name,
+        }
+      })
     })
-  })
+  }
 
   log.info({
     point: 'generate-feature', target, feature,