chore: move search and namespace domain to search package (#139)

ravisuhag · web-flow · commit 7a8f93b943ce · 2022-08-27T12:25:11.000-05:00
* chore: move search domain to search package

* chore: move namespace domain to namespace
diff --git a/core/namespace/namespace.go b/core/namespace/namespace.go
@@ -1,4 +1,4 @@
-package domain
+package namespace
 
 import (
 	"context"
diff --git a/core/namespace/service.go b/core/namespace/service.go
@@ -2,27 +2,25 @@ package namespace
 
 import (
 	"context"
-
-	"github.com/odpf/stencil/domain"
 )
 
 type Service struct {
-	Repo domain.NamespaceRepository
+	Repo NamespaceRepository
 }
 
-func (s Service) Create(ctx context.Context, ns domain.Namespace) (domain.Namespace, error) {
+func (s Service) Create(ctx context.Context, ns Namespace) (Namespace, error) {
 	return s.Repo.CreateNamespace(ctx, ns)
 }
 
-func (s Service) Update(ctx context.Context, ns domain.Namespace) (domain.Namespace, error) {
+func (s Service) Update(ctx context.Context, ns Namespace) (Namespace, error) {
 	return s.Repo.UpdateNamespace(ctx, ns)
 }
 
 func (s Service) List(ctx context.Context) ([]string, error) {
 	return s.Repo.ListNamespaces(ctx)
 }
 
-func (s Service) Get(ctx context.Context, name string) (domain.Namespace, error) {
+func (s Service) Get(ctx context.Context, name string) (Namespace, error) {
 	return s.Repo.GetNamespace(ctx, name)
 }
 
diff --git a/core/schema/service.go b/core/schema/service.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/google/uuid"
+	"github.com/odpf/stencil/core/namespace"
 	"github.com/odpf/stencil/domain"
 	"github.com/odpf/stencil/internal/store"
 )
@@ -28,7 +29,7 @@ func getBytes(key interface{}) []byte {
 	return buf
 }
 
-func NewService(repo domain.SchemaRepository, provider SchemaProvider, nsSvc domain.NamespaceService, cache schemaCache) *Service {
+func NewService(repo domain.SchemaRepository, provider SchemaProvider, nsSvc namespace.NamespaceService, cache schemaCache) *Service {
 	return &Service{
 		Repo:           repo,
 		SchemaProvider: provider,
@@ -45,7 +46,7 @@ type schemaCache interface {
 type Service struct {
 	SchemaProvider SchemaProvider
 	Repo           domain.SchemaRepository
-	NamespaceSvc   domain.NamespaceService
+	NamespaceSvc   namespace.NamespaceService
 	cache          schemaCache
 }
 
diff --git a/core/schema/service_test.go b/core/schema/service_test.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"testing"
 
+	"github.com/odpf/stencil/core/namespace"
 	"github.com/odpf/stencil/core/schema"
 	"github.com/odpf/stencil/domain"
 	"github.com/odpf/stencil/internal/store"
@@ -30,7 +31,7 @@ func TestSchemaCreate(t *testing.T) {
 	t.Run("should return error if namespace not found", func(t *testing.T) {
 		svc, nsService, _, _ := getSvc()
 		nsName := "testNamespace"
-		nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{}, store.NoRowsErr)
+		nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{}, store.NoRowsErr)
 		_, err := svc.Create(ctx, nsName, "a", &domain.Metadata{}, []byte(""))
 		assert.NotNil(t, err)
 		assert.ErrorIs(t, err, store.NoRowsErr)
@@ -41,7 +42,7 @@ func TestSchemaCreate(t *testing.T) {
 		svc, nsService, schemaProvider, _ := getSvc()
 		nsName := "testNamespace"
 		data := []byte("data")
-		nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{Format: "avro"}, nil)
+		nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{Format: "avro"}, nil)
 		schemaProvider.On("ParseSchema", "protobuf", data).Return(&mocks.ParsedSchema{}, errors.New("invalid schema"))
 		_, err := svc.Create(ctx, nsName, "a", &domain.Metadata{Format: "protobuf"}, data)
 		assert.NotNil(t, err)
@@ -52,7 +53,7 @@ func TestSchemaCreate(t *testing.T) {
 		svc, nsService, schemaProvider, _ := getSvc()
 		nsName := "testNamespace"
 		data := []byte("data")
-		nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{Format: "protobuf"}, nil)
+		nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{Format: "protobuf"}, nil)
 		schemaProvider.On("ParseSchema", "protobuf", data).Return(&mocks.ParsedSchema{}, errors.New("invalid schema"))
 		_, err := svc.Create(ctx, nsName, "a", &domain.Metadata{}, data)
 		assert.NotNil(t, err)
@@ -65,7 +66,7 @@ func TestSchemaCreate(t *testing.T) {
 		parsedSchema := &mocks.ParsedSchema{}
 		nsName := "testNamespace"
 		data := []byte("data")
-		nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{Format: "protobuf"}, nil)
+		nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{Format: "protobuf"}, nil)
 		schemaProvider.On("ParseSchema", "protobuf", data).Return(parsedSchema, nil)
 		schemaRepo.On("GetLatestVersion", mock.Anything, nsName, "a").Return(int32(2), store.NoRowsErr)
 		parsedSchema.On("GetCanonicalValue").Return(scFile)
@@ -81,7 +82,7 @@ func TestSchemaCreate(t *testing.T) {
 		parsedSchema := &mocks.ParsedSchema{}
 		nsName := "testNamespace"
 		data := []byte("data")
-		nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{Format: "protobuf"}, nil)
+		nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{Format: "protobuf"}, nil)
 		schemaProvider.On("ParseSchema", "protobuf", data).Return(parsedSchema, nil)
 		schemaRepo.On("GetLatestVersion", mock.Anything, nsName, "a").Return(int32(2), errors.New("some other error apart from noRowsError"))
 		_, err := svc.Create(ctx, nsName, "a", &domain.Metadata{}, data)
@@ -96,7 +97,7 @@ func TestSchemaCreate(t *testing.T) {
 		nsName := "testNamespace"
 		data := []byte("data aa")
 		prevData := []byte("some prev data")
-		nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{Format: "protobuf", Compatibility: "COMPATIBILITY_BACKWARD"}, nil)
+		nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{Format: "protobuf", Compatibility: "COMPATIBILITY_BACKWARD"}, nil)
 		schemaProvider.On("ParseSchema", "protobuf", data).Return(parsedSchema, nil).Once()
 		schemaRepo.On("GetSchemaMetadata", mock.Anything, nsName, "a").Return(&domain.Metadata{Format: "protobuf"}, nil)
 		schemaRepo.On("GetLatestVersion", mock.Anything, nsName, "a").Return(int32(3), nil)
@@ -130,7 +131,7 @@ func TestSchemaCreate(t *testing.T) {
 				if test.isError {
 					compErr = errors.New("compatibilit error")
 				}
-				nsService.On("Get", mock.Anything, nsName).Return(domain.Namespace{Format: "protobuf", Compatibility: "COMPATIBILITY_BACKWARD"}, nil)
+				nsService.On("Get", mock.Anything, nsName).Return(namespace.Namespace{Format: "protobuf", Compatibility: "COMPATIBILITY_BACKWARD"}, nil)
 				schemaProvider.On("ParseSchema", "protobuf", data).Return(parsedSchema, nil).Once()
 				schemaRepo.On("GetSchemaMetadata", mock.Anything, nsName, "a").Return(&domain.Metadata{Format: "protobuf"}, nil)
 				schemaRepo.On("GetLatestVersion", mock.Anything, nsName, "a").Return(int32(3), nil)
diff --git a/core/search/search.go b/core/search/search.go
@@ -1,4 +1,4 @@
-package domain
+package search
 
 import "context"
 
diff --git a/core/search/service.go b/core/search/service.go
@@ -3,8 +3,6 @@ package search
 import (
 	"context"
 	"errors"
-
-	"github.com/odpf/stencil/domain"
 )
 
 var (
@@ -14,10 +12,10 @@ var (
 )
 
 type Service struct {
-	Repo domain.SearchRepository
+	Repo SearchRepository
 }
 
-func (s *Service) Search(ctx context.Context, req *domain.SearchRequest) (*domain.SearchResponse, error) {
+func (s *Service) Search(ctx context.Context, req *SearchRequest) (*SearchResponse, error) {
 	if req.Query == "" {
 		return nil, ErrEmptyQueryString
 	}
@@ -26,7 +24,7 @@ func (s *Service) Search(ctx context.Context, req *domain.SearchRequest) (*domai
 		return nil, ErrEmptyNamespaceID
 	}
 
-	var res []*domain.SearchHits
+	var res []*SearchHits
 	var err error
 	if req.VersionID == 0 && !req.History {
 		res, err = s.Repo.SearchLatest(ctx, req)
@@ -40,7 +38,7 @@ func (s *Service) Search(ctx context.Context, req *domain.SearchRequest) (*domai
 	if err != nil {
 		return nil, err
 	}
-	return &domain.SearchResponse{
+	return &SearchResponse{
 		Hits: res,
 	}, nil
 }
diff --git a/internal/api/api.go b/internal/api/api.go
@@ -7,6 +7,8 @@ import (
 
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/newrelic/go-agent/v3/newrelic"
+	"github.com/odpf/stencil/core/namespace"
+	"github.com/odpf/stencil/core/search"
 	"github.com/odpf/stencil/domain"
 	stencilv1beta1 "github.com/odpf/stencil/proto/odpf/stencil/v1beta1"
 	"google.golang.org/grpc/health/grpc_health_v1"
@@ -19,12 +21,12 @@ type errHandleFunc func(http.ResponseWriter, *http.Request, map[string]string) e
 type API struct {
 	stencilv1beta1.UnimplementedStencilServiceServer
 	grpc_health_v1.UnimplementedHealthServer
-	namespace domain.NamespaceService
+	namespace namespace.NamespaceService
 	schema    domain.SchemaService
-	search    domain.SearchService
+	search    search.SearchService
 }
 
-func NewAPI(namespace domain.NamespaceService, schema domain.SchemaService, search domain.SearchService) *API {
+func NewAPI(namespace namespace.NamespaceService, schema domain.SchemaService, search search.SearchService) *API {
 	return &API{
 		namespace: namespace,
 		schema:    schema,
diff --git a/internal/api/namespace.go b/internal/api/namespace.go
@@ -3,21 +3,21 @@ package api
 import (
 	"context"
 
-	"github.com/odpf/stencil/domain"
+	"github.com/odpf/stencil/core/namespace"
 	stencilv1beta1 "github.com/odpf/stencil/proto/odpf/stencil/v1beta1"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-func createNamespaceRequestToNamespace(r *stencilv1beta1.CreateNamespaceRequest) domain.Namespace {
-	return domain.Namespace{
+func createNamespaceRequestToNamespace(r *stencilv1beta1.CreateNamespaceRequest) namespace.Namespace {
+	return namespace.Namespace{
 		ID:            r.GetId(),
 		Format:        r.GetFormat().String(),
 		Compatibility: r.GetCompatibility().String(),
 		Description:   r.GetDescription(),
 	}
 }
 
-func namespaceToProto(ns domain.Namespace) *stencilv1beta1.Namespace {
+func namespaceToProto(ns namespace.Namespace) *stencilv1beta1.Namespace {
 	return &stencilv1beta1.Namespace{
 		Id:            ns.ID,
 		Format:        stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[ns.Format]),
@@ -36,7 +36,7 @@ func (a *API) CreateNamespace(ctx context.Context, in *stencilv1beta1.CreateName
 }
 
 func (a *API) UpdateNamespace(ctx context.Context, in *stencilv1beta1.UpdateNamespaceRequest) (*stencilv1beta1.UpdateNamespaceResponse, error) {
-	ns, err := a.namespace.Update(ctx, domain.Namespace{ID: in.GetId(), Format: in.GetFormat().String(), Compatibility: in.GetCompatibility().String(), Description: in.GetDescription()})
+	ns, err := a.namespace.Update(ctx, namespace.Namespace{ID: in.GetId(), Format: in.GetFormat().String(), Compatibility: in.GetCompatibility().String(), Description: in.GetDescription()})
 	return &stencilv1beta1.UpdateNamespaceResponse{Namespace: namespaceToProto(ns)}, err
 }
 
diff --git a/internal/api/search.go b/internal/api/search.go
@@ -4,12 +4,12 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/odpf/stencil/domain"
+	"github.com/odpf/stencil/core/search"
 	stencilv1beta1 "github.com/odpf/stencil/proto/odpf/stencil/v1beta1"
 )
 
 func (a *API) Search(ctx context.Context, in *stencilv1beta1.SearchRequest) (*stencilv1beta1.SearchResponse, error) {
-	searchReq := &domain.SearchRequest{
+	searchReq := &search.SearchRequest{
 		NamespaceID: in.GetNamespaceId(),
 		Query:       in.GetQuery(),
 		SchemaID:    in.GetSchemaId(),
diff --git a/internal/store/postgres/repository.go b/internal/store/postgres/repository.go
@@ -8,6 +8,8 @@ import (
 	"github.com/georgysavva/scany/pgxscan"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
+	"github.com/odpf/stencil/core/namespace"
+	"github.com/odpf/stencil/core/search"
 	"github.com/odpf/stencil/domain"
 	"github.com/odpf/stencil/internal/store"
 )
@@ -42,20 +44,20 @@ func (r *Store) Close() {
 	r.db.Close()
 }
 
-func (r *Store) CreateNamespace(ctx context.Context, ns domain.Namespace) (domain.Namespace, error) {
-	newNamespace := domain.Namespace{}
+func (r *Store) CreateNamespace(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error) {
+	newNamespace := namespace.Namespace{}
 	err := pgxscan.Get(ctx, r.db, &newNamespace, namespaceInsertQuery, ns.ID, ns.Format, ns.Compatibility, ns.Description)
 	return newNamespace, wrapError(err, ns.ID)
 }
 
-func (r *Store) UpdateNamespace(ctx context.Context, ns domain.Namespace) (domain.Namespace, error) {
-	newNamespace := domain.Namespace{}
+func (r *Store) UpdateNamespace(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error) {
+	newNamespace := namespace.Namespace{}
 	err := pgxscan.Get(ctx, r.db, &newNamespace, namespaceUpdateQuery, ns.ID, ns.Format, ns.Compatibility, ns.Description)
 	return newNamespace, wrapError(err, ns.ID)
 }
 
-func (r *Store) GetNamespace(ctx context.Context, id string) (domain.Namespace, error) {
-	newNamespace := domain.Namespace{}
+func (r *Store) GetNamespace(ctx context.Context, id string) (namespace.Namespace, error) {
+	newNamespace := namespace.Namespace{}
 	err := pgxscan.Get(ctx, r.db, &newNamespace, namespaceGetQuery, id)
 	return newNamespace, wrapError(err, id)
 }
@@ -151,14 +153,14 @@ func (r *Store) DeleteVersion(ctx context.Context, ns string, sc string, version
 	return wrapError(err, "delete version")
 }
 
-func (r *Store) Search(ctx context.Context, req *domain.SearchRequest) ([]*domain.SearchHits, error) {
-	var searchHits []*domain.SearchHits
+func (r *Store) Search(ctx context.Context, req *search.SearchRequest) ([]*search.SearchHits, error) {
+	var searchHits []*search.SearchHits
 	err := pgxscan.Select(ctx, r.db, &searchHits, searchAllQuery, req.NamespaceID, req.SchemaID, req.VersionID, req.Query)
 	return searchHits, err
 }
 
-func (r *Store) SearchLatest(ctx context.Context, req *domain.SearchRequest) ([]*domain.SearchHits, error) {
-	var searchHits []*domain.SearchHits
+func (r *Store) SearchLatest(ctx context.Context, req *search.SearchRequest) ([]*search.SearchHits, error) {
+	var searchHits []*search.SearchHits
 	err := pgxscan.Select(ctx, r.db, &searchHits, searchLatestQuery, req.NamespaceID, req.SchemaID, req.Query)
 	return searchHits, err
 }
diff --git a/internal/store/postgres/repository_test.go b/internal/store/postgres/repository_test.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/odpf/stencil/core/namespace"
 	"github.com/odpf/stencil/domain"
 	"github.com/odpf/stencil/internal/store"
 	"github.com/odpf/stencil/internal/store/postgres"
@@ -36,7 +37,7 @@ func tearDown(t *testing.T) {
 	}
 }
 
-func assertNamespace(t *testing.T, expected, actual domain.Namespace) {
+func assertNamespace(t *testing.T, expected, actual namespace.Namespace) {
 	t.Helper()
 	assert.Equal(t, expected.ID, actual.ID)
 	assert.Equal(t, expected.Compatibility, actual.Compatibility)
@@ -50,7 +51,7 @@ func TestStorage(t *testing.T) {
 	tearDown(t)
 	db := getStore(t)
 	ctx := context.Background()
-	n := &domain.Namespace{ID: "test", Format: "protobuf", Compatibility: "FULL", Description: "testDesc"}
+	n := &namespace.Namespace{ID: "test", Format: "protobuf", Compatibility: "FULL", Description: "testDesc"}
 	t.Run("Namespace", func(t *testing.T) {
 		t.Run("create: should create namespace", func(t *testing.T) {
 			ns, err := db.CreateNamespace(ctx, *n)
@@ -95,7 +96,7 @@ func TestStorage(t *testing.T) {
 	})
 
 	t.Run("schema", func(t *testing.T) {
-		n := &domain.Namespace{ID: "testschema", Format: "protobuf", Compatibility: "FULL", Description: "testDesc"}
+		n := &namespace.Namespace{ID: "testschema", Format: "protobuf", Compatibility: "FULL", Description: "testDesc"}
 		_, err := db.CreateNamespace(ctx, *n)
 		assert.Nil(t, err)
 		meta := &domain.Metadata{
diff --git a/internal/store/store.go b/internal/store/store.go
@@ -1,11 +1,12 @@
 package store
 
 import (
+	"github.com/odpf/stencil/core/namespace"
 	"github.com/odpf/stencil/domain"
 )
 
 // Store is the interface that all database objects must implement.
 type Store interface {
-	domain.NamespaceRepository
+	namespace.NamespaceRepository
 	domain.SchemaRepository
 }
diff --git a/mocks/NamespaceRepository.go b/mocks/NamespaceRepository.go
diff --git a/mocks/NamespaceService.go b/mocks/NamespaceService.go
diff --git a/mocks/SearchRepository.go b/mocks/SearchRepository.go
diff --git a/mocks/SearchService.go b/mocks/SearchService.go
diff --git a/mocks/Store.go b/mocks/Store.go

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package domain`
	`1`	`+package namespace`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"context"`
Original file line number	Diff line number	Diff line change
`@@ -2,27 +2,25 @@ package namespace`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"context"`
`5`		`-`
`6`		`- "github.com/odpf/stencil/domain"`
`7`	`5`	`)`
`8`	`6`
`9`	`7`	`type Service struct {`
`10`		`- Repo domain.NamespaceRepository`
	`8`	`+ Repo NamespaceRepository`
`11`	`9`	`}`
`12`	`10`
`13`		`-func (s Service) Create(ctx context.Context, ns domain.Namespace) (domain.Namespace, error) {`
	`11`	`+func (s Service) Create(ctx context.Context, ns Namespace) (Namespace, error) {`
`14`	`12`	`return s.Repo.CreateNamespace(ctx, ns)`
`15`	`13`	`}`
`16`	`14`
`17`		`-func (s Service) Update(ctx context.Context, ns domain.Namespace) (domain.Namespace, error) {`
	`15`	`+func (s Service) Update(ctx context.Context, ns Namespace) (Namespace, error) {`
`18`	`16`	`return s.Repo.UpdateNamespace(ctx, ns)`
`19`	`17`	`}`
`20`	`18`
`21`	`19`	`func (s Service) List(ctx context.Context) ([]string, error) {`
`22`	`20`	`return s.Repo.ListNamespaces(ctx)`
`23`	`21`	`}`
`24`	`22`
`25`		`-func (s Service) Get(ctx context.Context, name string) (domain.Namespace, error) {`
	`23`	`+func (s Service) Get(ctx context.Context, name string) (Namespace, error) {`
`26`	`24`	`return s.Repo.GetNamespace(ctx, name)`
`27`	`25`	`}`
`28`	`26`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package domain`
	`1`	`+package search`
`2`	`2`
`3`	`3`	`import "context"`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,6 @@ package search`
`3`	`3`	`import (`
`4`	`4`	`"context"`
`5`	`5`	`"errors"`
`6`		`-`
`7`		`- "github.com/odpf/stencil/domain"`
`8`	`6`	`)`
`9`	`7`
`10`	`8`	`var (`
`@@ -14,10 +12,10 @@ var (`
`14`	`12`	`)`
`15`	`13`
`16`	`14`	`type Service struct {`
`17`		`- Repo domain.SearchRepository`
	`15`	`+ Repo SearchRepository`
`18`	`16`	`}`
`19`	`17`
`20`		`-func (s Service) Search(ctx context.Context, req domain.SearchRequest) (*domain.SearchResponse, error) {`
	`18`	`+func (s Service) Search(ctx context.Context, req SearchRequest) (*SearchResponse, error) {`
`21`	`19`	`if req.Query == "" {`
`22`	`20`	`return nil, ErrEmptyQueryString`
`23`	`21`	`}`
`@@ -26,7 +24,7 @@ func (s Service) Search(ctx context.Context, req domain.SearchRequest) (*domai`
`26`	`24`	`return nil, ErrEmptyNamespaceID`
`27`	`25`	`}`
`28`	`26`
`29`		`- var res []*domain.SearchHits`
	`27`	`+ var res []*SearchHits`
`30`	`28`	`var err error`
`31`	`29`	`if req.VersionID == 0 && !req.History {`
`32`	`30`	`res, err = s.Repo.SearchLatest(ctx, req)`
`@@ -40,7 +38,7 @@ func (s Service) Search(ctx context.Context, req domain.SearchRequest) (*domai`
`40`	`38`	`if err != nil {`
`41`	`39`	`return nil, err`
`42`	`40`	`}`
`43`		`- return &domain.SearchResponse{`
	`41`	`+ return &SearchResponse{`
`44`	`42`	`Hits: res,`
`45`	`43`	`}, nil`
`46`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,21 +3,21 @@ package api`
`3`	`3`	`import (`
`4`	`4`	`"context"`
`5`	`5`
`6`		`- "github.com/odpf/stencil/domain"`
	`6`	`+ "github.com/odpf/stencil/core/namespace"`
`7`	`7`	`stencilv1beta1 "github.com/odpf/stencil/proto/odpf/stencil/v1beta1"`
`8`	`8`	`"google.golang.org/protobuf/types/known/timestamppb"`
`9`	`9`	`)`
`10`	`10`
`11`		`-func createNamespaceRequestToNamespace(r *stencilv1beta1.CreateNamespaceRequest) domain.Namespace {`
`12`		`- return domain.Namespace{`
	`11`	`+func createNamespaceRequestToNamespace(r *stencilv1beta1.CreateNamespaceRequest) namespace.Namespace {`
	`12`	`+ return namespace.Namespace{`
`13`	`13`	`ID: r.GetId(),`
`14`	`14`	`Format: r.GetFormat().String(),`
`15`	`15`	`Compatibility: r.GetCompatibility().String(),`
`16`	`16`	`Description: r.GetDescription(),`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`		`-func namespaceToProto(ns domain.Namespace) *stencilv1beta1.Namespace {`
	`20`	`+func namespaceToProto(ns namespace.Namespace) *stencilv1beta1.Namespace {`
`21`	`21`	`return &stencilv1beta1.Namespace{`
`22`	`22`	`Id: ns.ID,`
`23`	`23`	`Format: stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[ns.Format]),`
`@@ -36,7 +36,7 @@ func (a API) CreateNamespace(ctx context.Context, in stencilv1beta1.CreateName`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`func (a API) UpdateNamespace(ctx context.Context, in stencilv1beta1.UpdateNamespaceRequest) (*stencilv1beta1.UpdateNamespaceResponse, error) {`
`39`		`- ns, err := a.namespace.Update(ctx, domain.Namespace{ID: in.GetId(), Format: in.GetFormat().String(), Compatibility: in.GetCompatibility().String(), Description: in.GetDescription()})`
	`39`	`+ ns, err := a.namespace.Update(ctx, namespace.Namespace{ID: in.GetId(), Format: in.GetFormat().String(), Compatibility: in.GetCompatibility().String(), Description: in.GetDescription()})`
`40`	`40`	`return &stencilv1beta1.UpdateNamespaceResponse{Namespace: namespaceToProto(ns)}, err`
`41`	`41`	`}`
`42`	`42`