Merge branch 'task/PRXS-1089-References' into 'feature/1004-AddPublicEntities'

Перенос References

See merge request perxis/perxis-go!32

pkg/references/field.go

+package references
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+
+	"git.perx.ru/perxis/perxis-go/pkg/data"
+	"git.perx.ru/perxis/perxis-go/pkg/errors"
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+	"git.perx.ru/perxis/perxis-go/pkg/schema/field"
+)
+
+const ReferenceTypeName = "reference"
+
+type ReferenceParameters struct {
+	AllowedCollections []string `json:"allowedCollections"`
+}
+
+func (p ReferenceParameters) Type() field.Type { return &ReferenceType{} }
+
+func (p ReferenceParameters) Clone(reset bool) field.Parameters {
+	if p.AllowedCollections != nil {
+		cols := make([]string, 0, len(p.AllowedCollections))
+		for _, c := range p.AllowedCollections {
+			cols = append(cols, c)
+		}
+		p.AllowedCollections = cols
+	}
+	return &p
+}
+
+type ReferenceType struct{}
+
+func NewReferenceType() *ReferenceType {
+	return &ReferenceType{}
+}
+
+func (t ReferenceType) Name() string { return ReferenceTypeName }
+
+func (t *ReferenceType) NewParameters() field.Parameters {
+	return &ReferenceParameters{}
+}
+
+func (t ReferenceType) Decode(_ context.Context, fld *field.Field, v interface{}) (interface{}, error) {
+	if v == nil {
+		return nil, nil
+	}
+
+	r, ok := v.(map[string]interface{})
+	if !ok {
+		return nil, errors.Errorf("ReferenceField decode error: incorrect type: \"%s\", expected \"map[string]interface{}\"", reflect.ValueOf(v).Kind())
+	}
+	id, ok1 := r["id"].(string)
+	if !ok1 || id == "" {
+		return nil, errors.Errorf("ReferenceField decode error: field \"id\" required")
+	}
+	collID, ok2 := r["collection_id"].(string)
+	if !ok2 || collID == "" {
+		return nil, errors.Errorf("ReferenceField decode error: field \"collection_id\" required")
+	}
+	disabled, _ := r["disabled"].(bool)
+
+	return &Reference{ID: id, CollectionID: collID, Disabled: disabled}, nil
+}
+
+func (t ReferenceType) Encode(_ context.Context, fld *field.Field, v interface{}) (interface{}, error) {
+	if v == nil {
+		return nil, nil
+	}
+
+	val, ok := v.(*Reference)
+
+	if !ok {
+		return nil, errors.Errorf("ReferenceField encode error: incorrect type: \"%s\", expected \"*Reference\"", reflect.ValueOf(v).Kind())
+	}
+	if val == nil {
+		return nil, nil
+	}
+	ref := map[string]interface{}{
+		"id":            val.ID,
+		"collection_id": val.CollectionID,
+		"disabled":      val.Disabled,
+	}
+	return ref, nil
+}
+
+func (t *ReferenceType) PreSave(ctx context.Context, f *field.Field, v interface{}, itemCtx *items.Context) (interface{}, bool, error) {
+	params, ok := f.Params.(*ReferenceParameters)
+	if !ok {
+		return nil, false, errors.New("field parameters required")
+	}
+
+	if v == nil {
+		return nil, false, nil
+	}
+	ref, ok := v.(*Reference)
+	if !ok {
+		return nil, false, fmt.Errorf("ReferenceField presave error: incorrect type: \"%s\", expected \"*Reference\"", reflect.ValueOf(v).Kind())
+	}
+
+	// Проверка на наличие ссылок заданных типов
+	if len(params.AllowedCollections) > 0 {
+		ok := false
+		for _, allowed := range params.AllowedCollections {
+
+			if data.GlobMatch(ref.CollectionID, allowed) {
+				ok = true
+				break
+			}
+		}
+		if !ok {
+			return nil, false, errors.Errorf("usage of collection \"%s\" not allowed", ref.CollectionID)
+		}
+	}
+
+	return ref, false, nil
+}
+
+// Field - создает новое поле Field типа ReferenceType
+// ReferenceType должен быть предварительно создан через `NewReferenceType` и зарегистрирован `field.Register`
+func Field(allowedColls []string, o ...interface{}) *field.Field {
+	_, ok := field.GetType(ReferenceTypeName)
+	if !ok {
+		panic("field reference type not registered")
+	}
+
+	return field.NewField(&ReferenceParameters{AllowedCollections: allowedColls}, o...)
+}
+
+func (t *ReferenceType) IsEmpty(v interface{}) bool {
+	if v == nil {
+		return true
+	}
+
+	ref, ok := v.(*Reference)
+
+	return !ok || ref.ID == "" && ref.CollectionID == ""
+}
+
+func init() {
+	field.Register(NewReferenceType())
+}

