@voxgig/create-sdkgen 0.0.1 → 0.0.3

package/src/standard/ModelSdk.ts

@@ -0,0 +1,92 @@
+
+import {
+  names,
+  cmp,
+  each,
+
+  Project,
+  Folder,
+  Copy,
+  File,
+  Content,
+
+} from 'jostraca'
+
+
+
+const ModelSdk = cmp(function ModelSdk(props: any) {
+  const { ctx$, ctx$: { model } } = props
+
+
+  // console.log('ModelSdk 2', model)
+
+  // TODO: use apidef
+  // const def = ctx$.fs.readFileSync(model.def.filepath)
+
+
+  File({ name: 'sdk.jsonic' }, () => {
+    Content(`
+name: '${model.name}'
+
+@"api.jsonic"
+@"def.jsonic"
+
+main: sdk: build: &: { name: .$KEY }
+
+main: sdk: build: js: @"js.jsonic"
+
+main: sdk: build: rb: @"rb.jsonic"
+
+main: sdk: build: py: @"py.jsonic"
+
+main: sdk: build: php: @"php.jsonic"
+
+main: sdk: build: go: @"go.jsonic"
+
+
+
+main: sdk: test: quick: entity: name: q
+
+
+main: sdk: entity: $.main.api.entity
+
+
+main: sdk: entity: &: {
+  name: .$KEY
+  publish: *true | boolean
+}
+
+
+
+main: sdk: options: &: {
+   name: .$KEY
+   publish: *true | boolean
+}
+
+
+main: sdk: options: {
+
+  endpoint: {
+    kind: *String | string
+    short: "${model.Name} API URL"
+  }
+
+  apikey: {
+    kind: *String | string
+    short: "${model.Name} API Key"
+  }
+  
+  fetch: {
+    kind: *Any | string
+    publish: false
+  }
+}
+`)
+  })
+
+})
+
+
+export {
+  ModelSdk
+}

package/src/standard/ModelSdk.ts~

@@ -0,0 +1 @@
+

package/src/standard/Root.ts

@@ -0,0 +1,107 @@
+
+
+import Path from 'node:path'
+
+
+import {
+  names,
+  cmp,
+  each,
+
+  Project,
+  Folder,
+  Copy,
+  File,
+  Content,
+
+} from 'jostraca'
+
+
+import { ModelSdk } from './ModelSdk'
+
+
+const Root = cmp(function Root(props: any) {
+  const { model, ctx$ } = props
+
+  const { folder, meta } = ctx$
+  const { spec } = meta
+
+  console.log('Root 5')
+
+  // console.log('SPEC', spec)
+
+  names(model, model.name)
+
+  // console.log('MODEL')
+  // console.dir(model, { depth: null })
+
+  ctx$.model = model
+
+  /*
+  let createInfo = { exclude: [], last: Number.MAX_SAFE_INTEGER }
+
+
+  try {
+    createInfo = JSON.parse(ctx$.fs.readFileSync(
+      Path.join(folder, '.voxgig', 'create-sdkgen.json'), 'utf8'))
+  }
+  catch (err: any) {
+    console.log(err)
+    // TODO: file not foound ignored, handle others!
+  }
+
+  ctx$.info = createInfo
+
+  console.log('INFO', ctx$.info)
+  */
+
+  Project({ folder }, () => {
+
+    // TODO: perhaps remove the need for this, create top level folder in Project
+    // would keep paths indo of project folder name
+    // Folder({ name: Path.basename(folder) }, () => {
+
+    // File({ name: 'foo.txt' }, () => {
+    //   Content('FOO')
+    // })
+
+    // console.log('FOLDER', folder)
+    Copy({ from: __dirname + '/../../tm/standard' })
+
+    const def = model.def.filepath
+    if (null != def && '' !== def) {
+      Folder({ name: 'def' }, () => {
+        Copy({ from: def, name: Path.basename(def) })
+      })
+    }
+
+    Folder({ name: '.voxgig' }, () => { })
+
+    Folder({ name: 'model' }, () => {
+      ModelSdk({})
+    })
+  })
+
+  /*
+  // TODO: need mechanism to ensure this is last
+  setTimeout(() => {
+    try {
+      const info = {
+        last: Date.now(),
+        exclude: ctx$.info.exclude,
+      }
+      ctx$.fs.writeFileSync(Path.join(folder, '.voxgig', 'create-sdkgen.json'),
+        JSON.stringify(info, null, 2))
+    }
+    catch (err: any) {
+      console.log(err)
+      // TODO: file not foound ignored, handle others!
+    }
+    }, 777)
+    */
+})
+
+
+export {
+  Root
+}

