@voxgig/sdkgen 0.15.0 → 0.17.0

package/project/generate/src/cmp/js/Entity_js.ts

@@ -0,0 +1,91 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each, camelify,
+  File, Content, Folder, Fragment, Line, FeatureHook,
+} from '@voxgig/sdkgen'
+
+
+
+const Operation = cmp(function Operation(props: any) {
+  // console.log('OP', props)
+
+  const { ff, opname, indent, entity } = props
+
+  const entop = entity.op[opname]
+  const path = entop.path
+  // console.log('ENTOP', entop)
+
+  // TODO: move up to to common Entity
+  const params = JSON.stringify(path
+    .match(/\{[^}]+\}/g)
+    .map((p: string) => p.substring(1, p.length - 1))
+    .filter((p: string) => null != p && '' !== p))
+
+  const hasp = '' != entop.place
+
+  Fragment({
+    from: ff + '/Entity' + camelify(opname) + 'Op.fragment.js',
+    indent,
+    replace: {
+      Name: entity.Name,
+      PATH: entop.path,
+      "['PARAM']": params,
+      "'INWARD'":
+        entop.inward ||
+        'ctx.result.body' + ('' === entop.place ? '' : '.' + entop.place),
+      "'OUTWARD'":
+        entop.outward ||
+        (hasp ? '({' + entop.place + ': ' : '') + 'ctx.op.data' + (hasp ? '})' : ''),
+
+      'class EntityOperation { // REMOVED': '',
+      '} // REMOVED': '',
+
+      '#Feature-Hook': ({ name, indent }: any) =>
+        FeatureHook({ name }, (f: any) =>
+          Line({ indent },
+            `${f.await ? 'await ' : ''}this.#features.${f.name}.${name}(ctx)`)),
+    }
+  })
+})
+
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { target, entity } = props
+  // const { model } = props.ctx$
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/js/fragment')
+
+  Folder({ name: 'src/entity' }, () => {
+
+    File({ name: entity.Name + 'Entity.' + target.name }, () => {
+
+      const opnames = Object.keys(entity.op)
+
+      const opfrags =
+        (['load', 'list', 'create', 'update', 'remove']
+          .reduce((a: any, opname: string) =>
+          (a['#' + camelify(opname) + 'Op'] =
+            !opnames.includes(opname) ? '' : ({ indent }: any) => {
+              Operation({ ff, opname, indent, entity })
+            }, a), {}))
+
+      Fragment({
+        from: ff + '/Entity.fragment.js',
+        replace: {
+          Name: entity.Name,
+
+          ...opfrags,
+        }
+      })
+
+    })
+  })
+})
+
+
+export {
+  Entity
+}

package/project/generate/src/cmp/js/MainEntity_js.ts

@@ -0,0 +1,22 @@
+
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity } = props
+
+  Content(`
+  ${entity.Name}(data) {
+    const self = this
+    return new ${entity.Name}Entity(self,data)
+  }
+
+`)
+
+})
+
+
+export {
+  MainEntity
+}

package/project/generate/src/cmp/js/Main_js.ts

@@ -0,0 +1,82 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each, names,
+  List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+} from '@voxgig/sdkgen'
+
+
+import { Package } from './Package_js'
+import { Config } from './Config_js'
+import { MainEntity } from './MainEntity_js'
+import { Test } from './Test_js'
+
+
+const Main = cmp(async function Main(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+  const { entity } = model.main.api
+  const { feature } = model.main.sdk
+  const { utility } = model.main.sdk
+
+  Package({ target })
+
+  Test({ target })
+
+  Folder({ name: 'src' }, () => {
+
+    File({ name: model.const.Name + 'SDK.' + target.name }, () => {
+
+      Line(`// ${model.const.Name} ${target.Name} SDK\n`)
+
+      List({ item: feature }, ({ item }: any) =>
+        Line(`const { ${item.Name + 'Feature'} } = ` +
+          `require('./feature/${item.name}/${item.Name}Feature')`))
+
+      List({ item: entity }, ({ item }: any) =>
+        Line(`const { ${item.Name}Entity } = require('./entity/${item.Name}Entity')`))
+
+      each(utility, (u: any) =>
+        Line(`const { ${u.name} } = require('./utility/${u.Name}Utility')`))
+      Line('')
+
+      Fragment({
+        from: Path.normalize(__dirname + '/../../../src/cmp/js/fragment/Main.fragment.js'),
+        replace: {
+          Name: model.const.Name,
+
+          '#BuildFeature': ({ indent }: any) =>
+            List({ item: feature, line: false }, ({ item }: any) =>
+              Line({ indent }, `${item.name}: ` +
+                `new ${item.Name}Feature(this, this.#options.feature.${item.name}, ` +
+                `${JSON.stringify(item.config || {})}), `)),
+
+          '#CustomUtility': ({ indent }: any) =>
+            each(utility, (u: any) =>
+              Line({ indent }, `this.#utility.${u.name} = ${u.name}`)),
+
+          '#Feature-Hook': ({ name, indent }: any) =>
+            FeatureHook({ name }, (f: any) =>
+              Line({ indent },
+                `${f.await ? 'await ' : ''}this.#features.${f.name}.${name}({ client: this })`)),
+        }
+      }, () => {
+
+        each(entity, (entity: any) => {
+          MainEntity({ model, target, entity })
+        })
+
+      })
+    })
+
+    Config({ target })
+
+  })
+})
+
+
+export {
+  Main
+}