pkg/references/field_test.go

+package references
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+	"git.perx.ru/perxis/perxis-go/pkg/items/mocks"
+	"git.perx.ru/perxis/perxis-go/pkg/schema"
+	"git.perx.ru/perxis/perxis-go/pkg/schema/field"
+	"git.perx.ru/perxis/perxis-go/pkg/schema/validate"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestReferenceField_Decode(t *testing.T) {
+
+	tests := []struct {
+		name    string
+		field   *field.Field
+		data    interface{}
+		want    interface{}
+		wantErr bool
+	}{
+		{
+			"Correct",
+			Field(nil),
+			map[string]interface{}{"collection_id": "media", "id": "11111111"},
+			&Reference{ID: "11111111", CollectionID: "media"},
+			false,
+		},
+		{
+			"Invalid CollectionID",
+			Field(nil),
+			map[string]interface{}{"collection_id": "media", "id": 11111111},
+			"decode error: ReferenceField decode error: field \"id\" required",
+			true,
+		},
+		{
+			"Extra Field",
+			Field(nil),
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "extra": true},
+			&Reference{ID: "11111111", CollectionID: "media"},
+			false,
+		},
+		{
+			"Enabled",
+			Field(nil),
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "disabled": true},
+			&Reference{ID: "11111111", CollectionID: "media", Disabled: true},
+			false,
+		},
+		{
+			"Disabled",
+			Field(nil),
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "disabled": false},
+			&Reference{ID: "11111111", CollectionID: "media", Disabled: false},
+			false,
+		},
+		{
+			"Disabled wrong type",
+			Field(nil),
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "disabled": 3},
+			&Reference{ID: "11111111", CollectionID: "media", Disabled: false},
+			false,
+		},
+		{
+			"Missing Field",
+			Field(nil),
+			map[string]interface{}{"id": "11111111"},
+			"decode error: ReferenceField decode error: field \"collection_id\" required",
+			true,
+		},
+		{
+			"Invalid type",
+			Field(nil),
+			"string",
+			"decode error: ReferenceField decode error: incorrect type: \"string\", expected \"map[string]interface{}\"",
+			true,
+		},
+		{
+			"Invalid  element type",
+			Field(nil),
+			[]interface{}{"string"},
+			"decode error: ReferenceField decode error: incorrect type: \"slice\", expected \"map[string]interface{}\"",
+			true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := schema.Decode(nil, tt.field, tt.data)
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.EqualError(t, err, tt.want.(string), fmt.Sprintf("Decode() error = %v, want %v", err, tt.want.(string)))
+			}
+			if !tt.wantErr {
+				require.NoError(t, err)
+				assert.Equal(t, got, tt.want, fmt.Sprintf("Decode() got = %v, want %v", got, tt.want))
+			}
+		})
+	}
+}
+
+func TestReferenceField_Encode(t *testing.T) {
+
+	tests := []struct {
+		name    string
+		field   *field.Field
+		data    interface{}
+		want    interface{}
+		wantErr bool
+	}{
+		{
+			"Correct",
+			Field(nil),
+			&Reference{ID: "11111111", CollectionID: "media"},
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "disabled": false},
+			false,
+		},
+		{
+			"Enabled",
+			Field(nil),
+			&Reference{ID: "11111111", CollectionID: "media", Disabled: true},
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "disabled": true},
+			false,
+		},
+		{
+			"Disabled",
+			Field(nil),
+			&Reference{ID: "11111111", CollectionID: "media", Disabled: false},
+			map[string]interface{}{"collection_id": "media", "id": "11111111", "disabled": false},
+			false,
+		},
+		{
+			"From Map",
+			Field(nil),
+			map[string]interface{}{"id": "11111111", "collection_id": "media"},
+			"encode error: ReferenceField encode error: incorrect type: \"map\", expected \"*Reference\"",
+			true,
+		},
+		{
+			"Invalid type",
+			Field(nil),
+			"string",
+			"encode error: ReferenceField encode error: incorrect type: \"string\", expected \"*Reference\"",
+			true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := schema.Encode(nil, tt.field, tt.data)
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.EqualError(t, err, tt.want.(string), fmt.Sprintf("Encode() error = %v, want %v", err, tt.want.(string)))
+			}
+			if !tt.wantErr {
+				require.NoError(t, err)
+				assert.Equal(t, got, tt.want, fmt.Sprintf("Encode() got = %v, want %v", got, tt.want))
+			}
+		})
+	}
+}
+
+func TestReferenceField_PreSave(t *testing.T) {
+	ctx := context.Background()
+	rt := NewReferenceType()
+
+	t.Run("Nil Value", func(t *testing.T) {
+		svc := &mocks.Items{}
+		itemCtx := &items.Context{Items: svc, SpaceID: "sp", EnvID: "env"}
+		f := Field(nil)
+		_, _, err := rt.PreSave(ctx, f, nil, itemCtx)
+		require.NoError(t, err)
+		svc.AssertExpectations(t)
+	})
+	t.Run("Nil Context", func(t *testing.T) {
+		svc := &mocks.Items{}
+		f := Field(nil)
+		ref := &Reference{
+			ID: "111", CollectionID: "media",
+		}
+		_, _, err := rt.PreSave(ctx, f, ref, nil)
+		require.NoError(t, err)
+		svc.AssertExpectations(t)
+	})
+	t.Run("Referenced Items Exist", func(t *testing.T) {
+		t.Run("Correct", func(t *testing.T) {
+			svc := &mocks.Items{}
+			itemCtx := &items.Context{Items: svc, SpaceID: "sp", EnvID: "env"}
+
+			f := Field(nil)
+			ref := &Reference{
+				ID: "111", CollectionID: "media",
+			}
+			_, _, err := rt.PreSave(ctx, f, ref, itemCtx)
+			require.NoError(t, err)
+			svc.AssertExpectations(t)
+		})
+		t.Run("Item Not Found", func(t *testing.T) {
+			svc := &mocks.Items{}
+
+			itemCtx := &items.Context{Items: svc, SpaceID: "sp", EnvID: "env"}
+
+			f := Field(nil)
+			ref := &Reference{
+				ID: "111", CollectionID: "media",
+			}
+			_, _, err := rt.PreSave(ctx, f, ref, itemCtx)
+			require.NoError(t, err)
+			svc.AssertExpectations(t)
+		})
+	})
+	t.Run("Allowed Types", func(t *testing.T) {
+		t.Run("Correct", func(t *testing.T) {
+			svc := &mocks.Items{}
+
+			itemCtx := &items.Context{Items: svc, SpaceID: "sp", EnvID: "env"}
+
+			f := Field([]string{"media"})
+
+			ref := &Reference{
+				ID: "111", CollectionID: "media",
+			}
+
+			_, _, err := rt.PreSave(ctx, f, ref, itemCtx)
+			require.NoError(t, err)
+			svc.AssertExpectations(t)
+		})
+		t.Run("Not Allowed", func(t *testing.T) {
+			svc := &mocks.Items{}
+			f := Field([]string{"cars", "motorbikes"})
+			itemCtx := &items.Context{Items: svc, SpaceID: "sp", EnvID: "env"}
+			ref := &Reference{
+				ID: "111", CollectionID: "media",
+			}
+			_, _, err := rt.PreSave(ctx, f, ref, itemCtx)
+			require.Error(t, err)
+			assert.Equal(t, "usage of collection \"media\" not allowed", err.Error())
+			svc.AssertExpectations(t)
+		})
+	})
+}
+
+func TestReferenceField_Validate(t *testing.T) {
+	rt := NewReferenceType()
+	field.Register(rt)
+
+	t.Run("Max Elements", func(t *testing.T) {
+		t.Run("Correct", func(t *testing.T) {
+			f := Field(nil, validate.MaxItems(1))
+			refs := []*Reference{
+				{ID: "111", CollectionID: "media"},
+			}
+			err := validate.Validate(nil, f, refs)
+			require.NoError(t, err)
+		})
+		t.Run("Limit exceeded", func(t *testing.T) {
+			f := Field(nil, validate.MaxItems(1))
+			refs := []*Reference{
+				{ID: "111", CollectionID: "media"},
+				{ID: "222", CollectionID: "media"},
+			}
+			err := validate.Validate(nil, f, refs)
+			require.Error(t, err)
+			require.Contains(t, err.Error(), "validation error: maximum elements number is 1")
+		})
+	})
+	t.Run("Required", func(t *testing.T) {
+		t.Run("Correct", func(t *testing.T) {
+			f := Field(nil, validate.Required())
+			ref := &Reference{ID: "111", CollectionID: "media"}
+			err := validate.Validate(nil, f, ref)
+			require.NoError(t, err)
+		})
+		t.Run("Empty", func(t *testing.T) {
+			f := Field(nil, validate.Required())
+			ref := &Reference{}
+			err := validate.Validate(nil, f, ref)
+			require.Error(t, err)
+			require.Contains(t, err.Error(), "validation error: value is required")
+		})
+	})
+}
+
+func TestReference_JSON(t *testing.T) {
+	fld := Field([]string{"col1"}).AddOptions(validate.MaxItems(2))
+
+	b, err := json.MarshalIndent(fld, "", "  ")
+	require.NoError(t, err)
+
+	res := field.NewField(nil)
+	err = json.Unmarshal(b, res)
+	require.NoError(t, err)
+
+	assert.Equal(t, fld, res)
+}

