@voxgig/create-sdkgen 0.0.3 → 0.0.6

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

@@ -1,226 +0,0 @@
-
-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

@@ -1,26 +0,0 @@
-
-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

@@ -1,168 +0,0 @@
-
-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
-}

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

@@ -1,108 +0,0 @@
-
-import { cmp, File, Content } from '@voxgig/sdkgen'
-
-
-const Quick = cmp(function Quick(props: any) {
-  const { build } = props
-  const { model } = props.ctx$
-
-  File({ name: 'quick_test.' + build.name }, () => {
-
-    Content(`
-package ${model.name}sdk
-
-import (
-  "log"
-  "os"
-  "strings"
-  "testing"
-
-  "github.com/joho/godotenv"
-)
-
-func TestQuick(t *testing.T) {
-  err := godotenv.Load()
-  if err != nil {
-    t.Fatal("Error loading .env file for Quick test") 
-  }
-
-  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
-  apikey := os.Getenv("${model.NAME}_APIKEY")
-
-  var options Options
-  options.Apikey = apikey
-  options.Endpoint = endpoint
-  client, err := Make(options)
-  if err != nil {
-    t.Fatalf("Error creating a new client Quick: %q", err)
-  }
-
-  data := GeofenceData{
-    Id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
-  }
-
-  out, err := client.Geofence().Load(data)
-  if err != nil {
-    t.Fatalf("Error running Quick load method: %q", err)
-  }
-  log.Print("Geofence.load", out.Data)
-
-  out2, err := client.Geofence().List()
-  if err != nil {
-    t.Fatalf("Error running Quick list method: %q", err)
-  }
-  log.Print("Geofence.list", out2[0].Data, out2[1].Data)
-
-  if strings.Contains(endpoint, "localhost") {
-    //Create Quick Test
-    data := GeofenceData{
-      Name: "Geofence 1",
-      Desc: "Geofence 1 description",
-      Extent_id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
-      Custom: map[string]any{
-        "foo": "bar",
-      },
-    }
-    out, err := client.Geofence().Create(data)
-    if err != nil {
-      t.Fatalf("Error running Quick create method: %q", err)
-    }
-    log.Print("Geofence.create", out.Data)
-
-    //Save Quick Test
-    data = GeofenceData{
-      Id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
-      Name: "Geofence 1",
-      Desc: "Geofence 1 description",
-      Extent_id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
-      Custom: map[string]any{
-        "foo": "bar",
-      },
-    }
-    out, err = client.Geofence().Save(data)
-    if err != nil {
-      t.Fatalf("Error running Quick save method: %q", err)
-    }
-    log.Print("Geofence.save", out.Data)
-
-    //Remove Quick Test
-    data = GeofenceData{
-      Id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
-    }
-    out, err = client.Geofence().Remove(data)
-    if err != nil {
-      t.Fatalf("Error running Quick remove method: %q", err)
-    }
-    log.Print("Geofence.remove ", out)
-  }
-}
-`)
-
-  })
-})
-
-
-export {
-  Quick
-}
-

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

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

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

@@ -1,45 +0,0 @@
-
-import { cmp, Content } from '@voxgig/sdkgen'
-
-
-const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
-  const { build, ctx$: { model } } = props
-
-  Content('```go')
-  Content(`
-package main
-
-import (
-  "log"
-  "os"
-
-  "${build.module.name}"
-)
-
-func main() {
-  var options ${model.name}sdk.Options
-  options.Apikey = os.Getenv("${model.NAME}_APIKEY")
-  options.Endpoint = os.Getenv("${model.NAME}_ENDPOINT")
-
-  client, err := ${model.name}sdk.Make(options)
-  if err != nil {
-    log.Fatal(err)
-  }
-
-  buildings, err := client.Building().List()
-  if err != nil {
-    log.Println("Error running building list:", err)
-    return
-  }
-
-  log.Println("Buildings", buildings)
-}
-`)
-  Content('```')
-
-})
-
-
-export {
-  ReadmeQuick
-}