@voxgig/create-sdkgen 0.0.1 → 0.0.3

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

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

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

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

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

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

@@ -0,0 +1,219 @@
+
+import { cmp, each, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestAcceptEntity = cmp(function TestAcceptEntity(props: any) {
+  const { model, entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  const valueMap: Record<string, any> = {
+    "custom": "map[string]any{\"test\": \"test\"}",
+    "xval": "rand.Float64()",
+    "yval": "rand.Float64()",
+    "zval": "rand.Float64()",
+    "xlen": "rand.Int()",
+    "ylen": "rand.Int()",
+    "parent_xlen": "rand.Int()",
+    "parent_xval": "rand.Float64()",
+    "parent_xyangle": "rand.Float64()",
+    "parent_ylen": "rand.Int()",
+    "parent_yval": "rand.Float64()",
+    "parent_zval": "rand.Float64()",
+    "polygon": "struct{Points [][]float64}{[][]float64{{ 1.34},{12.33}}}",
+    "has_parent": true,
+    "primary": true,
+  }
+
+  Content(`
+func Test${entity.Name}AcceptList(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptList")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} list: %q", err)
+  }
+
+  entities, err := client.${entity.Name}().List()
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} list method: %v", err)
+  }
+
+  if len(entities) == 0 {
+    t.Fatalf("Error getting ${entity.name} accept list length == 0 and got %v", 
+     len(entities))
+  }
+
+  got := entities[0].Data
+
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept list - id equal to empty string")
+  }
+}
+
+
+func Test${entity.Name}AcceptLoad(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptLoad")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} load: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    Id: "t01",
+  }
+
+  client${entity.Name}, err := client.${entity.Name}().Load(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} load method: %v", err)
+  }
+
+  got := client${entity.Name}.Data
+  
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept load - id equal to empty string") 
+  }
+}
+
+func Test${entity.Name}AcceptCreate(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptCreate")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} create: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    `)
+  each(entity.field, (field: any) => {
+    const value = valueMap[field.name] ? valueMap[field.name] : field.type
+
+    if (value == "string") {
+      Content(`
+    ${field.Name}: "test",
+            `)
+      return
+    }
+    Content(`
+    ${field.Name}: ${value},
+            `)
+  })
+  Content(`
+  }
+
+  client${entity.Name}, err := client.${entity.Name}().Create(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} create method: %v", err)
+  }
+
+  got := client${entity.Name}.Data
+  
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept create - id equal to empty string") 
+  }
+}
+
+
+func Test${entity.Name}AcceptSave(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptSave")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} save: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    `)
+  each(entity.field, (field: any) => {
+    const value = valueMap[field.name] ? valueMap[field.name] : field.type
+
+    if (value == "string") {
+      Content(`
+    ${field.Name}: "test",
+            `)
+      return
+    }
+    Content(`
+    ${field.Name}: ${value},
+            `)
+  })
+  Content(`
+  }
+
+  client${entity.Name}, err := client.${entity.Name}().Save(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} save method: %v", err)
+  }
+
+  got := client${entity.Name}.Data
+  
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept create - id equal to empty string") 
+  }
+}
+
+func Test${entity.Name}AcceptRemove(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptRemove")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} remove: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    Id: "t01",
+  }
+
+  _, err = client.${entity.Name}().Remove(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} remove method: %v", err)
+  }
+}
+`);
+})
+
+
+export {
+  TestAcceptEntity
+}

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

@@ -0,0 +1,38 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+import { TestAcceptEntity } from './TestAcceptEntity_go'
+
+
+const TestAccept = cmp(function TestAccept(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+
+  File({ name: model.name + 'sdk_accept_test.' + build.name }, () => {
+
+    Content(`
+package ${model.name}sdk_test
+
+import (
+  "math/rand"
+  "testing"
+  "os"
+
+  "github.com/joho/godotenv"
+  "github.com/${model.name}/${model.name}-sdk"
+)
+         `)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestAcceptEntity({ model, build, entity })
+    })
+
+  })
+})
+
+
+export {
+  TestAccept
+}
+

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

@@ -0,0 +1,79 @@
+
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  Content(`
+func Test${entity.Name}List(t *testing.T) {
+  endpoint := "http://test.com"
+  apikey := "apikey"
+  want := ${entity.Name}Data{
+    Id: "${entity.name}t01",
+    Name: "${entity.Name}T01",
+  }
+
+  var options Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} list: %q", err)
+  }
+
+  respData := strings.NewReader(\`{"list":[{"id":"${entity.name}t01"},
+    {"id":"${entity.name}t02"}]}\`)
+  httpClientMock := createHttpClientMock(respData)
+  client.httpClient = *httpClientMock
+
+  entities, err := client.${entity.Name}().List()
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} list method: %q", err)
+  }
+
+  got := entities[0].Data
+  if got.Id != want.Id {
+    t.Fatalf("Error getting ${entity.name} list want %v and got %v", want, got)
+  }
+}
+
+func Test${entity.Name}Load(t *testing.T) {
+  endpoint := "http://test.com"
+  apikey := "apikey"
+  want := ${entity.Name}Data{
+    Id: "${entity.name}t01",
+  }
+
+  var options Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} load: %q", err)
+  }
+
+  respData := strings.NewReader(fmt.Sprintf(\`{"id":"${entity.name}t01"}\`))
+  httpClientMock := createHttpClientMock(respData)
+  client.httpClient = *httpClientMock
+
+  data := want
+  client${entity.Name}, err := client.${entity.Name}().Load(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} load method: %q", err)
+  }
+
+  got := client${entity.Name}.Data
+  if got.Id != want.Id {
+    t.Fatalf("Error getting ${entity.name} load want %v and got %v", want.Id, got.Id)
+  }
+}
+`)
+})
+
+
+export {
+  TestEntity
+}