package/src/standard/Root.ts~

@@ -0,0 +1,3 @@
+
+
+

package/tm/standard/.env.local

@@ -0,0 +1,2 @@
+$$NAME$$_ENDPOINT=https://api.example.com
+$$NAME$$_APIKEY=apikey

package/tm/standard/build/sdk.js

@@ -0,0 +1,25 @@
+
+const { SdkGen } = require('@voxgig/sdkgen')
+const { Root } = require('../dist/Root')
+
+
+try {
+  const config = {
+    folder: __dirname+'/../sdk',
+    def: __dirname+'/../def/$$def.filename$$',
+    meta: {
+      name: '$$name$$'
+    },
+    model: {
+      folder: __dirname+'/../model',
+      
+      entity: {}
+    },
+  }
+
+  module.exports = SdkGen.makeBuild(Root, config)
+
+}
+catch(e) {
+  console.log('SDK ERROR', e)
+}

package/tm/standard/def/DEFINITION.md

@@ -0,0 +1,2 @@
+# API Definition
+ API definition (OpenAPI etc) files live here.

package/tm/standard/model/.model-config/model-config.jsonic

@@ -0,0 +1,13 @@
+
+
+@'@voxgig/model/model/.model-config/model-config.jsonic'
+
+sys: model: builders: {
+  sdk: load: 'build/sdk.js'
+}
+
+sys: model: watch: {
+  'build': {}
+  'dist': {}
+  'tm': {}
+}

package/tm/standard/model/go.jsonic

@@ -0,0 +1,6 @@
+
+title: Go
+
+module: name: '$ModuleName'
+
+options: $.main.sdk.options

package/tm/standard/model/js.jsonic

@@ -0,0 +1,6 @@
+
+title: JavaScript
+
+module: name: '$ModuleName'
+
+options: $.main.sdk.options

package/tm/standard/model/php.jsonic

@@ -0,0 +1,6 @@
+
+title: PHP
+
+module: name: '$ModuleName'
+
+options: $.main.sdk.options

package/tm/standard/model/py.jsonic

@@ -0,0 +1,7 @@
+title: Python
+
+extension: py
+
+module: name: '$ModuleName'
+
+options: $.main.sdk.options

package/tm/standard/model/rb.jsonic

@@ -0,0 +1,6 @@
+
+title: Ruby
+
+module: name: '$ModuleName'
+
+options: $.main.sdk.options

package/tm/standard/model/sdk.jsonic.off

@@ -0,0 +1,60 @@
+
+name: '$$name$$'
+
+@"api.jsonic"
+@"def.jsonic"
+
+main: sdk: build: &: { name: .$KEY }
+
+main: sdk: build: js: @"js.jsonic"
+
+main: sdk: build: rb: @"rb.jsonic"
+
+main: sdk: build: py: @"py.jsonic"
+
+main: sdk: build: php: @"php.jsonic"
+
+main: sdk: build: go: @"go.jsonic"
+
+
+
+main: sdk: test: quick: entity: name: $$test.quick.entity.name$$
+
+
+main: sdk: entity: $.main.api.entity
+
+
+main: sdk: entity: &: {
+  name: .$KEY
+  publish: *true | boolean
+}
+
+
+
+main: sdk: options: &: {
+   name: .$KEY
+   publish: *true | boolean
+}
+
+
+main: sdk: options: {
+
+  endpoint: {
+    kind: *String | string
+    short: "$$Name$$ API URL"
+  }
+
+  apikey: {
+    kind: *String | string
+    short: "$$Name$$ API Key"
+  }
+  
+  fetch: {
+    kind: *Any | string
+    publish: false
+  }
+}
+
+
+
+

