create helper functions to parse server && client versions

_examples/golang-basics/main.go

@@ -48,38 +48,26 @@ func (rpc *ExampleServiceRPC) Status(ctx context.Context) (bool, error) {
 }
 
 func (rpc *ExampleServiceRPC) Version(ctx context.Context) (*Version, error) {
-	req := RequestFromContext(ctx)
-	writer := ResponseWriterFromContext(ctx)
-
-	if writer.Header().Get("Webrpc") == "" {
-		return nil, fmt.Errorf("server webrpc header is missing")
-	}
-
-	serverVersions, err := ParseWebRPCGenVersions(writer.Header().Get("Webrpc"))
+	serverVersions, err := ParseServerVersions(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("parse server webrpc gen versions: %w", err)
 	}
 
-	var clientVersions *GenVersions
-	if req.Header.Get("Webrpc") != "" {
-		parsedVersions, err := ParseWebRPCGenVersions(req.Header.Get("Webrpc"))
-		if err != nil {
-			return nil, fmt.Errorf("parse client webrpc gen versions: %w", err)
-		}
-
-		clientVersions = &GenVersions{
-			WebRPCGenVersion: parsedVersions.WebRPCGenVersion,
-			TmplTarget:       parsedVersions.TmplTarget,
-			TmplVersion:      parsedVersions.TmplVersion,
-			SchemaVersion:    parsedVersions.SchemaVersion,
-		}
+	clientVersions, err := ParseClientVersions(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("parse client webrpc gen versions: %w", err)
 	}
 
 	return &Version{
-		WebrpcVersion:    WebRPCVersion(),
-		SchemaVersion:    WebRPCSchemaVersion(),
-		SchemaHash:       WebRPCSchemaHash(),
-		ClientGenVersion: clientVersions,
+		WebrpcVersion: WebRPCVersion(),
+		SchemaVersion: WebRPCSchemaVersion(),
+		SchemaHash:    WebRPCSchemaHash(),
+		ClientGenVersion: &GenVersions{
+			WebRPCGenVersion: clientVersions.WebRPCGenVersion,
+			TmplTarget:       clientVersions.TmplTarget,
+			TmplVersion:      clientVersions.TmplVersion,
+			SchemaVersion:    clientVersions.SchemaVersion,
+		},
 		ServerGenVersion: &GenVersions{
 			WebRPCGenVersion: serverVersions.WebRPCGenVersion,
 			TmplTarget:       serverVersions.TmplTarget,

main.go.tmpl

@@ -81,6 +81,8 @@ package {{get $opts "pkg"}}
 
 {{template "imports" dict "Types" .Types "Opts" $opts }}
 
+const WebRPCVersionHeader = "Webrpc"
+
 // WebRPC description and code-gen version
 func WebRPCVersion() string {
 	return "{{.WebrpcVersion}}"
@@ -110,7 +112,43 @@ func WebRPCHeader() string {
     return "webrpc@{{.WebrpcGenVersion}};{{.TmplTarget}}@{{ if eq .TmplVersion "" }}unknown{{ else }}{{.TmplVersion}}{{end}};{{.SchemaName}}@{{.SchemaVersion}}"
 }
 
-func ParseWebRPCGenVersions(header string) (*WebRPCGenVersions, error) {
+func ParseServerVersions(ctx context.Context) (*WebRPCGenVersions, error) {
+    writer := ResponseWriterFromContext(ctx)
+
+    header := writer.Header().Get(WebRPCVersionHeader)
+    if header == "" {
+        return nil, fmt.Errorf("webrpc header is missing")
+    }
+
+    versions, err := parseWebRPCGenVersions(header)
+    if err != nil {
+        return nil, fmt.Errorf("webrpc header is invalid: %w", err)
+    }
+
+    return versions, nil
+}
+
+func ParseClientVersions(ctx context.Context) (*WebRPCGenVersions, error) {
+    req := RequestFromContext(ctx)
+    if req == nil {
+        return nil, fmt.Errorf("request is nil")
+    }
+
+    header := req.Header.Get(WebRPCVersionHeader)
+    if header == "" {
+        return nil, fmt.Errorf("webrpc header is missing")
+    }
+
+    versions, err := parseWebRPCGenVersions(header)
+    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: %s", header)

server.go.tmpl

@@ -38,7 +38,7 @@ func (s *{{$serviceName}}) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		}
 	}()
 
-	w.Header().Set("Webrpc", WebRPCHeader())
+	w.Header().Set(WebRPCVersionHeader, WebRPCHeader())
 
 	ctx := r.Context()
 	ctx = context.WithValue(ctx, HTTPResponseWriterCtxKey, w)