pkg/references/mocks/References.go

+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	items "git.perx.ru/perxis/perxis-go/pkg/items"
+	references "git.perx.ru/perxis/perxis-go/pkg/references"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// References is an autogenerated mock type for the References type
+type References struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: ctx, spaceId, envId, _a3
+func (_m *References) Get(ctx context.Context, spaceId string, envId string, _a3 []*references.Reference) ([]*items.Item, []*references.Reference, error) {
+	ret := _m.Called(ctx, spaceId, envId, _a3)
+
+	var r0 []*items.Item
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, []*references.Reference) []*items.Item); ok {
+		r0 = rf(ctx, spaceId, envId, _a3)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*items.Item)
+		}
+	}
+
+	var r1 []*references.Reference
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, []*references.Reference) []*references.Reference); ok {
+		r1 = rf(ctx, spaceId, envId, _a3)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).([]*references.Reference)
+		}
+	}
+
+	var r2 error
+	if rf, ok := ret.Get(2).(func(context.Context, string, string, []*references.Reference) error); ok {
+		r2 = rf(ctx, spaceId, envId, _a3)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+type mockConstructorTestingTNewReferences interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewReferences creates a new instance of References. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewReferences(t mockConstructorTestingTNewReferences) *References {
+	mock := &References{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

pkg/references/reference.go

+package references
+
+import (
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+	pb "git.perx.ru/perxis/perxis-go/proto/references"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type Reference struct {
+	ID           string `json:"id" bson:"id" mapstructure:"id"`
+	CollectionID string `json:"collection_id" bson:"collection_id" mapstructure:"collection_id"`
+	Disabled     bool   `json:"disabled,omitempty" bson:"disabled,omitempty" mapstructure:"disabled"`
+}
+
+func (r *Reference) MarshalBSON() ([]byte, error) {
+	d := bson.D{
+		{"id", r.ID},
+		{"collection_id", r.CollectionID},
+	}
+
+	if r.Disabled {
+		d = append(d, bson.E{Key: "disabled", Value: true})
+	}
+
+	return bson.Marshal(d)
+}
+
+func ReferenceFromPB(refPB *pb.Reference) *Reference {
+	return &Reference{
+		ID:           refPB.Id,
+		CollectionID: refPB.CollectionId,
+		Disabled:     refPB.Disabled,
+	}
+}
+
+func ReferenceFromItem(item *items.Item) *Reference {
+	if item == nil {
+		return nil
+	}
+
+	return &Reference{
+		ID:           item.ID,
+		CollectionID: item.CollectionID,
+	}
+}
+
+func ReferenceToPB(ref *Reference) *pb.Reference {
+	return &pb.Reference{
+		Id:           ref.ID,
+		CollectionId: ref.CollectionID,
+		Disabled:     ref.Disabled,
+	}
+}
+
+func ReferenceListFromPB(listPB []*pb.Reference) []*Reference {
+	list := make([]*Reference, 0, len(listPB))
+	for _, refPB := range listPB {
+		list = append(list, ReferenceFromPB(refPB))
+	}
+	return list
+}
+
+func (r *Reference) String() string {
+	if r == nil {
+		return ""
+	}
+	return r.CollectionID + "." + r.ID
+}
+
+func (r *Reference) Equal(r1 *Reference) bool {
+	return r == r1 || r != nil && r1 != nil && r.CollectionID == r1.CollectionID && r.ID == r1.ID && r.Disabled == r1.Disabled
+}
+
+func EqualArrays(sr1, sr2 []*Reference) bool {
+	if len(sr1) != len(sr2) {
+		return false
+	}
+	for i, r := range sr1 {
+		if !r.Equal(sr2[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (r *Reference) IsValid() bool {
+	return r != nil && r.ID != "" && r.CollectionID != "" && !r.Disabled
+}
+
+func (r *Reference) Fetch(i interface{}) interface{} {
+	p, _ := i.(string)
+	switch p {
+	case "id":
+		return r.ID
+	case "collection_id":
+		return r.CollectionID
+	case "disabled":
+		return r.Disabled
+	default:
+		panic("unknown parameter")
+	}
+	return nil
+}

pkg/references/service.go

+package references
+
+import (
+	"context"
+
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+)
+
+// @microgen grpc
+// @protobuf git.perx.ru/perxis/perxis-go/proto/references
+// @grpc-addr content.references.References
+type References interface {
+	Get(ctx context.Context, spaceId, envId string, references []*Reference) (items []*items.Item, notfound []*Reference, err error)
+}

pkg/references/transport/client.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+	"context"
+	"errors"
+
+	items "git.perx.ru/perxis/perxis-go/pkg/items"
+	references "git.perx.ru/perxis/perxis-go/pkg/references"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+func (set EndpointsSet) Get(arg0 context.Context, arg1 string, arg2 string, arg3 []*references.Reference) (res0 []*items.Item, res1 []*references.Reference, res2 error) {
+	request := GetRequest{
+		EnvId:      arg2,
+		References: arg3,
+		SpaceId:    arg1,
+	}
+	response, res2 := set.GetEndpoint(arg0, &request)
+	if res2 != nil {
+		if e, ok := status.FromError(res2); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res2 = errors.New(e.Message())
+		}
+		return
+	}
+	return response.(*GetResponse).Items, response.(*GetResponse).Notfound, res2
+}

pkg/references/transport/endpoints.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import endpoint "github.com/go-kit/kit/endpoint"
+
+// EndpointsSet implements References API and used for transport purposes.
+type EndpointsSet struct {
+	GetEndpoint endpoint.Endpoint
+}

pkg/references/transport/exchanges.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+	items "git.perx.ru/perxis/perxis-go/pkg/items"
+	references "git.perx.ru/perxis/perxis-go/pkg/references"
+)
+
+type (
+	GetRequest struct {
+		SpaceId    string                  `json:"space_id"`
+		EnvId      string                  `json:"env_id"`
+		References []*references.Reference `json:"references"`
+	}
+	GetResponse struct {
+		Items    []*items.Item           `json:"items"`
+		Notfound []*references.Reference `json:"notfound"`
+	}
+)

pkg/references/transport/grpc/client.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transportgrpc
+
+import (
+	transport "git.perx.ru/perxis/perxis-go/pkg/references/transport"
+	pb "git.perx.ru/perxis/perxis-go/proto/references"
+	grpckit "github.com/go-kit/kit/transport/grpc"
+	grpc "google.golang.org/grpc"
+)
+
+func NewGRPCClient(conn *grpc.ClientConn, addr string, opts ...grpckit.ClientOption) transport.EndpointsSet {
+	if addr == "" {
+		addr = "content.references.References"
+	}
+	return transport.EndpointsSet{GetEndpoint: grpckit.NewClient(
+		conn, addr, "Get",
+		_Encode_Get_Request,
+		_Decode_Get_Response,
+		pb.GetResponse{},
+		opts...,
+	).Endpoint()}
+}

pkg/references/transport/grpc/protobuf_endpoint_converters.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// Please, do not change functions names!
+package transportgrpc
+
+import (
+	"context"
+	"errors"
+
+	transport "git.perx.ru/perxis/perxis-go/pkg/references/transport"
+	pb "git.perx.ru/perxis/perxis-go/proto/references"
+)
+
+func _Encode_Get_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil GetRequest")
+	}
+	req := request.(*transport.GetRequest)
+	reqReferences, err := ListPtrReferenceToProto(req.References)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.GetRequest{
+		EnvId:      req.EnvId,
+		References: reqReferences,
+		SpaceId:    req.SpaceId,
+	}, nil
+}
+
+func _Encode_Get_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	if response == nil {
+		return nil, errors.New("nil GetResponse")
+	}
+	resp := response.(*transport.GetResponse)
+	respItems, err := ListPtrItemsItemToProto(resp.Items)
+	if err != nil {
+		return nil, err
+	}
+	respNotfound, err := ListPtrReferenceToProto(resp.Notfound)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.GetResponse{
+		Items:    respItems,
+		Notfound: respNotfound,
+	}, nil
+}
+
+func _Decode_Get_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil GetRequest")
+	}
+	req := request.(*pb.GetRequest)
+	reqReferences, err := ProtoToListPtrReference(req.References)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.GetRequest{
+		EnvId:      string(req.EnvId),
+		References: reqReferences,
+		SpaceId:    string(req.SpaceId),
+	}, nil
+}
+
+func _Decode_Get_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	if response == nil {
+		return nil, errors.New("nil GetResponse")
+	}
+	resp := response.(*pb.GetResponse)
+	respItems, err := ProtoToListPtrItemsItem(resp.Items)
+	if err != nil {
+		return nil, err
+	}
+	respNotfound, err := ProtoToListPtrReference(resp.Notfound)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.GetResponse{
+		Items:    respItems,
+		Notfound: respNotfound,
+	}, nil
+}