package/tm/standard/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "build-$$name$$-sdk",
+  "version": "0.0.1",
+  "description": "",
+  "main": "QQQindex.js",
+  "scripts": {
+    "model": "voxgig-model model/sdk.jsonic",
+    "watch": "tsc --build src -w",
+    "build": "tsc --build src",
+    "test": "echo no-test",
+    "clean": "rm -rf node_modules yarn.lock package-lock.json",
+    "reset": "npm run clean && npm i && npm run build && npm test",
+    "mock-server": "prism mock def/$DefinitionFile"
+  },
+  "author": "",
+  "license": "MIT",
+  "overrides": {
+    "@stoplight/prism-cli": {
+      "@stoplight/json": "3.21.0"
+    }
+  },
+  "devDependencies": {
+    "@voxgig/model": "^3.2.0",
+    "@voxgig/sdkgen": "^0.6.0",
+    "@voxgig/util": "^0.0.3",
+    "@types/node": "22.5.4",
+    "@stoplight/prism-cli": "^5.9.0",
+    "typescript": "^5.5.4"
+  }
+}

package/tm/standard/src/Root.ts

@@ -0,0 +1,60 @@
+
+import {
+  names,
+  cmp,
+  each,
+
+  Project,
+  Folder,
+
+  Main,
+  Entity,
+  Readme,
+
+} from '@voxgig/sdkgen'
+
+// import { Readme } from './Readme'
+// import { Main } from './Main'
+// import { Entity } from './Entity'
+
+
+const Root = cmp(function Root(props: any) {
+  const { model, ctx$ } = props
+
+  names(model, model.name)
+
+  // console.dir(model, { depth: null })
+
+  ctx$.model = model
+
+  const build = model.main.sdk.build
+  const entity = model.main.sdk.entity
+
+  Project({}, () => {
+
+    each(build, (build: any) => {
+      names(build, build.name)
+      // console.log('BUILD', build.name)
+
+      Folder({ name: build.name }, () => {
+
+        each(entity, (entity: any) => {
+          names(entity, entity.name)
+          // console.log('ENTITY', entity.name)
+
+          Entity({ build, entity })
+        })
+
+        Main({ build })
+
+        Readme({ build })
+      })
+    })
+  })
+})
+
+
+export {
+  Root
+}
+

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

