feat: support different content types based on schema type

server/api/api.go

@@ -1,15 +1,57 @@
 package api
 
 import (
+	"net/http"
+
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/odpf/stencil/server/domain"
 	stencilv1beta1 "github.com/odpf/stencil/server/odpf/stencil/v1beta1"
 	"google.golang.org/grpc/health/grpc_health_v1"
 )
 
+type getSchemaData func(http.ResponseWriter, *http.Request, map[string]string) (*domain.Metadata, []byte, error)
+type errHandleFunc func(http.ResponseWriter, *http.Request, map[string]string) error
+
 //API holds all handlers
 type API struct {
 	stencilv1beta1.UnimplementedStencilServiceServer
 	grpc_health_v1.UnimplementedHealthServer
 	Namespace domain.NamespaceService
 	Schema    domain.SchemaService
 }
+
+// RegisterSchemaHandlers registers HTTP handlers for schema download
+func (a *API) RegisterSchemaHandlers(mux *runtime.ServeMux) {
+	mux.HandlePath("GET", "/v1beta1/namespaces/{namespace}/schemas/{name}/versions/{version}", handleSchemaResponse(mux, a.HTTPGetSchema))
+	mux.HandlePath("GET", "/v1beta1/namespaces/{namespace}/schemas/{name}", handleSchemaResponse(mux, a.HTTPLatestSchema))
+	mux.HandlePath("POST", "/v1beta1/namespaces/{namespace}/schemas/{name}", wrapHandler(mux, a.HTTPUpload))
+}
+
+func handleSchemaResponse(mux *runtime.ServeMux, getSchemaFn getSchemaData) runtime.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
+		meta, data, err := getSchemaFn(w, r, pathParams)
+		if err != nil {
+			_, outbound := runtime.MarshalerForRequest(mux, r)
+			runtime.HTTPError(r.Context(), mux, outbound, w, r, err)
+			return
+		}
+		contentType := "application/json"
+		if meta.Format == "FORMAT_PROTOBUF" {
+			contentType = "application/octet-stream"
+		}
+		w.Header().Set("Content-Type", contentType)
+		w.WriteHeader(http.StatusOK)
+		w.Write(data)
+	}
+}
+
+func wrapHandler(mux *runtime.ServeMux, handler errHandleFunc) runtime.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
+		err := handler(w, r, pathParams)
+		if err != nil {
+			_, outbound := runtime.MarshalerForRequest(mux, r)
+			runtime.DefaultHTTPErrorHandler(r.Context(), mux, outbound, w, r, err)
+			return
+		}
+	}
+}

server/api/api_test.go

@@ -1,16 +1,19 @@
 package api_test
 
 import (
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/odpf/stencil/mocks"
 	"github.com/odpf/stencil/server/api"
 )
 
-func setup() (*mocks.NamespaceService, *mocks.SchemaService, *api.API) {
+func setup() (*mocks.NamespaceService, *mocks.SchemaService, *runtime.ServeMux, *api.API) {
 	nsService := &mocks.NamespaceService{}
 	schemaService := &mocks.SchemaService{}
-	v1 := &api.API{
+	mux := runtime.NewServeMux()
+	v1beta1 := &api.API{
 		Namespace: nsService,
 		Schema:    schemaService,
 	}
-	return nsService, schemaService, v1
+	v1beta1.RegisterSchemaHandlers(mux)
+	return nsService, schemaService, mux, v1beta1
 }

server/api/schema.go

@@ -2,7 +2,13 @@ package api
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"strconv"
 
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/odpf/stencil/server/domain"
 	stencilv1beta1 "github.com/odpf/stencil/server/odpf/stencil/v1beta1"
 )
@@ -16,26 +22,63 @@ func (a *API) CreateSchema(ctx context.Context, in *stencilv1beta1.CreateSchemaR
 		Location: sc.Location,
 	}, err
 }
+func (a *API) HTTPUpload(w http.ResponseWriter, req *http.Request, pathParams map[string]string) error {
+	data, err := io.ReadAll(req.Body)
+	if err != nil {
+		return err
+	}
+	format := req.Header.Get("X-Format")
+	compatibility := req.Header.Get("X-Compatibility")
+	metadata := &domain.Metadata{Format: format, Compatibility: compatibility}
+	namespaceID := pathParams["namespace"]
+	schemaName := pathParams["name"]
+	sc, err := a.Schema.Create(req.Context(), namespaceID, schemaName, metadata, data)
+	if err != nil {
+		return err
+	}
+	respData, _ := json.Marshal(sc)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	w.Write(respData)
+	return nil
+}
 
 func (a *API) ListSchemas(ctx context.Context, in *stencilv1beta1.ListSchemasRequest) (*stencilv1beta1.ListSchemasResponse, error) {
 	schemas, err := a.Schema.List(ctx, in.Id)
 	return &stencilv1beta1.ListSchemasResponse{Schemas: schemas}, err
 }
 
 func (a *API) GetLatestSchema(ctx context.Context, in *stencilv1beta1.GetLatestSchemaRequest) (*stencilv1beta1.GetLatestSchemaResponse, error) {
-	data, err := a.Schema.GetLatest(ctx, in.NamespaceId, in.SchemaId)
+	_, data, err := a.Schema.GetLatest(ctx, in.NamespaceId, in.SchemaId)
 	return &stencilv1beta1.GetLatestSchemaResponse{
 		Data: data,
 	}, err
 }
 
+func (a *API) HTTPLatestSchema(w http.ResponseWriter, req *http.Request, pathParams map[string]string) (*domain.Metadata, []byte, error) {
+	namespaceID := pathParams["namespace"]
+	schemaName := pathParams["name"]
+	return a.Schema.GetLatest(req.Context(), namespaceID, schemaName)
+}
+
 func (a *API) GetSchema(ctx context.Context, in *stencilv1beta1.GetSchemaRequest) (*stencilv1beta1.GetSchemaResponse, error) {
-	data, err := a.Schema.Get(ctx, in.NamespaceId, in.SchemaId, in.GetVersionId())
+	_, data, err := a.Schema.Get(ctx, in.NamespaceId, in.SchemaId, in.GetVersionId())
 	return &stencilv1beta1.GetSchemaResponse{
 		Data: data,
 	}, err
 }
 
+func (a *API) HTTPGetSchema(w http.ResponseWriter, req *http.Request, pathParams map[string]string) (*domain.Metadata, []byte, error) {
+	namespaceID := pathParams["namespace"]
+	schemaName := pathParams["name"]
+	versionString := pathParams["version"]
+	v, err := strconv.ParseInt(versionString, 10, 32)
+	if err != nil {
+		return nil, nil, &runtime.HTTPStatusError{HTTPStatus: http.StatusBadRequest, Err: errors.New("invalid version number")}
+	}
+	return a.Schema.Get(req.Context(), namespaceID, schemaName, int32(v))
+}
+
 func (a *API) ListVersions(ctx context.Context, in *stencilv1beta1.ListVersionsRequest) (*stencilv1beta1.ListVersionsResponse, error) {
 	versions, err := a.Schema.ListVersions(ctx, in.NamespaceId, in.SchemaId)
 	return &stencilv1beta1.ListVersionsResponse{Versions: versions}, err