@voxgig/create-sdkgen 0.0.2 → 0.0.3

package/bin/run-create-sdkgen.js~

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/create-sdkgen",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "main": "dist/create-sdkgen.js",
   "type": "commonjs",
   "types": "dist/create-sdkgen.d.ts",
@@ -34,6 +34,8 @@
   "files": [
     "src",
     "dist",
+    "bin",
+    "tm",
     "LICENSE"
   ],
   "devDependencies": {

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
+}

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

@@ -0,0 +1,168 @@
+
+import { cmp, each, camelify, File, Content, Copy } from '@voxgig/sdkgen'
+
+import { MainEntity } from './MainEntity_go'
+import { Test } from './Test_go'
+
+
+const Main = cmp(async function Main(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  const entity = model.main.sdk.entity
+  const options = build.options
+
+  Copy({ from: 'tm/' + build.name + '/.env.example', name: '.env.example' })
+  Copy({ from: 'tm/' + build.name + '/go.mod', name: 'go.mod' })
+  Copy({ from: 'tm/' + build.name + '/go.sum', name: 'go.sum' })
+  Test({ build })
+  File({ name: model.name + 'sdk.' + build.name }, () => {
+
+    Content(`
+// ${model.Name} ${build.Name} SDK
+
+package ${model.name}sdk
+
+import(
+  "bytes"
+  "encoding/json"
+  "fmt"
+  "net/http"
+  "errors"
+  "reflect"
+)
+
+type endpointConfig struct {
+  op string
+  id string
+  name string
+  apiUrl string
+}
+
+type fetchConfig struct {
+  op string
+  url string
+  apikey string
+}
+
+type spec struct {
+  body *bytes.Buffer
+  url string
+  method string
+  contentType string
+  authorization string
+}
+
+type Options struct {`)
+    each(options, (option: any) => {
+      if (option.kind != "Any") {
+        Content(`
+  ${camelify(option.name)} ${option.kind.toLowerCase()}
+`)
+      }
+    }); Content(`
+}
+
+type ${model.name} struct {
+  httpClient http.Client
+  options Options
+}
+
+func method(op string) string {
+  operations := map[string]string {
+    "create": "POST",
+    "save": "PUT",
+    "load": "GET",
+    "list": "GET",
+    "remove": "DELETE",
+  }
+
+  return operations[op]
+}
+
+func endpoint(config endpointConfig) string {
+  url := fmt.Sprintf("%v/%v", config.apiUrl, config.name)
+
+  if config.op == "load" || config.op == "remove" {
+    url += fmt.Sprintf("/%v", config.id)
+  }
+
+  return url
+}
+
+func body[T any](data T) ([]byte, error) {
+  var msg []byte
+  msg, err := json.Marshal(data)
+  if err != nil {
+    return nil, err
+  }
+  return msg, nil
+}
+
+func fetchSpec[T any](config fetchConfig, data T) (spec, error){
+  method := method(config.op)
+  buffBody := bytes.NewBuffer([]byte{})
+
+  if method != "GET" && method != "DELETE" {
+    parsedBody, err := body(data)
+    if err != nil {
+      return spec{}, err
+    }
+    buffBody = bytes.NewBuffer(parsedBody)
+  }
+
+  spec := spec{
+    url: config.url,
+    method: method,
+    contentType: "application/json",
+    authorization: fmt.Sprintf("Bearer %v", config.apikey),
+    body: buffBody,
+  }
+  return spec, nil
+}
+
+`)
+
+    each(entity, (entity: any) => {
+      MainEntity({ model, build, entity })
+    })
+
+    Content(`
+func validateOptions(options Options) error {
+  e := reflect.ValueOf(&options).Elem()
+
+	for i := 0; i < e.NumField(); i++ {
+    field := e.Field(i)
+		fieldName := e.Type().Field(i).Name
+    fieldValue := field.Interface()
+
+		if field.IsZero() {
+			return errors.New(fmt.Sprintf("${model.Name}SDK: Invalid options: opt: %v value: %v",
+        fieldName, fieldValue))
+		}
+	}
+	return nil
+}
+
+func new${model.Name}SDK(options Options) (*${model.name}, error) {
+	sdk := new(${model.name})
+	sdk.options = options
+	sdk.httpClient = *http.DefaultClient
+	return sdk, nil
+}
+
+func Make(options Options) (*${model.name}, error) {
+  err := validateOptions(options)
+  if err != nil {
+    return nil, err
+  }
+  return new${model.Name}SDK(options)
+}
+`)
+  })
+})
+
+
+export {
+  Main
+}