@@ -0,0 +1,226 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { build, entity } = props
+  const { model } = props.ctx$
+
+  File({ name: entity.name + '.' + build.name }, () => {
+    const complexTypeMap: Record<string, string> = {
+      "custom": "map[string]any",
+      "xval": "float64",
+      "yval": "float64",
+      "zval": "float64",
+      "xlen": "int",
+      "ylen": "int",
+      "parent_xlen": "int",
+      "parent_xval": "float64",
+      "parent_xyangle": "float64",
+      "parent_ylen": "int",
+      "parent_yval": "float64",
+      "parent_zval": "float64",
+      "polygon": "struct{Points [][]float64}",
+    }
+
+    const defaultTypeMap: Record<string, string> = {
+      "boolean": "bool",
+      "string": "string"
+    }
+
+    Content(`
+// ${model.Name} ${build.Name} ${entity.Name}
+
+package ${model.name}sdk
+
+import (
+  "fmt"
+  "encoding/json"
+  "io"
+  "errors"
+  "net/http"
+)
+
+type ${entity.Name}Data struct {`)
+    each(entity.field, (field: any) => {
+      const type = complexTypeMap[field.name] ? complexTypeMap[field.name]
+        : defaultTypeMap[field.type]
+      Content(`
+  ${field.Name} ${type} \`json:"${field.name}"\`
+            `)
+    })
+    Content(`
+}
+
+type ${entity.Name} struct {
+  Data ${entity.Name}Data
+  def map[string]any
+  sdk func () *${model.name}
+}
+
+func (e *${entity.Name}) reqSetup(op string, data ${entity.Name}Data) (*http.Request, error) {
+  e.Data = data
+
+  endpointConfig := endpointConfig{
+    op: op,
+    id: e.Data.Id,
+    name: e.def["name"].(string),
+    apiUrl: e.sdk().options.Endpoint,
+  }
+
+  fetchConfig := fetchConfig{
+    op: op,
+    url: endpoint(endpointConfig),
+    apikey: e.sdk().options.Apikey,
+  }
+
+  spec, err := fetchSpec(fetchConfig, e.Data)
+  if err != nil {
+    return nil, err
+  }
+
+  req, err := http.NewRequest(spec.method, spec.url, spec.body)
+  if err != nil {
+    return nil, err
+  }
+
+  req.Header.Set("Content-Type", spec.contentType)
+  req.Header.Set("Authorization", spec.authorization)
+
+  return req, nil
+}
+
+func (e *${entity.Name}) handleResult(op string, res *http.Response,
+  handler func(${entity.Name}Data) *${entity.Name}) (*${entity.Name}, error) {
+  var result ${entity.Name}Data
+  status := res.StatusContent
+
+  if status == 200 {
+    resBody, err := io.ReadAll(res.Body)
+    if err != nil {
+      return nil, err
+    }
+
+    if err = json.Unmarshal(resBody, &result); err != nil {
+      return nil, err
+    }
+    return handler(result), nil
+  }
+
+  return nil, errors.New(fmt.Sprintf("HTTP-ERROR: %v: ${entity.name}: %v",
+    op, status))
+}
+
+`)
+    each(entity.op, (op: any) => {
+      if (op.name == "list") {
+        Content(`
+func (e *${entity.Name}) ${op.Name}() ([]*${entity.Name}, error) {
+  type entity${op.Name} struct {
+    ${op.Name} []${entity.Name}Data
+  }
+
+  op := "${op.name}"
+  var entities []*${entity.Name}
+
+  endpointConfig := endpointConfig{
+    op: op,
+    id: e.Data.Id,
+    name: e.def["name"].(string),
+    apiUrl: e.sdk().options.Endpoint,
+  }
+
+  fetchConfig := fetchConfig{
+    op: op,
+    url: endpoint(endpointConfig),
+    apikey: e.sdk().options.Apikey,
+  }
+
+  spec, err := fetchSpec(fetchConfig, e.Data)
+  if err != nil {
+    return nil, err
+  }
+
+  req, err := http.NewRequest(spec.method, spec.url, spec.body)
+  if err != nil {
+    return nil, err
+  }
+
+  req.Header.Set("Content-Type", spec.contentType)
+  req.Header.Set("Authorization", spec.authorization)
+
+  res, err := e.sdk().httpClient.Do(req)
+  if err != nil {
+    return nil, err
+  }
+  defer res.Body.Close()
+
+  status := res.StatusContent
+
+  if status == 200 {
+    resBody, err := io.ReadAll(res.Body)
+    if err != nil {
+      return nil, err
+    }
+
+    var entity${op.Name} entity${op.Name}
+    if err = json.Unmarshal(resBody, &entity${op.Name}); err != nil {
+      return nil, err
+    }
+
+    for _, entityData := range entity${op.Name}.${op.Name} {
+      entity := e.sdk().${entity.Name}(entityData)
+      entities = append(entities, entity)
+    }
+
+    return entities, nil
+  }
+
+  return nil, errors.New(fmt.Sprintf("HTTP-ERROR: %v: ${entity.name}: %v",
+    op, status))
+}
+`)
+        return
+      }
+      Content(`
+func (e *${entity.Name}) ${op.Name}(data ${entity.Name}Data) (*${entity.Name}, error) {
+  op := "${op.name}"
+
+  req, err := e.reqSetup(op, data)
+  if err != nil {
+    return nil, err
+  }
+
+  res, err := e.sdk().httpClient.Do(req)
+  if err != nil {
+    return nil, err
+  }
+  defer res.Body.Close()
+
+  handler := func(data ${entity.Name}Data) *${entity.Name} {
+    e.Data = data
+          `)
+      if (op.name == "remove") {
+        Content(`
+    return nil
+  }
+  return e.handleResult(op, res, handler)
+}
+  `)
+        return
+      }
+      Content(`
+    return e
+  }
+
+  return e.handleResult(op, res, handler)
+}
+`)
+    });
+  })
+})
+
+
+export {
+  Entity
+}

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

@@ -0,0 +1,26 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { model, entity } = props
+
+  Content(`
+func (m *${model.name}) ${entity.Name}(data ...${entity.Name}Data) *${entity.Name} {
+  e := new (${entity.Name})
+  e.sdk = func () *${model.name} {return m}
+  if data != nil {
+    e.Data = data[0]
+  }
+  e.def = map[string]any{
+    "name": "${entity.name}",
+  }
+  return e
+}
+`)
+})
+
+
+export {
+  MainEntity
+}