implement openrpc-codegen tool:

- create openrpc.json spec file that represent all zos types and api
  handlers
- create a tool that generate go types/methods from the spec file with
  the limitation for the `net/rpc` package services

Author: Omarabdul3ziz

openrpc.json

@@ -0,0 +1,3 @@
+
+build:
+	sudo go build -o /usr/local/bin/openrpc-codegen main.go 

tools/openrpc-codegen/Makefile

@@ -0,0 +1,22 @@
+package fileutils
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/threefoldtech/zos/tools/openrpc-codegen/schema"
+)
+
+func Parse(filePath string) (spec schema.Spec, err error) {
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return spec, fmt.Errorf("failed to read file content filepath=%v: %w", filePath, err)
+	}
+
+	if err := json.Unmarshal(content, &spec); err != nil {
+		return spec, fmt.Errorf("failed to unmarshal file content to schema spec: %w", err)
+	}
+
+	return spec, nil
+}

tools/openrpc-codegen/fileutils/parser.go

@@ -0,0 +1,27 @@
+package fileutils
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"os"
+)
+
+func Write(buf bytes.Buffer, filePath string) error {
+	formatted, err := format.Source(buf.Bytes())
+	if err != nil {
+		return fmt.Errorf("failed to format buffer content: %w", err)
+	}
+
+	file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
+	if err != nil {
+		return fmt.Errorf("failed to open file for writing filepath=%v: %w", filePath, err)
+	}
+	defer file.Close()
+
+	if _, err := file.Write(formatted); err != nil {
+		return fmt.Errorf("failed to write on file: %w", err)
+	}
+
+	return nil
+}

tools/openrpc-codegen/fileutils/writer.go