pkg/references/transport/grpc/protobuf_type_converters.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// It is better for you if you do not change functions names!
+// This file will never be overwritten.
+package transportgrpc
+
+import (
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+	itemstransportgrpc "git.perx.ru/perxis/perxis-go/pkg/items/transport/grpc"
+	service "git.perx.ru/perxis/perxis-go/pkg/references"
+	itemspb "git.perx.ru/perxis/perxis-go/proto/items"
+	pb "git.perx.ru/perxis/perxis-go/proto/references"
+)
+
+func PtrItemToReference(ref *service.Reference) (*pb.Reference, error) {
+	if ref == nil {
+		return nil, nil
+	}
+
+	protoRef := &pb.Reference{
+		Id:           ref.ID,
+		CollectionId: ref.CollectionID,
+	}
+
+	return protoRef, nil
+}
+
+func ListPtrReferenceToProto(refs []*service.Reference) ([]*pb.Reference, error) {
+	protoRefs := make([]*pb.Reference, 0, len(refs))
+	for _, ref := range refs {
+		pr, err := PtrItemToReference(ref)
+		if err != nil {
+			return nil, err
+		}
+		protoRefs = append(protoRefs, pr)
+	}
+	return protoRefs, nil
+}
+
+func ProtoToPtrReference(protoRef *pb.Reference) (*service.Reference, error) {
+	if protoRef == nil {
+		return nil, nil
+	}
+
+	ref := &service.Reference{
+		ID:           protoRef.Id,
+		CollectionID: protoRef.CollectionId,
+	}
+
+	return ref, nil
+}
+
+func ProtoToListPtrReference(protoRefs []*pb.Reference) ([]*service.Reference, error) {
+	refs := make([]*service.Reference, 0, len(protoRefs))
+	for _, ref := range protoRefs {
+		r, err := ProtoToPtrReference(ref)
+		if err != nil {
+			return nil, err
+		}
+		refs = append(refs, r)
+	}
+	return refs, nil
+}
+
+func ListPtrItemsItemToProto(items []*items.Item) ([]*itemspb.Item, error) {
+	return itemstransportgrpc.ListPtrItemToProto(items)
+}
+
+func ProtoToListPtrItemsItem(protoItems []*itemspb.Item) ([]*items.Item, error) {
+	return itemstransportgrpc.ProtoToListPtrItem(protoItems)
+}