package/project/generate/src/cmp/js/Package_js.ts

@@ -0,0 +1,57 @@
+
+import {
+  cmp, omap, each, cmap,
+  File, Content,
+} from '@voxgig/sdkgen'
+
+
+
+const Package = cmp(async function Package(props: any) {
+  const { target, ctx$: { model } } = props
+  const { main: { sdk: { feature } } } = model
+
+  const only = (kind: string, deps: any) =>
+    omap(deps, ([k, v]: any) => [v.active && kind === v.kind ? k : undefined, v.version])
+
+  // merge target and feature deps, by kind
+  const deps =
+    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?
+      .reduce((a: any, deps: any) => (each(deps, (dep: any) =>
+        a[dep.kind][dep.key$] = dep.version), a),
+        {
+          prod: only('prod', target.deps),
+          peer: only('peer', target.deps),
+          dev: only('dev', target.deps),
+        })
+
+  // TODO: complete SDK meta data in model and use here
+  const pkg = {
+    name: `${model.const.name}-sdk`,
+    version: `0.0.1`,
+    description: 'DESCRIPTION',
+    main: `src/${model.const.Name}SDK.js`,
+    scripts: {
+      'test': 'node --test test/*.test.js',
+      'test-accept': 'node --test test/accept/*.test.js',
+      'test-all': 'npm run test && npm run test-accept'
+    },
+    author: `${model.const.Name}`,
+    license: 'MIT',
+    dependencies: deps.prod,
+    peerDependencies: deps.peer,
+    devDependencies: deps.dev,
+  }
+
+
+  File({ name: 'package.json' }, () => {
+    Content(JSON.stringify(pkg, null, 2))
+  })
+})
+
+
+export {
+  Package
+}

package/project/generate/src/cmp/js/Quick_js.ts

@@ -0,0 +1,82 @@
+
+import { names, getx, each, cmp, File, Content } from '@voxgig/sdkgen'
+
+
+const Quick = cmp(function Quick(props: any) {
+  const { target } = props
+  const { model, meta: { spec } } = props.ctx$
+
+  // get quick entity from target config
+
+  let ent: any
+  let entmap = getx(spec.config.guideModel, 'guide entity?test:quick:active=true')
+
+  if (entmap) {
+    ent = Object.values(entmap)[0]
+    ent.name = Object.keys(entmap)[0]
+  }
+
+  ent = ent || { name: 'Entity' }
+  names(ent, ent.name)// , ent.key$ || 'name')
+
+  // TODO: selected features should be active by default!
+
+  const featureOptions = each(model.main.sdk.feature)
+    .filter((f: any) => f.active)
+    .reduce((a: any, f: any) => a + `\n    ${f.name}: { active: true },`, '')
+
+  // console.log('QUICK', ent, featureOptions)
+
+
+  File({ name: 'quick.' + target.name }, () => {
+
+    Content(`
+// ENT 3
+require('dotenv').config({ path: ['../../.env.local']})
+
+const { ${model.const.Name}SDK } = require('../')
+
+run()
+
+async function run() {
+  const client = new ${model.const.Name}SDK({
+    endpoint: process.env.${model.NAME}_ENDPOINT,
+    apikey: process.env.${model.NAME}_APIKEY,
+    ${featureOptions}
+  })
+
+`)
+
+    if (ent.test?.quick.create) {
+      Content(`    
+  out = await client.${ent.Name}().create(${JSON.stringify(ent.test?.quick.create)})
+  console.log('${ent.Name}.load', out) 
+`)
+    }
+
+    if (ent.test?.quick.load) {
+      Content(`    
+  out = await client.${ent.Name}().load(${JSON.stringify(ent.test?.quick.load)})
+  console.log('${ent.Name}.load', out) 
+`)
+    }
+
+    if (ent.test?.quick.list) {
+      Content(`    
+  out = await client.${ent.Name}().list(${JSON.stringify(ent.test?.quick.list)})
+  console.log('${ent.Name}.list', out)
+`)
+    }
+
+    Content(`
+}
+`)
+
+  })
+})
+
+
+export {
+  Quick
+}
+

