@voxgig/sdkgen 0.25.0 → 0.28.0

package/project/.sdk/src/cmp/ts/Package_ts.ts

@@ -1,14 +1,28 @@
 
 import {
-  cmp, omap, each, cmap,
-  File, Content,
+  Content,
+  File,
+  cmp,
+  each,
+  omap,
 } from '@voxgig/sdkgen'
 
 
+import {
+  KIT,
+  Model,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
 
 const Package = cmp(async function Package(props: any) {
-  const { target, ctx$: { model } } = props
-  const { main: { sdk: { feature } } } = model
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const feature = getModelPath(model, `main.${KIT}.feature`)
 
   const only = (kind: string, deps: any) =>
     omap(deps, ([k, v]: any) => [v.active && kind === v.kind ? k : undefined, v.version])
@@ -18,7 +32,9 @@ const Package = cmp(async function Package(props: any) {
     each(feature, (feature: any) =>
       omap(feature.deps?.[target.name], ([k, v]: any) =>
         [v.active ? k : undefined, v]))
+
       // TODO: sort by version; rules for version choice?
+      // TODO: non-node dep kinds
       .reduce((a: any, deps: any) => (each(deps, (dep: any) =>
         a[dep.kind][dep.key$] = dep.version), a),
         {
@@ -28,6 +44,7 @@ const Package = cmp(async function Package(props: any) {
         })
 
   const sdkname = model.name
+  const SdkName = nom(model, 'Name')
   const origin = null == model.origin ? '' : `@${model.origin}/`
   const sdknamesuffix = model.origin?.endsWith('-sdk') ? '' : '-sdk'
 
@@ -36,13 +53,13 @@ const Package = cmp(async function Package(props: any) {
     name: `${origin}${sdkname}${sdknamesuffix}`,
     version: `0.0.1`,
     description: 'DESCRIPTION',
-    main: `dist/${model.const.Name}SDK.js`,
+    main: `dist/${SdkName}SDK.js`,
     type: 'commonjs',
-    types: `dist/${model.const.Name}SDK.d.ts`,
+    types: `dist/${SdkName}SDK.d.ts`,
     scripts: {
-      'test': 'node --enable-source-maps --test dist-test/**/*.test.js',
-      'test-some': 'node --enable-source-maps ' +
-        '--test-name-pattern=\"$npm_config_pattern\" --test dist-test/**/*.test.js',
+      'test': 'node --enable-source-maps --test \'dist-test/**/*.test.js\'',
+      'test-some': 'node --enable-source-maps --experimental-test-isolation=none ' +
+        '--test-name-pattern=\"$TEST_PATTERN\" --test \'dist-test/**/*.test.js\'',
       'test-utility': 'node --enable-source-maps --test test/utility/*.test.ts',
 
       "watch": "tsc --build src test -w",
@@ -50,14 +67,16 @@ const Package = cmp(async function Package(props: any) {
       "clean": "rm -rf node_modules yarn.lock package-lock.json",
       "reset": "npm run clean && npm i && npm run build && npm test",
     },
-    author: `${model.const.Name}`,
+    author: `${SdkName}`,
+
+    // TODO: needs to be config
     license: 'MIT',
+
     dependencies: deps.prod,
     peerDependencies: deps.peer,
     devDependencies: deps.dev,
   }
 
-
   File({ name: 'package.json' }, () => {
     Content(JSON.stringify(pkg, null, 2))
   })

package/project/.sdk/src/cmp/ts/SdkError_ts.ts

@@ -0,0 +1,42 @@
+
+import * as Path from 'node:path'
+
+
+import {
+  File,
+  Fragment,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+
+
+const SdkError = cmp(async function SdkError(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/ts/fragment/')
+
+  File({ name: model.const.Name + 'Error.' + target.ext }, () => {
+
+    Fragment({
+      from: ff + 'SdkError.fragment.ts',
+
+      replace: {
+        ...ctx$.stdrep,
+      }
+    })
+  })
+})
+
+
+export {
+  SdkError
+}

package/project/.sdk/src/cmp/ts/TestDirect_ts.ts

@@ -0,0 +1,288 @@
+
+import {
+  nom,
+} from '@voxgig/apidef'
+
+
+import {
+  Content,
+  File,
+  Folder,
+  Fragment,
+  Slot,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+import {
+  projectPath
+} from './utility_ts'
+
+
+const TestDirect = cmp(function TestDirect(props: any) {
+  const ctx$ = props.ctx$
+  const model = ctx$.model
+  const stdrep = ctx$.stdrep
+
+  const target = props.target
+  const entity = props.entity
+
+  const ff = projectPath('src/cmp/ts/fragment/')
+
+  const PROJECTNAME = model.Name.toUpperCase()
+  const entidEnvVar = `${PROJECTNAME}_TEST_${entity.Name.toUpperCase()}_ENTID`
+
+  const opnames = Object.keys(entity.op)
+  const hasLoad = opnames.includes('load')
+  const hasList = opnames.includes('list')
+
+  if (!hasLoad && !hasList) {
+    return
+  }
+
+  Folder({ name: entity.name }, () => {
+
+    File({ name: nom(entity, 'Name') + 'Direct.test.' + target.name }, () => {
+
+      Fragment({
+        from: ff + 'Direct.test.fragment.ts',
+        replace: {
+          SdkName: nom(model.const, 'Name'),
+          EntityName: nom(entity, 'Name'),
+          entityname: entity.name,
+          ...stdrep,
+        }
+      }, () => {
+
+
+        Slot({ name: 'directSetup' }, () => {
+          Content(`
+function directSetup(mockres?: any) {
+  const calls: any[] = []
+
+  const env = envOverride({
+    '${entidEnvVar}': {},
+    '${PROJECTNAME}_TEST_LIVE': 'FALSE',
+    '${PROJECTNAME}_APIKEY': 'NONE',
+  })
+
+  const live = 'TRUE' === env.${PROJECTNAME}_TEST_LIVE
+
+  if (live) {
+    const client = new ${nom(model.const, 'Name')}SDK({
+      apikey: env.${PROJECTNAME}_APIKEY,
+    })
+
+    let idmap: any = env['${entidEnvVar}']
+    if ('string' === typeof idmap && idmap.startsWith('{')) {
+      idmap = JSON.parse(idmap)
+    }
+
+    return { client, calls, live, idmap }
+  }
+
+  const mockFetch = async (url: string, init: any) => {
+    calls.push({ url, init })
+    return {
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+      json: async () => (null != mockres ? mockres : { id: 'direct01' }),
+    }
+  }
+
+  const client = new ${nom(model.const, 'Name')}SDK({
+    base: 'http://localhost:8080',
+    system: { fetch: mockFetch },
+  })
+
+  return { client, calls, live, idmap: {} as any }
+}
+  `)
+        })
+
+
+        Slot({ name: 'direct' }, () => {
+
+          if (hasLoad) {
+            generateDirectLoad(model, entity)
+          }
+
+          if (hasList) {
+            generateDirectList(model, entity)
+          }
+        })
+
+      })
+    })
+  })
+})
+
+
+function generateDirectLoad(model: any, entity: any) {
+  const loadOp = entity.op.load
+  const loadTarget = loadOp.targets[0]
+
+  if (null == loadTarget) {
+    return
+  }
+
+  const loadPath = (loadTarget.parts || []).join('/')
+  const loadParams = loadTarget.args?.params || []
+
+  // Get list info for live mode bootstrapping
+  const listOp = entity.op.list
+  const listTarget = listOp?.targets?.[0]
+  const listPath = listTarget ? (listTarget.parts || []).join('/') : ''
+  const listParams = listTarget?.args?.params || []
+  const hasList = null != listTarget
+
+  // Ancestor params (not 'id') for live mode
+  const ancestorParams = loadParams.filter((p: any) => p.name !== 'id')
+
+  const paramAsserts = loadParams.map((p: any, i: number) =>
+    '      assert(calls[0].url.includes(\'direct0' + (i + 1) + '\'))\n').join('')
+
+  // Build live list params
+  const liveListParams = listParams.map((p: any) => {
+    const key = p.name === 'id'
+      ? entity.name + '01'
+      : p.name.replace(/_id$/, '') + '01'
+    return { name: p.name, key }
+  })
+
+  // Build live ancestor params for load
+  const liveAncestorParams = ancestorParams.map((p: any) => {
+    const key = p.name.replace(/_id$/, '') + '01'
+    return { name: p.name, key }
+  })
+
+  let liveParamsBlock = ''
+  if (hasList) {
+    const listParamLines = liveListParams.map((lp: any) =>
+      `        ${lp.name}: setup.idmap['${lp.key}'],`).join('\n')
+    const ancestorParamLines = liveAncestorParams.map((lp: any) =>
+      `      params.${lp.name} = setup.idmap['${lp.key}']`).join('\n')
+
+    liveParamsBlock = `    if (setup.live) {
+      const listResult: any = await client.direct({
+        path: '${listPath}',
+        method: 'GET',
+        params: {
+${listParamLines}
+        },
+      })
+      assert(listResult.ok === true)
+      const listData = listResult.data
+      if (!Array.isArray(listData) || listData.length === 0) {
+        return // skip: no entities to load in live mode
+      }
+      params.id = listData[0].id
+${ancestorParamLines}
+    } else {
+${loadParams.map((p: any, i: number) => `      params.${p.name} = 'direct0${i + 1}'`).join('\n')}
+    }`
+  } else {
+    liveParamsBlock = `    if (!setup.live) {
+${loadParams.map((p: any, i: number) => `      params.${p.name} = 'direct0${i + 1}'`).join('\n')}
+    }`
+  }
+
+  Content(`
+  test('direct-load-${entity.name}', async () => {
+    const setup = directSetup({ id: 'direct01' })
+    const { client, calls } = setup
+
+    const params: any = {}
+${liveParamsBlock}
+
+    const result: any = await client.direct({
+      path: '${loadPath}',
+      method: 'GET',
+      params,
+    })
+
+    assert(result.ok === true)
+    assert(result.status === 200)
+    assert(null != result.data)
+
+    if (!setup.live) {
+      assert(result.data.id === 'direct01')
+      assert(calls.length === 1)
+      assert(calls[0].init.method === 'GET')
+${paramAsserts}    }
+  })
+`)
+}
+
+
+function generateDirectList(model: any, entity: any) {
+  const listOp = entity.op.list
+  const listTarget = listOp.targets[0]
+
+  if (null == listTarget) {
+    return
+  }
+
+  const listPath = (listTarget.parts || []).join('/')
+  const listParams = listTarget.args?.params || []
+
+  // Build live params
+  const liveParams = listParams.map((p: any) => {
+    const key = p.name === 'id'
+      ? entity.name + '01'
+      : p.name.replace(/_id$/, '') + '01'
+    return { name: p.name, key }
+  })
+
+  const paramAsserts = listParams.map((p: any, i: number) =>
+    '      assert(calls[0].url.includes(\'direct0' + (i + 1) + '\'))\n').join('')
+
+  let paramsBlock = ''
+  if (listParams.length > 0) {
+    const liveLines = liveParams.map((lp: any) =>
+      `      params.${lp.name} = setup.idmap['${lp.key}']`).join('\n')
+    const mockLines = listParams.map((p: any, i: number) =>
+      `      params.${p.name} = 'direct0${i + 1}'`).join('\n')
+
+    paramsBlock = `    const params: any = {}
+    if (setup.live) {
+${liveLines}
+    } else {
+${mockLines}
+    }
+`
+  } else {
+    paramsBlock = `    const params: any = {}
+`
+  }
+
+  Content(`
+  test('direct-list-${entity.name}', async () => {
+    const setup = directSetup([{ id: 'direct01' }, { id: 'direct02' }])
+    const { client, calls } = setup
+
+${paramsBlock}
+    const result: any = await client.direct({
+      path: '${listPath}',
+      method: 'GET',
+      params,
+    })
+
+    assert(result.ok === true)
+    assert(result.status === 200)
+    assert(Array.isArray(result.data))
+
+    if (!setup.live) {
+      assert(result.data.length === 2)
+      assert(calls.length === 1)
+      assert(calls[0].init.method === 'GET')
+${paramAsserts}    }
+  })
+`)
+}
+
+
+export {
+  TestDirect
+}