pkg/references/transport/grpc/server.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// DO NOT EDIT.
+package transportgrpc
+
+import (
+	transport "git.perx.ru/perxis/perxis-go/pkg/references/transport"
+	pb "git.perx.ru/perxis/perxis-go/proto/references"
+	grpc "github.com/go-kit/kit/transport/grpc"
+	context "golang.org/x/net/context"
+)
+
+type referencesServer struct {
+	get grpc.Handler
+
+	pb.UnsafeReferencesServer
+}
+
+func NewGRPCServer(endpoints *transport.EndpointsSet, opts ...grpc.ServerOption) pb.ReferencesServer {
+	return &referencesServer{get: grpc.NewServer(
+		endpoints.GetEndpoint,
+		_Decode_Get_Request,
+		_Encode_Get_Response,
+		opts...,
+	)}
+}
+
+func (S *referencesServer) Get(ctx context.Context, req *pb.GetRequest) (*pb.GetResponse, error) {
+	_, resp, err := S.get.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*pb.GetResponse), nil
+}

pkg/references/transport/server.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+	"context"
+
+	references "git.perx.ru/perxis/perxis-go/pkg/references"
+	endpoint "github.com/go-kit/kit/endpoint"
+)
+
+func Endpoints(svc references.References) EndpointsSet {
+	return EndpointsSet{GetEndpoint: GetEndpoint(svc)}
+}
+
+func GetEndpoint(svc references.References) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*GetRequest)
+		res0, res1, res2 := svc.Get(arg0, req.SpaceId, req.EnvId, req.References)
+		return &GetResponse{
+			Items:    res0,
+			Notfound: res1,
+		}, res2
+	}
+}