@voxgig/create-sdkgen 0.0.1 → 0.0.3

package/tm/standard/src/go/TestMain_go.ts

@@ -0,0 +1,61 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_go'
+
+
+const TestMain = cmp(function TestMain(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  File({ name: model.name + 'sdk_test.' + build.name }, () => {
+
+    Content(`
+package ${model.name}sdk
+
+import (
+  "fmt"
+  "testing"
+  "net/http"
+  "io"
+  "strings"
+)
+
+// Mock HTTP Client Transport type.
+// For more info, please see: https://pkg.go.dev/net/http#Client
+// And: https://pkg.go.dev/net/http#RoundTripper
+type fakeService func(*http.Request) (*http.Response, error)
+
+func (s fakeService) RoundTrip(req *http.Request) (*http.Response, error) {
+  return s(req)
+}
+
+func createHttpClientMock(respData *strings.Reader) *http.Client {
+ return &http.Client{
+  Transport: fakeService(func(*http.Request) (*http.Response, error) {
+    return &http.Response{
+      StatusContent: http.StatusOK,
+      Header: http.Header{
+        "Content-Type": []string{"application/json"},
+      },
+      Body: io.NopCloser(respData),
+    }, nil
+  }),
+}}
+`)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestEntity({ model, build, entity })
+    })
+    Content(`
+`)
+
+  })
+})
+
+
+export {
+  TestMain
+}
+

package/tm/standard/src/go/Test_go.ts

@@ -0,0 +1,20 @@
+
+import { cmp } from '@voxgig/sdkgen'
+
+import { Quick } from './Quick_go'
+import { TestMain } from './TestMain_go'
+import { TestAccept } from './TestAccept_go'
+
+
+const Test = cmp(function Test(props: any) {
+  const { build } = props
+
+  Quick({ build })
+  TestMain({ build })
+  TestAccept({ build })
+})
+
+
+export {
+  Test
+}

package/tm/standard/src/js/Entity_js.ts

@@ -0,0 +1,135 @@
+
+// Entity 1
+
+import { cmp, File, Content, Folder } from '@voxgig/sdkgen'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { build, entity } = props
+  const { model } = props.ctx$
+
+
+  Folder({ name: 'src' }, () => {
+
+    File({ name: entity.Name + '.' + build.name }, () => {
+
+      Content(`
+// ${model.Name} ${build.Name} ${entity.Name} 1
+
+class ${entity.Name} {
+  def
+  data
+
+
+  constructor(sdk,data) {
+    this.sdk = ()=>sdk
+    this.def = {
+      name: '${entity.name}'
+    }
+    // data is optional
+    this.data = data
+  }
+
+
+  async handleResult(op, res, spec, handler) {
+    const status = res.status
+
+    if(200 === status) {
+      const json = await res.json()
+      // TODO: error
+      return handler(json)
+    }
+    else {
+      throw new Error('HTTP-ERROR: '+op+': ${entity.name}: '+status)
+    }
+  }
+
+
+  async save(data) {
+    const op = 'save'
+    this.data = data
+    // TODO: validate data
+
+    const spec = this.sdk().fetchSpec(op,this)
+    const res = await this.sdk().options.fetch(spec.url,spec)
+
+    return this.handleResult(op, res, spec, (json)=>{
+      this.data = json
+      return this
+    })
+  }
+
+  async create(data) {
+    const op = 'create'
+    this.data = data
+    // TODO: validate data
+
+    const spec = this.sdk().fetchSpec(op,this)
+    const res = await this.sdk().options.fetch(spec.url,spec) 
+
+    return this.handleResult(op, res, spec, (json)=>{
+      this.data = json
+      return this
+    })
+  }
+
+
+  async load(data) {
+    const op = 'load'
+    this.data = data
+    // TODO: check data.id defined
+    // TODO: separate data and query
+
+    const spec = this.sdk().fetchSpec(op,this)
+    const res = await this.sdk().options.fetch(spec.url,spec)
+
+   return this.handleResult(op, res, spec, (json)=>{
+      this.data = json
+      return this
+    })
+  }
+
+
+  async remove(data) {
+    const op = 'remove'
+    this.data = data
+    // TODO: check data.id defined
+
+    const spec = this.sdk().fetchSpec(op,this)
+    const res = await this.sdk().options.fetch(spec.url,spec)
+
+    return this.handleResult(op, res, spec, (json)=>{
+      this.data = json
+      return null
+    })
+  }
+
+
+  async list(query) {
+    const op = 'list'
+    // TODO: use query if defined
+
+    const spec = this.sdk().fetchSpec(op,this)
+    const res = await this.sdk().options.fetch(spec.url,spec)
+
+    return this.handleResult(op, res, spec, (json)=>{
+      return json.list.map(data=>this.sdk().${entity.Name}(data))
+    })
+  }
+
+}
+
+
+module.exports = {
+  ${entity.Name}
+}
+
+`)
+    })
+  })
+})
+
+
+export {
+  Entity
+}

