Add client and server versions of generators (webrpc, schema and ridl…

… schema) (#72)

* add client and server versions of generators (webrpc, schema and ridl schema)

* rename to WebRpc

* improve naming

* generate only if includeHeaders option is set

* rename to Webrpc

* use one function to parse headers

* rename all occurences to Webrpc

* rename to webrpcHeader

* fix conditions in main.tmpl

* regenerate examples

README.md

@@ -32,6 +32,7 @@ Change any of the following values by passing `-option="Value"` CLI flag to `web
 | `-fixEmptyArrays` | `false` | force empty array `[]` instead of `null` in JSON (see Go [#27589][go27589]) | v0.13.0 |
 | `-errorStackTrace` | `false` | enables error stack traces | v0.14.0 |
 | `-legacyErrors` | `false` | enable legacy errors (v0.10.0 or older) | v0.11.0 |
+| `-webrpcHeader` | `true` | enable client send webrpc version in http headers | v0.16.0 |
 
 Example:
 ```

_examples/golang-basics/example.ridl

@@ -2,7 +2,6 @@ webrpc = v1 # version of webrpc schema format (ridl or json)
 
 name = example # name of your backend app
 version = v0.0.1 # version of your schema
-
 
 # user role
 # which defines which type of operations user can do
@@ -69,6 +68,8 @@ struct Version
  - webrpcVersion: string
  - schemaVersion: string
  - schemaHash: string
+ - clientGenVersion: GenVersions
+ - serverGenVersion: GenVersions
 
 struct ComplexType
  - meta: map<string,any>
@@ -81,6 +82,12 @@ struct ComplexType
  - mapOfUsers: map<string,User>
  - user: User
 
+struct GenVersions
+ - WebrpcGenVersion: string
+ - TmplTarget: string
+ - TmplVersion: string
+ - SchemaVersion: string
+
 error 500100 MissingArgument "missing argument"
 error 500101 InvalidUsername "invalid username"
 error 400100 MemoryFull "system memory is full"

_examples/golang-basics/example_test.go

@@ -38,6 +38,14 @@ func TestStatus(t *testing.T) {
  assert.NoError(t, err)
 }
 
+func TestVersion(t *testing.T) {
+ version, err := client.Version(context.Background())
+
+ assert.NoError(t, err)
+ assert.NotNil(t, version.ClientGenVersion)
+ assert.NotNil(t, version.ServerGenVersion)
+}
+
 func TestGetUser(t *testing.T) {
  {
  arg1 := map[string]string{"a": "1"}

_examples/golang-basics/main.go

@@ -48,10 +48,34 @@ func (rpc *ExampleServiceRPC) Status(ctx context.Context) (bool, error) {
 }
 
 func (rpc *ExampleServiceRPC) Version(ctx context.Context) (*Version, error) {
+ resp := ResponseWriterFromContext(ctx)
+ serverVersions, err := VersionFromHeader(resp.Header())
+ if err != nil {
+ return nil, fmt.Errorf("parse server webrpc gen versions: %w", err)
+ }
+
+ req := RequestFromContext(ctx)
+ clientVersions, err := VersionFromHeader(req.Header)
+ if err != nil {
+ return nil, fmt.Errorf("parse client webrpc gen versions: %w", err)
+ }
+
  return &Version{
  WebrpcVersion: WebRPCVersion(),
  SchemaVersion: WebRPCSchemaVersion(),
  SchemaHash: WebRPCSchemaHash(),
+ ClientGenVersion: &GenVersions{
+ WebrpcGenVersion: clientVersions.WebrpcGenVersion,
+ TmplTarget: clientVersions.CodeGenName,
+ TmplVersion: clientVersions.CodeGenVersion,
+ SchemaVersion: clientVersions.CodeGenVersion,
+ },
+ ServerGenVersion: &GenVersions{
+ WebrpcGenVersion: serverVersions.WebrpcGenVersion,
+ TmplTarget: serverVersions.CodeGenName,
+ TmplVersion: serverVersions.CodeGenVersion,
+ SchemaVersion: serverVersions.CodeGenVersion,
+ },
  }, nil
 }
 

client.go.tmpl

@@ -208,6 +208,9 @@ func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType
  }
  req.Header.Set("Accept", contentType)
  req.Header.Set("Content-Type", contentType)
+ {{- if eq $opts.webrpcHeader true }}
+ req.Header.Set(WebrpcHeader, WebrpcHeaderValue)
+ {{- end }}
  if headers, ok := HTTPRequestHeaders(ctx); ok {
  for k := range headers {
  for _, v := range headers[k] {

main.go.tmpl

@@ -11,6 +11,7 @@
 {{- set $opts "fixEmptyArrays" (ternary (in .Opts.fixEmptyArrays "" "true") true false) -}}
 {{- set $opts "errorStackTrace" (ternary (in .Opts.errorStackTrace "" "true") true false) -}}
 {{- set $opts "legacyErrors" (ternary (in .Opts.legacyErrors "" "true") true false) -}}
+{{- set $opts "webrpcHeader" (ternary (eq (default .Opts.webrpcHeader "true") "false") false true) -}}
 
 {{- $typePrefix := (last (split "/" $opts.importTypesFrom)) -}}
 {{- if ne $typePrefix "" -}}
@@ -81,6 +82,10 @@ package {{get $opts "pkg"}}
 
 {{template "imports" dict "Types" .Types "Opts" $opts }}
 
+const WebrpcHeader = "Webrpc"
+
+const WebrpcHeaderValue = "{{ .WebrpcHeader }}"
+
 // WebRPC description and code-gen version
 func WebRPCVersion() string {
  return "{{.WebrpcVersion}}"
@@ -96,6 +101,57 @@ func WebRPCSchemaHash() string {
  return "{{.SchemaHash}}"
 }
 
+type WebrpcGenVersions struct {
+ WebrpcGenVersion string
+ CodeGenName string
+ CodeGenVersion string
+ SchemaName string
+ SchemaVersion string
+}
+
+func VersionFromHeader(h http.Header) (*WebrpcGenVersions, error) {
+ if h.Get(WebrpcHeader) == "" {
+ return nil, fmt.Errorf("header is empty or missing")
+ }
+
+ versions, err := parseWebrpcGenVersions(h.Get(WebrpcHeader))
+ if err != nil {
+ return nil, fmt.Errorf("webrpc header is invalid: %w", err)
+ }
+
+ return versions, nil
+}
+
+func parseWebrpcGenVersions(header string) (*WebrpcGenVersions, error) {
+ versions := strings.Split(header, ";")
+ if len(versions) < 3 {
+ return nil, fmt.Errorf("expected at least 3 parts while parsing webrpc header: %v", header)
+ }
+
+ _, webrpcGenVersion, ok := strings.Cut(versions[0], "@")
+ if !ok {
+ return nil, fmt.Errorf("webrpc gen version could not be parsed from: %s", versions[0])
+ }
+
+ tmplTarget, tmplVersion, ok := strings.Cut(versions[1], "@")
+ if !ok {
+ return nil, fmt.Errorf("tmplTarget and tmplVersion could not be parsed from: %s", versions[1])
+ }
+
+ schemaName, schemaVersion, ok := strings.Cut(versions[2], "@")
+ if !ok {
+ return nil, fmt.Errorf("schema name and schema version could not be parsed from: %s", versions[2])
+ }
+
+ return &WebrpcGenVersions{
+ WebrpcGenVersion: webrpcGenVersion,
+ CodeGenName: tmplTarget,
+ CodeGenVersion: tmplVersion,
+ SchemaName: schemaName,
+ SchemaVersion: schemaVersion,
+ }, nil
+}
+
 {{- printf "\n" -}}
 
 {{- if eq $opts.importTypesFrom "" }}

server.go.tmpl

@@ -38,6 +38,8 @@ func (s *{{$serviceName}}) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  }
  }()
 
+ w.Header().Set(WebrpcHeader, WebrpcHeaderValue)
+
  ctx := r.Context()
  ctx = context.WithValue(ctx, HTTPResponseWriterCtxKey, w)
  ctx = context.WithValue(ctx, HTTPRequestCtxKey, r)