package/project/generate/src/cmp/js/ReadmeInstall_js.ts

@@ -0,0 +1,19 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { target } = props
+
+  Content('```js')
+  Content(`
+npm install ${target.module.name}
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeInstall
+}

package/project/generate/src/cmp/js/ReadmeQuick_js.ts

@@ -0,0 +1,25 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
+  const { target, ctx$: { model } } = props
+
+  Content('```js')
+  Content(`
+const { ${model.const.Name}SDK } = require('${target.module.name}')
+
+const client = ${model.const.Name}SDK.make({
+  endpoint: process.env.${model.NAME}_ENDPOINT,
+  apikey: process.env.${model.NAME}_APIKEY,
+})
+
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeQuick
+}

package/project/generate/src/cmp/js/TestAcceptEntity_js.ts

@@ -0,0 +1,101 @@
+
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestAcceptEntity = cmp(function TestEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  Content(`
+    test('${entity.name}-load', async ()=>{
+      const client = makeClient()
+      const out = await client.${entity.Name}().load({id:'t01'})
+      //console.log('${entity.name}-load', 'out', out)
+
+      // equal(out.status, 200, 'Expected status code 200');
+
+      // Check out.data is an object
+      equal(typeof out.data, 'object', 'Expected data to be an object');
+
+      // Check out.data has id
+      equal(typeof out.data.id, 'string', 'Expected data to have an id');
+
+    })
+
+    test('${entity.name}-list', async ()=>{
+      const client = makeClient()
+      const out = await client.${entity.Name}().list()
+      //console.log('${entity.name}-list', 'out', out)
+
+      // Check out is an array
+      equal(Array.isArray(out), true, 'Expected an array');
+
+      // Check out.data is an object
+      equal(typeof out[0], 'object', 'Expected data to be an object');
+
+      // Check out.data has id
+      equal(typeof out[0].data.id, 'string', 'Expected data to have an id');
+    })
+
+    test('${entity.name}-create', async ()=>{
+      const client = makeClient() 
+      const out = await client.${entity.Name}().create(${JSON.stringify(generateObjectFromFields(entity.field))})
+      //console.log('${entity.name}-create', 'out', out)
+
+      // Check out is an object
+      equal(typeof out, 'object', 'Expected an object');
+
+      // Check out.data has id
+      equal(typeof out.data.id, 'string', 'Expected data to have an id');
+    })
+
+    test('${entity.name}-save', async ()=>{
+      const client = makeClient()
+      const out = await client.${entity.Name}().save(${JSON.stringify(generateObjectFromFields(entity.field))})
+      //console.log('${entity.name}-save', 'out', out)
+
+      // Check out is an object
+      equal(typeof out, 'object', 'Expected an object');
+
+      // Check out.data has id
+      equal(typeof out.data.id, 'string', 'Expected data to have an id'); 
+    })
+
+    test('${entity.name}-remove', async ()=>{
+      const client = makeClient()
+      const out = await client.${entity.Name}().remove({id:'t01'})
+      //console.log('${entity.name}-remove', 'out', out)
+
+      // Check out is an object
+      equal(typeof out, 'object', 'Expected an object');
+    })
+
+`);
+})
+
+function generateObjectFromFields(fields: any) {
+  const getRandomString = (length: number): string =>
+    Array.from({ length }, () => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(Math.random() * 62))).join('');
+
+  const defaultValues: Record<string, any> = {
+    number: Math.floor(Math.random() * 100),
+    string: getRandomString(5),
+    object: { [getRandomString(3)]: getRandomString(3) },
+    boolean: Math.random() > 0.5,
+    array: Array.from({ length: 3 }, () => getRandomString(3)),
+  }
+
+  const result: Record<string, any> = {}
+
+  for (const key in fields) {
+    result[key] = defaultValues[fields[key].type] ?? null;
+  }
+
+  return result
+}
+
+
+export {
+  TestAcceptEntity
+}

package/project/generate/src/cmp/js/TestAccept_js.ts

@@ -0,0 +1,60 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestAcceptEntity } from './TestAcceptEntity_js'
+
+
+const TestAccept = cmp(function TestMain(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+
+  File({ name: model.const.Name + 'SDK.accept.test.' + target.name }, () => {
+
+    Content(`
+const { test, describe } = require('node:test')
+const { equal, deepEqual } = require('node:assert')
+
+const { ${model.const.Name}SDK } = require('../../')
+
+
+describe('${model.const.Name}SDK Acceptance Tests', ()=>{
+  test('happy', async ()=>{
+    const client = makeClient()
+    const out = await client.Geofence().load({id:'gf01'})
+    console.log('Geofence.load', out)
+    equal(out.data.id,'gf01')
+  })
+
+`)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestAcceptEntity({ model, target, entity })
+    })
+
+
+    Content(`
+})
+
+
+function makeClient(config) {
+  const client = ${model.const.Name}SDK.make({
+    endpoint: process.env.${model.NAME}_ENDPOINT,
+    apikey: process.env.${model.NAME}_APIKEY,
+    ...config
+  })
+
+  return client
+}
+
+`)
+
+  })
+})
+
+
+export {
+  TestAccept
+}
+

package/project/generate/src/cmp/js/TestEntity_js.ts

@@ -0,0 +1,24 @@
+
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  Content(`
+  test('${entity.name}-load', async ()=>{
+    const client = makeClient()
+    const out = await client.${entity.Name}().load({id:'t01'})
+    console.log('${entity.name}-load', out)
+    deepEqual(out.data,{id:'t01',title:'T01'})
+  })
+
+`)
+})
+
+
+export {
+  TestEntity
+}

package/project/generate/src/cmp/js/TestMain_js.ts

@@ -0,0 +1,120 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_js'
+
+
+const TestMain = cmp(function TestMain(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+
+  File({ name: model.const.Name + 'SDK.test.' + target.name }, () => {
+
+    Content(`
+
+
+const { test, describe } = require('node:test')
+const { equal, deepEqual } = require('node:assert')
+
+const { ${model.const.Name}SDK } = require('../')
+
+
+describe('${model.const.Name}SDK Unit Tests', ()=>{
+  test('make', async ()=>{
+    const client = makeClient()
+    equal(null == client, false)
+  })
+
+`)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestEntity({ model, target, entity })
+    })
+
+
+    Content(`
+})
+
+
+function makeClient(config) {
+  const client = ${model.const.Name}SDK.make({
+    endpoint: 'https://host/api/v1/rest/project_id/plant/stage',
+    apikey: 'apikey',
+    fetch,
+    ...config
+  })
+
+  return client
+}
+
+async function fetch(url, config) {
+  const parts = url.split('/')
+  const entname = parts[9]
+  const entid = parts[10]
+  const data = JSON.parse(config.body||'{}')
+  const method = config.method || 'GET'
+
+  const req$ = {
+    url,
+    parts,
+    entname,
+    entid,
+    method,
+    data,
+  }
+
+  console.log('REQ', req$)
+
+  return {
+    req$,
+    status: 200,
+    json: async function() {
+      if('PUT'=== method||'POST'===method) {
+        return entid ? {
+          id: entid,
+          title: data.title,
+        } :
+        {
+          id: 'n01',
+          title: data.title || 'T01',        
+        }
+      }
+      else if('GET'===method) {
+        return entid ? {
+          id: entid,
+          title: 'T01'
+        } :
+        {
+          name: entname,
+          list: [
+            {
+              id: 'n01',
+              title: 'N01'
+            },
+            {
+              id: 'n01',
+              title: 'N01'
+            },
+          ]
+        }
+      }
+      else {
+        return {}
+      }
+    } 
+  }
+}
+
+
+`)
+
+  })
+})
+
+
+export {
+  TestMain
+}
+