@@ -0,0 +1,132 @@
+package generator
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/threefoldtech/zos/tools/openrpc-codegen/schema"
+)
+
+func generateStructs(buf *bytes.Buffer, name string, schema schema.Schema) error {
+	fields := []field{}
+	for n, prop := range schema.Properties {
+		// Handle nested properties recursively
+		propType, err := generateType(buf, n, prop)
+		if err != nil {
+			return err
+		}
+		fields = append(fields, field{
+			Name:     n,
+			Type:     propType,
+			JSONName: prop.Tag,
+		})
+	}
+
+	return executeTemplate(buf, structTemplate, structType{
+		Name:   name,
+		Fields: fields,
+	})
+}
+
+func generateType(buf *bytes.Buffer, name string, schema schema.Schema) (string, error) {
+	if schema.Ref != "" {
+		return invokeRef(schema.Ref), nil
+	}
+
+	if schema.Format == "raw" {
+		return convertToGoType(invokeRef(schema.Type), schema.Format), nil
+	}
+
+	switch schema.Type {
+	case "object":
+		if err := generateStructs(buf, name, schema); err != nil {
+			return "", err
+		}
+		return name, nil
+	case "array":
+		if schema.Items.Ref != "" {
+			return "[]" + invokeRef(schema.Items.Ref), nil
+		}
+		itemType, err := generateType(buf, name, *schema.Items)
+		if err != nil {
+			return "", err
+		}
+		return "[]" + itemType, nil
+	default:
+		return convertToGoType(invokeRef(schema.Type), schema.Format), nil
+	}
+}
+
+func generateSchemas(buf *bytes.Buffer, schemas map[string]schema.Schema) error {
+	for key, schema := range schemas {
+		_, err := generateType(buf, key, schema)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func generateMethods(buf *bytes.Buffer, serviceName string, methods []schema.Method) error {
+	ms := []methodType{}
+	for _, method := range methods {
+		methodName := extractMethodName(method.Name)
+		arg, reply, err := getMethodTypes(method)
+		if err != nil {
+			return err
+		}
+		ms = append(ms, methodType{
+			Name:      methodName,
+			ArgType:   arg,
+			ReplyType: reply,
+		})
+	}
+
+	return executeTemplate(buf, MethodTemplate, service{
+		Name:    serviceName,
+		Methods: ms,
+	})
+}
+
+func getMethodTypes(method schema.Method) (string, string, error) {
+	argType, replyType := "any", ""
+
+	if len(method.Params) == 1 {
+		argType = getTypeFromSchema(method.Params[0].Schema)
+	} else if len(method.Params) > 1 {
+		return "", "", fmt.Errorf("multiple parameters not supported for method: %v", method.Name)
+	}
+
+	if method.Result.Schema.Type != "" {
+		replyType = convertToGoType(method.Result.Schema.Type, method.Result.Schema.Format)
+	} else if method.Result.Schema.Ref != "" {
+		replyType = invokeRef(method.Result.Schema.Ref)
+	} else {
+		return "", "", fmt.Errorf("no result defined for method: %v", method.Name)
+	}
+
+	return argType, replyType, nil
+}
+
+func getTypeFromSchema(schema schema.Schema) string {
+	if schema.Type != "" {
+		return convertToGoType(schema.Type, schema.Format)
+	}
+	return invokeRef(schema.Ref)
+}
+
+func GenerateServerCode(buf *bytes.Buffer, spec schema.Spec, pkg string) error {
+	if err := addPackageName(buf, pkg); err != nil {
+		return fmt.Errorf("failed to write pkg name: %w", err)
+	}
+
+	if err := generateMethods(buf, spec.Info.Title, spec.Methods); err != nil {
+		return fmt.Errorf("failed to generate methods: %w", err)
+	}
+
+	if err := generateSchemas(buf, spec.Components.Schemas); err != nil {
+		return fmt.Errorf("failed to generate schema: %w", err)
+	}
+
+	return nil
+}

tools/openrpc-codegen/generator/generator.go

@@ -0,0 +1,39 @@
+package generator
+
+type structType struct {
+	Name   string
+	Fields []field
+}
+
+type field struct {
+	Name     string
+	Type     string
+	JSONName string
+}
+
+const structTemplate = `
+type {{.Name}} struct {
+{{- range .Fields }}
+  {{ .Name }} {{ .Type }} ` + "`json:\"{{ .JSONName }}\"`" + `
+{{- end }}
+}
+`
+
+type service struct {
+	Name    string
+	Methods []methodType
+}
+
+type methodType struct {
+	Name      string
+	ArgType   string
+	ReplyType string
+}
+
+const MethodTemplate = `
+type {{.Name}} interface {
+{{- range .Methods }}
+  {{.Name}}({{.ArgType}}, *{{.ReplyType}}) error
+{{- end}}
+}
+`

tools/openrpc-codegen/generator/templates.go

@@ -0,0 +1,53 @@
+package generator
+
+import (
+	"bytes"
+	"fmt"
+	"path"
+	"strings"
+	"text/template"
+)
+
+func convertToGoType(t string, f string) string {
+	if f == "raw" {
+		return "json.RawMessage"
+	}
+
+	switch t {
+	case "integer":
+		return "uint64"
+	case "number":
+		return "float64"
+	case "boolean":
+		return "bool"
+	case "null":
+		return "any"
+	default:
+		return t
+	}
+}
+
+func invokeRef(t string) string {
+	return path.Base(t)
+}
+
+func extractMethodName(methodText string) string {
+	return strings.Split(methodText, ".")[len(strings.Split(methodText, "."))-1]
+}
+
+func executeTemplate(buf *bytes.Buffer, tmpl string, data interface{}) error {
+	templ, err := template.New("").Parse(tmpl)
+	if err != nil {
+		return fmt.Errorf("failed to parse template: %w", err)
+	}
+	if err := templ.Execute(buf, data); err != nil {
+		return fmt.Errorf("failed to execute template: %w", err)
+	}
+	return nil
+}
+
+func addPackageName(buf *bytes.Buffer, pkg string) error {
+	pkgLine := fmt.Sprintf("package %s\n", pkg)
+	_, err := buf.Write([]byte(pkgLine))
+	return err
+}

tools/openrpc-codegen/generator/utils.go

@@ -0,0 +1,3 @@
+module github.com/threefoldtech/zos/tools/openrpc-codegen
+
+go 1.21.0

tools/openrpc-codegen/go.mod

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+
+	"github.com/threefoldtech/zos/tools/openrpc-codegen/fileutils"
+	"github.com/threefoldtech/zos/tools/openrpc-codegen/generator"
+)
+
+type flags struct {
+	spec   string
+	output string
+	pkg    string
+}
+
+func run() error {
+	var f flags
+	flag.StringVar(&f.spec, "spec", "", "openrpc spec file")
+	flag.StringVar(&f.output, "output", "", "generated go code")
+	flag.StringVar(&f.pkg, "pkg", "apirpc", "name of the go package")
+	flag.Parse()
+
+	if f.spec == "" || f.output == "" {
+		return fmt.Errorf("missing flag is required")
+	}
+
+	spec, err := fileutils.Parse(f.spec)
+	if err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	if err := generator.GenerateServerCode(&buf, spec, f.pkg); err != nil {
+		return err
+	}
+
+	if err := fileutils.Write(buf, f.output); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}

tools/openrpc-codegen/go.sum

@@ -0,0 +1,52 @@
+# OpenRPC CodeGen
+
+this tools generate server side code in go from an openrpc spec file
+
+## Usage
+
+Manually generate code
+
+```bash
+go run main.go -spec </path/to/specfile> -output </path/to/generated/code>
+```
+
+Use it to generate the api code
+
+```bash
+make build
+# go to root
+go generate
+```
+
+## Limitations
+
+Any openrpc file that passes the linting on the [playground](https://playground.open-rpc.org/) should be valid for this tool. with just some limitations:
+
+- Methods must have only one arg/reply: since we use `net/rpc` package it requires to have only a single arg and reply.
+- Methods can have arg/reply defined only for a primitive types. but for custom types array/objects it must be defined on the components schema and referenced in the method.
+- Array is not a valid reply type, you need to define an object in the components that have a field of this array. and reference it on the method.
+- Method Name, component Name, and component fields name must be a `PascalCase`
+- Component fields must have a tag field, it is interpreted to a json tag on the generated struct and it is necessary in the conversion to the zos types.
+
+## Extensions
+
+- for compatibility with gridtypes we needed to configure some extra formats like
+
+  ```json
+  "Data": {
+    "tag": "data",
+    "type": "object",
+    "format": "raw"
+  }
+  ```
+
+  which will generate a json.RawMessage type
+
+## Notes
+
+- All types and fields should be upper case.
+
+## Enhancements
+
+- [ ] write structs in order
+- [ ] extend the spec file to have errors and examples and docs