package/tm/standard/src/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}(self,data)
+  }
+
+`)
+
+})
+
+
+export {
+  MainEntity
+}

package/tm/standard/src/js/Main_js.ts

@@ -0,0 +1,128 @@
+
+
+import { cmp, each, camelify, File, Content, Copy, Folder } from '@voxgig/sdkgen'
+
+
+import { MainEntity } from './MainEntity_js'
+import { Test } from './Test_js'
+
+
+const Main = cmp(async function Main(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  const entity = model.main.sdk.entity
+
+  Copy({ from: 'tm/' + build.name + '/package.json', name: 'package.json' })
+
+  Test({ build })
+
+  Folder({ name: 'src' }, () => {
+
+    File({ name: model.Name + 'SDK.' + build.name }, () => {
+
+      Content(`
+// ${model.Name} ${build.Name} SDK
+`)
+
+      each(entity, (entity: any) => {
+        entity.Name = camelify(entity.name)
+        Content(`
+const { ${entity.Name} } = require('./${entity.Name}')
+`)
+      })
+
+
+      const validate_options = each(build.options)
+        .reduce((a: string, opt: any) =>
+          a + ('String' === opt.kind ?
+            `    required('string','${opt.name}',options)\n` : ''), '')
+
+
+      Content(`
+    
+class ${model.Name}SDK {
+  options
+
+  static make(options) {
+    return new ${model.Name}SDK(options)
+  }
+
+
+  constructor(options) {
+    this.options = options
+
+${validate_options}
+
+    this.options.fetch = this.options.fetch || fetch 
+  }
+
+
+  endpoint(op,ent) {
+    let data = ent.data || {}
+    let def = ent.def
+    // Make this code depend on openapi spec
+    return this.options.endpoint + '/' + def.name + ((op === 'load' || op === 'remove') && data.id ? '/' + data.id : '')
+  }
+
+  method(op,ent) {
+    let key = (null == ent || null === ent.id) && 'save' === op ? 'create' : op
+    return ({
+      create: 'POST',
+      save: 'PUT',
+      load: 'GET',
+      list: 'GET',
+      remove: 'DELETE',
+    })[op]
+  }
+
+  body(op,ent) {
+    const msg = { ...ent.data }  
+    return JSON.stringify(msg)
+  }
+
+  fetchSpec(op,ent) {
+    const method = this.method(op, ent)
+    const spec = {
+      url: this.endpoint(op, ent),
+      method,
+      headers: {
+        'content-type': 'application/json',
+        'authorization': 'Bearer '+this.options.apikey
+      },
+      body: 'GET' === method || 'DELETE' === method ? undefined : this.body(op, ent),
+    }
+    return spec
+  }
+
+`)
+
+      each(entity, (entity: any) => {
+        MainEntity({ model, build, entity })
+      })
+
+      Content(`
+}
+
+
+function required(type,name,options) {
+  const val = options[name]
+  if(type !== typeof val) {
+    throw new Error('${model.Name}SDK: Invalid option: '+name+'='+val+': must be of type '+type)
+  }
+}
+
+module.exports = {
+  ${model.Name}SDK
+}
+
+`)
+
+    })
+  })
+})
+
+
+export {
+  Main
+}

package/tm/standard/src/js/Quick_js.ts

@@ -0,0 +1,72 @@
+
+import { names, getx, cmp, File, Content } from '@voxgig/sdkgen'
+
+
+const Quick = cmp(function Quick(props: any) {
+  const { build } = props
+  const { model, meta: { spec } } = props.ctx$
+
+  // get quick entity from build config
+
+  // console.log('CONFIG 2')
+  // console.dir(spec.config, { depth: null })
+
+
+  const ent = getx(spec.config, 'entity *').find((ent: any) => ent.test.quick.active)
+  names(ent, ent.key$)
+
+  console.log('ENT 3', ent)
+
+  File({ name: 'quick.' + build.name }, () => {
+
+    Content(`
+// ENT 3
+require('dotenv').config({ path: ['../../.env.local']})
+
+const { ${model.Name}SDK } = require('../')
+
+run()
+
+async function run() {
+  const client = ${model.Name}SDK.make({
+    endpoint: process.env.${model.NAME}_ENDPOINT,
+    apikey: process.env.${model.NAME}_APIKEY,
+  })
+
+  let out
+
+`)
+
+    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/tm/standard/src/js/ReadmeInstall_js.ts

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

package/tm/standard/src/js/ReadmeQuick_js.ts

@@ -0,0 +1,27 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
+  const { build, ctx$: { model } } = props
+
+  Content('```js')
+  Content(`
+const { ${model.Name}SDK } = require('${build.module.name}')
+
+const client = ${model.Name}SDK.make({
+  endpoint: process.env.${model.NAME}_ENDPOINT,
+  apikey: process.env.${model.NAME}_APIKEY,
+})
+
+let buildings = await client.Building().list()
+console.log('Buildings', buildings) 
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeQuick
+}

package/tm/standard/src/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/tm/standard/src/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 { build } = props
+  const { model } = props.ctx$
+
+
+  File({ name: model.Name + 'SDK.accept.test.' + build.name }, () => {
+
+    Content(`
+const { test, describe } = require('node:test')
+const { equal, deepEqual } = require('node:assert')
+
+const { ${model.Name}SDK } = require('../../')
+
+
+describe('${model.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, build, entity })
+    })
+
+
+    Content(`
+})
+
+
+function makeClient(config) {
+  const client = ${model.Name}SDK.make({
+    endpoint: process.env.${model.NAME}_ENDPOINT,
+    apikey: process.env.${model.NAME}_APIKEY,
+    ...config
+  })
+
+  return client
+}
+
+`)
+
+  })
+})
+
+
+export {
+  TestAccept
+}
+

package/tm/standard/src/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
+}