Merge branch 'feature/PRXS-1079-Collections' into 'feature/1004-AddPublicEntities'

Перенесён в репозиторий services/collections

See merge request perxis/perxis-go!19

pkg/collections/collection.go

+package collections
+
+import (
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/permission"
+	"git.perx.ru/perxis/perxis-go/pkg/schema"
+)
+
+// Config
+type Config struct {
+	SourceSpaceID      string
+	SourceEnvID        string
+	SourceCollectionID string
+	SourceSchema       *schema.Schema
+}
+
+// Access - описывает текущие ограничения на доступ к элементам коллекции для текущего
+// пользователя
+type Access struct {
+	Actions         []permission.Action // Список разрешенных действия с элементами коллекции
+	HiddenFields    []string            // Поля не отображаемые в интерфейсе и не возвращаемые API
+	ReadonlyFields  []string            // Поля недоступные для редактирования и не обновляемые через API
+	WriteonlyFields []string            // Поля отображаемые в интерфейсе, но не возвращаемые в API
+}
+
+func (a Access) Clone() *Access {
+
+	clone := &Access{
+		Actions:         make([]permission.Action, len(a.Actions)),
+		HiddenFields:    make([]string, len(a.HiddenFields)),
+		ReadonlyFields:  make([]string, len(a.ReadonlyFields)),
+		WriteonlyFields: make([]string, len(a.WriteonlyFields)),
+	}
+
+	copy(clone.Actions, a.Actions)
+	copy(clone.HiddenFields, a.HiddenFields)
+	copy(clone.ReadonlyFields, a.ReadonlyFields)
+	copy(clone.WriteonlyFields, a.WriteonlyFields)
+
+	return clone
+}
+
+func (a Access) Can(action permission.Action) bool {
+	for _, act := range a.Actions {
+		if act == action {
+			return true
+		}
+	}
+	return false
+}
+
+type Collection struct {
+	ID      string         `json:"id" bson:"id"`
+	SpaceID string         `json:"spaceId" bson:"-"`
+	EnvID   string         `json:"envId" bson:"-"`
+	Name    string         `json:"name" bson:"name"`
+	Single  *bool          `json:"single" bson:"single,omitempty"` // В коллекции может быть только один документ
+	System  *bool          `json:"system" bson:"system,omitempty"` // Системная коллекция
+	NoData  *bool          `json:"no_data" bson:"no_data"`         // Коллекция не содержит элементы. Схема используется для включения в другие схемы
+	Hidden  bool           `json:"hidden" bson:"hidden"`           // Коллекция скрыта в административном интерфейсе
+	Schema  *schema.Schema `json:"schema" bson:"schema"`
+	Access  *Access        `json:"access" bson:"-"` // Ограничения на доступ к элементам коллекции. Отсутствие объекта означает неограниченный доступ
+
+	// StateInfo отображает состояние коллекции:
+	// - State: идентификатор состояния коллекции (new/preparing/ready/error/changed)
+	// - Info: дополнительная информация о состоянии коллекции (например, если при
+	//   применении схемы к коллекции произошла ошибка)
+	// - StartedAt: время, в которое коллекция перешла в состояние `Preparing`
+	StateInfo *StateInfo `json:"state_info" bson:"state_info,omitempty"` // todo: показывать в интерфейсе как readonly
+
+	// View - Если значение поля непустое, то коллекция является View ("отображением"
+	// части данных другой коллекции согласно View.Filter)
+	View *View `json:"view,omitempty" bson:"view,omitempty"`
+
+	// Tags - список тегов коллекции. Добавляются при отправке событий events
+	Tags []string `json:"tags,omitempty" bson:"tags,omitempty"`
+
+	Config *Config `json:"-" bson:"-"`
+}
+
+type View struct {
+	SpaceID      string `json:"space_id" bson:"space_id"`             // SpaceID оригинальной коллекции
+	EnvID        string `json:"environment_id" bson:"environment_id"` // EnvID оригинальной коллекции
+	CollectionID string `json:"collection_id" bson:"collection_id"`   // CollectionID оригинальной коллекции
+	Filter       string `json:"filter" bson:"filter,omitempty"`       // Правила фильтрации записей оригинальной коллекции
+}
+
+type StateInfo struct {
+	State     State     `json:"state" bson:"state"`
+	Info      string    `json:"info" bson:"info"`
+	StartedAt time.Time `json:"started_at,omitempty" bson:"started_at,omitempty"`
+}
+
+type State int
+
+func (s State) String() string {
+	var state string
+
+	switch s {
+	case StateNew:
+		state = "New"
+	case StatePreparing:
+		state = "Preparing"
+	case StateReady:
+		state = "Ready"
+	case StateError:
+		state = "Error"
+	case StateChanged:
+		state = "Changed"
+	default:
+		state = "Unknown"
+	}
+
+	return state
+}
+
+const (
+	StateNew State = iota
+	StatePreparing
+	StateReady
+	StateError
+	StateChanged
+)
+
+func (c Collection) Clone() *Collection {
+
+	clone := &Collection{
+		ID:      c.ID,
+		SpaceID: c.SpaceID,
+		EnvID:   c.EnvID,
+		Name:    c.Name,
+		NoData:  c.NoData,
+		Hidden:  c.Hidden,
+	}
+
+	if c.Single != nil {
+		single := *c.Single
+		clone.Single = &single
+	}
+	if c.System != nil {
+		system := *c.System
+		clone.System = &system
+	}
+	if c.Schema != nil {
+		clone.Schema = c.Schema.Clone(false)
+	}
+	if c.Access != nil {
+		clone.Access = c.Access.Clone()
+	}
+	if c.StateInfo != nil {
+		info := *c.StateInfo
+		clone.StateInfo = &info
+	}
+	if c.View != nil {
+		view := *c.View
+		clone.View = &view
+	}
+	if c.Config != nil {
+		cfg := *c.Config
+		clone.Config = &cfg
+	}
+	if c.Tags != nil {
+		clone.Tags = append([]string{}, c.Tags...)
+	}
+
+	return clone
+}
+
+func (c Collection) IsSingle() bool {
+	return c.Single != nil && *c.Single
+}
+
+func (c Collection) IsNoData() bool {
+	return c.NoData != nil && *c.NoData
+}
+
+func (c Collection) IsView() bool {
+	return c.View != nil
+}

pkg/collections/mocks/Collections.go

+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	collections "git.perx.ru/perxis/perxis-go/pkg/collections"
+	schema "git.perx.ru/perxis/perxis-go/pkg/schema"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// Collections is an autogenerated mock type for the Collections type
+type Collections struct {
+	mock.Mock
+}
+
+// Create provides a mock function with given fields: ctx, collection
+func (_m *Collections) Create(ctx context.Context, collection *collections.Collection) (*collections.Collection, error) {
+	ret := _m.Called(ctx, collection)
+
+	var r0 *collections.Collection
+	if rf, ok := ret.Get(0).(func(context.Context, *collections.Collection) *collections.Collection); ok {
+		r0 = rf(ctx, collection)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*collections.Collection)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *collections.Collection) error); ok {
+		r1 = rf(ctx, collection)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: ctx, spaceId, envId, collectionId
+func (_m *Collections) Delete(ctx context.Context, spaceId string, envId string, collectionId string) error {
+	ret := _m.Called(ctx, spaceId, envId, collectionId)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
+		r0 = rf(ctx, spaceId, envId, collectionId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: ctx, spaceId, envId, collectionId, options
+func (_m *Collections) Get(ctx context.Context, spaceId string, envId string, collectionId string, options ...*collections.GetOptions) (*collections.Collection, error) {
+	_va := make([]interface{}, len(options))
+	for _i := range options {
+		_va[_i] = options[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, spaceId, envId, collectionId)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	var r0 *collections.Collection
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...*collections.GetOptions) *collections.Collection); ok {
+		r0 = rf(ctx, spaceId, envId, collectionId, options...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*collections.Collection)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, ...*collections.GetOptions) error); ok {
+		r1 = rf(ctx, spaceId, envId, collectionId, options...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// List provides a mock function with given fields: ctx, spaceId, envId, filter
+func (_m *Collections) List(ctx context.Context, spaceId string, envId string, filter *collections.Filter) ([]*collections.Collection, error) {
+	ret := _m.Called(ctx, spaceId, envId, filter)
+
+	var r0 []*collections.Collection
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, *collections.Filter) []*collections.Collection); ok {
+		r0 = rf(ctx, spaceId, envId, filter)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*collections.Collection)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, *collections.Filter) error); ok {
+		r1 = rf(ctx, spaceId, envId, filter)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetSchema provides a mock function with given fields: ctx, spaceId, envId, collectionId, _a4
+func (_m *Collections) SetSchema(ctx context.Context, spaceId string, envId string, collectionId string, _a4 *schema.Schema) error {
+	ret := _m.Called(ctx, spaceId, envId, collectionId, _a4)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *schema.Schema) error); ok {
+		r0 = rf(ctx, spaceId, envId, collectionId, _a4)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SetState provides a mock function with given fields: ctx, spaceId, envId, collectionId, state
+func (_m *Collections) SetState(ctx context.Context, spaceId string, envId string, collectionId string, state *collections.StateInfo) error {
+	ret := _m.Called(ctx, spaceId, envId, collectionId, state)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *collections.StateInfo) error); ok {
+		r0 = rf(ctx, spaceId, envId, collectionId, state)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Update provides a mock function with given fields: ctx, coll
+func (_m *Collections) Update(ctx context.Context, coll *collections.Collection) error {
+	ret := _m.Called(ctx, coll)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, *collections.Collection) error); ok {
+		r0 = rf(ctx, coll)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+type mockConstructorTestingTNewCollections interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewCollections creates a new instance of Collections. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewCollections(t mockConstructorTestingTNewCollections) *Collections {
+	mock := &Collections{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

pkg/collections/options.go

+package collections
+
+type GetOptions struct {
+	DisableSchemaIncludes bool
+}
+
+func MergeGetOptions(opts ...*GetOptions) *GetOptions {
+	o := &GetOptions{}
+	for _, opt := range opts {
+		if opt.DisableSchemaIncludes {
+			o.DisableSchemaIncludes = true
+		}
+	}
+	return o
+}

pkg/collections/service.go

+package collections
+
+import (
+	"context"
+
+	"git.perx.ru/perxis/perxis-go/pkg/schema"
+)
+
+// @microgen grpc
+// @protobuf git.perx.ru/perxis/perxis-go/proto/collections
+// @grpc-addr content.collections.Collections
+type Collections interface {
+	Create(ctx context.Context, collection *Collection) (created *Collection, err error)
+	Get(ctx context.Context, spaceId, envId, collectionId string, options ...*GetOptions) (collection *Collection, err error)
+	List(ctx context.Context, spaceId, envId string, filter *Filter) (collections []*Collection, err error)
+	Update(ctx context.Context, coll *Collection) (err error)
+	SetSchema(ctx context.Context, spaceId, envId, collectionId string, schema *schema.Schema) (err error)
+
+	// @microgen -
+	SetState(ctx context.Context, spaceId, envId, collectionId string, state *StateInfo) (err error)
+	Delete(ctx context.Context, spaceId, envId, collectionId string) (err error)
+}
+
+type Filter struct {
+	IncludeNoData bool     `json:"include_no_data,omitempty"`
+	IncludeHidden bool     `json:"include_hidden,omitempty"`
+	ExcludeSystem bool     `json:"exclude_system,omitempty"`
+	Name          []string `json:"name,omitempty"`
+	ID            []string `json:"id,omitempty"`
+}

pkg/collections/transport/client.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+	"context"
+	"errors"
+
+	collections "git.perx.ru/perxis/perxis-go/pkg/collections"
+	schema "git.perx.ru/perxis/perxis-go/pkg/schema"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+func (set EndpointsSet) Create(arg0 context.Context, arg1 *collections.Collection) (res0 *collections.Collection, res1 error) {
+	request := CreateRequest{Collection: arg1}
+	response, res1 := set.CreateEndpoint(arg0, &request)
+	if res1 != nil {
+		if e, ok := status.FromError(res1); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res1 = errors.New(e.Message())
+		}
+		return
+	}
+	return response.(*CreateResponse).Created, res1
+}
+
+func (set EndpointsSet) Get(arg0 context.Context, arg1 string, arg2 string, arg3 string, arg4 ...*collections.GetOptions) (res0 *collections.Collection, res1 error) {
+	request := GetRequest{
+		CollectionId: arg3,
+		EnvId:        arg2,
+		Options:      arg4,
+		SpaceId:      arg1,
+	}
+	response, res1 := set.GetEndpoint(arg0, &request)
+	if res1 != nil {
+		if e, ok := status.FromError(res1); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res1 = errors.New(e.Message())
+		}
+		return
+	}
+	return response.(*GetResponse).Collection, res1
+}
+
+func (set EndpointsSet) List(arg0 context.Context, arg1 string, arg2 string, arg3 *collections.Filter) (res0 []*collections.Collection, res1 error) {
+	request := ListRequest{
+		EnvId:   arg2,
+		Filter:  arg3,
+		SpaceId: arg1,
+	}
+	response, res1 := set.ListEndpoint(arg0, &request)
+	if res1 != nil {
+		if e, ok := status.FromError(res1); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res1 = errors.New(e.Message())
+		}
+		return
+	}
+	return response.(*ListResponse).Collections, res1
+}
+
+func (set EndpointsSet) Update(arg0 context.Context, arg1 *collections.Collection) (res0 error) {
+	request := UpdateRequest{Coll: arg1}
+	_, res0 = set.UpdateEndpoint(arg0, &request)
+	if res0 != nil {
+		if e, ok := status.FromError(res0); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res0 = errors.New(e.Message())
+		}
+		return
+	}
+	return res0
+}
+
+func (set EndpointsSet) SetSchema(arg0 context.Context, arg1 string, arg2 string, arg3 string, arg4 *schema.Schema) (res0 error) {
+	request := SetSchemaRequest{
+		CollectionId: arg3,
+		EnvId:        arg2,
+		Schema:       arg4,
+		SpaceId:      arg1,
+	}
+	_, res0 = set.SetSchemaEndpoint(arg0, &request)
+	if res0 != nil {
+		if e, ok := status.FromError(res0); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res0 = errors.New(e.Message())
+		}
+		return
+	}
+	return res0
+}
+
+func (set EndpointsSet) SetState(arg0 context.Context, arg1 string, arg2 string, arg3 string, arg4 *collections.StateInfo) (res0 error) {
+	return
+}
+
+func (set EndpointsSet) Delete(arg0 context.Context, arg1 string, arg2 string, arg3 string) (res0 error) {
+	request := DeleteRequest{
+		CollectionId: arg3,
+		EnvId:        arg2,
+		SpaceId:      arg1,
+	}
+	_, res0 = set.DeleteEndpoint(arg0, &request)
+	if res0 != nil {
+		if e, ok := status.FromError(res0); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+			res0 = errors.New(e.Message())
+		}
+		return
+	}
+	return res0
+}

pkg/collections/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 Collections API and used for transport purposes.
+type EndpointsSet struct {
+	CreateEndpoint    endpoint.Endpoint
+	GetEndpoint       endpoint.Endpoint
+	ListEndpoint      endpoint.Endpoint
+	UpdateEndpoint    endpoint.Endpoint
+	SetSchemaEndpoint endpoint.Endpoint
+	DeleteEndpoint    endpoint.Endpoint
+}

pkg/collections/transport/exchanges.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+	collections "git.perx.ru/perxis/perxis-go/pkg/collections"
+	schema "git.perx.ru/perxis/perxis-go/pkg/schema"
+)
+
+type (
+	CreateRequest struct {
+		Collection *collections.Collection `json:"collection"`
+	}
+	CreateResponse struct {
+		Created *collections.Collection `json:"created"`
+	}
+
+	GetRequest struct {
+		SpaceId      string                    `json:"space_id"`
+		EnvId        string                    `json:"env_id"`
+		CollectionId string                    `json:"collection_id"`
+		Options      []*collections.GetOptions `json:"options"` // This field was defined with ellipsis (...).
+	}
+	GetResponse struct {
+		Collection *collections.Collection `json:"collection"`
+	}
+
+	ListRequest struct {
+		SpaceId string              `json:"space_id"`
+		EnvId   string              `json:"env_id"`
+		Filter  *collections.Filter `json:"filter"`
+	}
+	ListResponse struct {
+		Collections []*collections.Collection `json:"collections"`
+	}
+
+	UpdateRequest struct {
+		Coll *collections.Collection `json:"coll"`
+	}
+	// Formal exchange type, please do not delete.
+	UpdateResponse struct{}
+
+	SetSchemaRequest struct {
+		SpaceId      string         `json:"space_id"`
+		EnvId        string         `json:"env_id"`
+		CollectionId string         `json:"collection_id"`
+		Schema       *schema.Schema `json:"schema"`
+	}
+	// Formal exchange type, please do not delete.
+	SetSchemaResponse struct{}
+
+	DeleteRequest struct {
+		SpaceId      string `json:"space_id"`
+		EnvId        string `json:"env_id"`
+		CollectionId string `json:"collection_id"`
+	}
+	// Formal exchange type, please do not delete.
+	DeleteResponse struct{}
+)

pkg/collections/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/collections/transport"
+	pb "git.perx.ru/perxis/perxis-go/proto/collections"
+	grpckit "github.com/go-kit/kit/transport/grpc"
+	empty "github.com/golang/protobuf/ptypes/empty"
+	grpc "google.golang.org/grpc"
+)
+
+func NewGRPCClient(conn *grpc.ClientConn, addr string, opts ...grpckit.ClientOption) transport.EndpointsSet {
+	if addr == "" {
+		addr = "content.collections.Collections"
+	}
+	return transport.EndpointsSet{
+		CreateEndpoint: grpckit.NewClient(
+			conn, addr, "Create",
+			_Encode_Create_Request,
+			_Decode_Create_Response,
+			pb.CreateResponse{},
+			opts...,
+		).Endpoint(),
+		DeleteEndpoint: grpckit.NewClient(
+			conn, addr, "Delete",
+			_Encode_Delete_Request,
+			_Decode_Delete_Response,
+			empty.Empty{},
+			opts...,
+		).Endpoint(),
+		GetEndpoint: grpckit.NewClient(
+			conn, addr, "Get",
+			_Encode_Get_Request,
+			_Decode_Get_Response,
+			pb.GetResponse{},
+			opts...,
+		).Endpoint(),
+		ListEndpoint: grpckit.NewClient(
+			conn, addr, "List",
+			_Encode_List_Request,
+			_Decode_List_Response,
+			pb.ListResponse{},
+			opts...,
+		).Endpoint(),
+		SetSchemaEndpoint: grpckit.NewClient(
+			conn, addr, "SetSchema",
+			_Encode_SetSchema_Request,
+			_Decode_SetSchema_Response,
+			empty.Empty{},
+			opts...,
+		).Endpoint(),
+		UpdateEndpoint: grpckit.NewClient(
+			conn, addr, "Update",
+			_Encode_Update_Request,
+			_Decode_Update_Response,
+			empty.Empty{},
+			opts...,
+		).Endpoint(),
+	}
+}

pkg/collections/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"
+
+	pb "git.perx.ru/perxis/perxis-go/proto/collections"
+	transport "git.perx.ru/perxis/perxis/services/collections/transport"
+	empty "github.com/golang/protobuf/ptypes/empty"
+)
+
+func _Encode_Create_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil CreateRequest")
+	}
+	req := request.(*transport.CreateRequest)
+	reqCollection, err := PtrCollectionToProto(req.Collection)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CreateRequest{Collection: reqCollection}, nil
+}
+
+func _Encode_Get_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil GetRequest")
+	}
+	req := request.(*transport.GetRequest)
+	return &pb.GetRequest{
+		CollectionId: req.CollectionId,
+		EnvId:        req.EnvId,
+		SpaceId:      req.SpaceId,
+		Options:      GetOptionsToProto(req.Options),
+	}, nil
+}
+
+func _Encode_List_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil ListRequest")
+	}
+	req := request.(*transport.ListRequest)
+	reqFilter, err := PtrFilterToProto(req.Filter)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.ListRequest{
+		EnvId:   req.EnvId,
+		Filter:  reqFilter,
+		SpaceId: req.SpaceId,
+	}, nil
+}
+
+func _Encode_Update_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil UpdateRequest")
+	}
+	req := request.(*transport.UpdateRequest)
+	reqColl, err := PtrCollectionToProto(req.Coll)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.UpdateRequest{Collection: reqColl}, nil
+}
+
+func _Encode_SetSchema_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil SetSchemaRequest")
+	}
+	req := request.(*transport.SetSchemaRequest)
+	reqSchema, err := PtrSchemaSchemaToProto(req.Schema)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.SetSchemaRequest{
+		CollectionId: req.CollectionId,
+		EnvId:        req.EnvId,
+		Schema:       reqSchema,
+		SpaceId:      req.SpaceId,
+	}, nil
+}
+
+func _Encode_Delete_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil DeleteRequest")
+	}
+	req := request.(*transport.DeleteRequest)
+	return &pb.DeleteRequest{
+		CollectionId: req.CollectionId,
+		EnvId:        req.EnvId,
+		SpaceId:      req.SpaceId,
+	}, nil
+}
+
+func _Encode_Create_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	if response == nil {
+		return nil, errors.New("nil CreateResponse")
+	}
+	resp := response.(*transport.CreateResponse)
+	respCreated, err := PtrCollectionToProto(resp.Created)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CreateResponse{Created: respCreated}, 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)
+	respCollection, err := PtrCollectionToProto(resp.Collection)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.GetResponse{Collection: respCollection}, nil
+}
+
+func _Encode_List_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	if response == nil {
+		return nil, errors.New("nil ListResponse")
+	}
+	resp := response.(*transport.ListResponse)
+	respCollections, err := ListPtrCollectionToProto(resp.Collections)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.ListResponse{Collections: respCollections}, nil
+}
+
+func _Encode_Update_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	return &empty.Empty{}, nil
+}
+
+func _Encode_SetSchema_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	return &empty.Empty{}, nil
+}
+
+func _Encode_Delete_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	return &empty.Empty{}, nil
+}
+
+func _Decode_Create_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil CreateRequest")
+	}
+	req := request.(*pb.CreateRequest)
+	reqCollection, err := ProtoToPtrCollection(req.Collection)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.CreateRequest{Collection: reqCollection}, 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)
+	return &transport.GetRequest{
+		CollectionId: string(req.CollectionId),
+		EnvId:        string(req.EnvId),
+		SpaceId:      string(req.SpaceId),
+		Options:      ProtoToGetOptions(req.Options),
+	}, nil
+}
+
+func _Decode_List_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil ListRequest")
+	}
+	req := request.(*pb.ListRequest)
+	reqFilter, err := ProtoToPtrFilter(req.Filter)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.ListRequest{
+		EnvId:   string(req.EnvId),
+		Filter:  reqFilter,
+		SpaceId: string(req.SpaceId),
+	}, nil
+}
+
+func _Decode_Update_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil UpdateRequest")
+	}
+	req := request.(*pb.UpdateRequest)
+	reqColl, err := ProtoToPtrCollection(req.Collection)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.UpdateRequest{Coll: reqColl}, nil
+}
+
+func _Decode_SetSchema_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil SetSchemaRequest")
+	}
+	req := request.(*pb.SetSchemaRequest)
+	reqSchema, err := ProtoToPtrSchemaSchema(req.Schema)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.SetSchemaRequest{
+		CollectionId: string(req.CollectionId),
+		EnvId:        string(req.EnvId),
+		Schema:       reqSchema,
+		SpaceId:      string(req.SpaceId),
+	}, nil
+}
+
+func _Decode_Delete_Request(ctx context.Context, request interface{}) (interface{}, error) {
+	if request == nil {
+		return nil, errors.New("nil DeleteRequest")
+	}
+	req := request.(*pb.DeleteRequest)
+	return &transport.DeleteRequest{
+		CollectionId: string(req.CollectionId),
+		EnvId:        string(req.EnvId),
+		SpaceId:      string(req.SpaceId),
+	}, nil
+}
+
+func _Decode_Create_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	if response == nil {
+		return nil, errors.New("nil CreateResponse")
+	}
+	resp := response.(*pb.CreateResponse)
+	respCreated, err := ProtoToPtrCollection(resp.Created)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.CreateResponse{Created: respCreated}, 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)
+	respCollection, err := ProtoToPtrCollection(resp.Collection)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.GetResponse{Collection: respCollection}, nil
+}
+
+func _Decode_List_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	if response == nil {
+		return nil, errors.New("nil ListResponse")
+	}
+	resp := response.(*pb.ListResponse)
+	respCollections, err := ProtoToListPtrCollection(resp.Collections)
+	if err != nil {
+		return nil, err
+	}
+	return &transport.ListResponse{Collections: respCollections}, nil
+}
+
+func _Decode_Update_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	return &empty.Empty{}, nil
+}
+
+func _Decode_SetSchema_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	return &empty.Empty{}, nil
+}
+
+func _Decode_Delete_Response(ctx context.Context, response interface{}) (interface{}, error) {
+	return &empty.Empty{}, nil
+}

pkg/collections/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 (
+	"fmt"
+
+	pb "git.perx.ru/perxis/perxis-go/proto/collections"
+	commonpb "git.perx.ru/perxis/perxis-go/proto/common"
+	"git.perx.ru/perxis/perxis/pkg/permission"
+	schema "git.perx.ru/perxis/perxis/schema"
+	service "git.perx.ru/perxis/perxis/services/collections"
+	jsoniter "github.com/json-iterator/go"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func PtrSchemaSchemaToProto(schema *schema.Schema) (string, error) {
+	if schema == nil {
+		return "", nil
+	}
+	res, err := jsoniter.MarshalToString(schema)
+	if err != nil {
+		return "", err
+	}
+	return res, nil
+}
+
+func ProtoToPtrSchemaSchema(protoSchema string) (*schema.Schema, error) {
+	if protoSchema == "" {
+		return nil, nil
+	}
+	sch := schema.New()
+	err := sch.UnmarshalJSON([]byte(protoSchema))
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode schema. err: %s", err.Error())
+	}
+	return sch, nil
+}
+
+func PtrCollectionToProto(coll *service.Collection) (*pb.Collection, error) {
+	if coll == nil {
+		return nil, nil
+	}
+
+	var access *pb.Access
+
+	if coll.Access != nil {
+		actions := make([]commonpb.Action, len(coll.Access.Actions))
+		for i, a := range coll.Access.Actions {
+			actions[i] = commonpb.Action(a)
+		}
+		access = &pb.Access{
+			Actions:         actions,
+			HiddenFields:    coll.Access.HiddenFields,
+			ReadonlyFields:  coll.Access.ReadonlyFields,
+			WriteonlyFields: coll.Access.WriteonlyFields,
+		}
+	}
+	protoCollection := &pb.Collection{
+		Id:      coll.ID,
+		SpaceId: coll.SpaceID,
+		EnvId:   coll.EnvID,
+		Name:    coll.Name,
+		Single:  coll.Single,
+		System:  coll.System,
+		NoData:  coll.NoData,
+		Access:  access,
+		Hidden:  coll.Hidden,
+		Tags:    coll.Tags,
+	}
+
+	if coll.StateInfo != nil {
+		protoCollection.StateInfo = &pb.Collection_StateInfo{
+			State:     pb.Collection_State(coll.StateInfo.State),
+			Info:      coll.StateInfo.Info,
+			StartedAt: timestamppb.New(coll.StateInfo.StartedAt),
+		}
+	}
+
+	sch, err := PtrSchemaSchemaToProto(coll.Schema)
+	if err != nil {
+		return nil, err
+	}
+	protoCollection.Schema = sch
+
+	if coll.View != nil {
+		protoCollection.View = &pb.Collection_View{
+			SpaceId:      coll.View.SpaceID,
+			EnvId:        coll.View.EnvID,
+			CollectionId: coll.View.CollectionID,
+			Filter:       coll.View.Filter,
+		}
+	}
+
+	return protoCollection, nil
+}
+
+func ProtoToPtrCollection(protoCollection *pb.Collection) (*service.Collection, error) {
+	if protoCollection == nil {
+		return nil, nil
+	}
+
+	var access *service.Access
+
+	if protoCollection.Access != nil {
+		actions := make([]permission.Action, len(protoCollection.Access.Actions))
+		for i, a := range protoCollection.Access.Actions {
+			actions[i] = permission.Action(a)
+		}
+		access = &service.Access{
+			Actions:         actions,
+			HiddenFields:    protoCollection.Access.HiddenFields,
+			ReadonlyFields:  protoCollection.Access.ReadonlyFields,
+			WriteonlyFields: protoCollection.Access.WriteonlyFields,
+		}
+	}
+	collection := &service.Collection{
+		ID:      protoCollection.Id,
+		SpaceID: protoCollection.SpaceId,
+		EnvID:   protoCollection.EnvId,
+		Name:    protoCollection.Name,
+		Single:  protoCollection.Single,
+		System:  protoCollection.System,
+		NoData:  protoCollection.NoData,
+		Access:  access,
+		Hidden:  protoCollection.Hidden,
+		Tags:    protoCollection.Tags,
+	}
+
+	if protoCollection.StateInfo != nil {
+		collection.StateInfo = &service.StateInfo{
+			State:     service.State(protoCollection.StateInfo.State),
+			Info:      protoCollection.StateInfo.Info,
+			StartedAt: protoCollection.StateInfo.StartedAt.AsTime(),
+		}
+	}
+
+	schm, err := ProtoToPtrSchemaSchema(protoCollection.Schema)
+	if err != nil {
+		return nil, err
+	}
+	collection.Schema = schm
+
+	if protoCollection.View != nil {
+		collection.View = &service.View{
+			SpaceID:      protoCollection.View.SpaceId,
+			EnvID:        protoCollection.View.EnvId,
+			CollectionID: protoCollection.View.CollectionId,
+			Filter:       protoCollection.View.Filter,
+		}
+	}
+
+	return collection, nil
+}
+
+func ListPtrCollectionToProto(collections []*service.Collection) ([]*pb.Collection, error) {
+	protoCollections := make([]*pb.Collection, 0, len(collections))
+	for _, collection := range collections {
+		protoCollection, err := PtrCollectionToProto(collection)
+		if err != nil {
+			return nil, err
+		}
+		protoCollections = append(protoCollections, protoCollection)
+	}
+	return protoCollections, nil
+}
+
+func ProtoToListPtrCollection(protoCollections []*pb.Collection) ([]*service.Collection, error) {
+	collections := make([]*service.Collection, 0, len(protoCollections))
+	for _, protoCollection := range protoCollections {
+		collection, err := ProtoToPtrCollection(protoCollection)
+		if err != nil {
+			return nil, err
+		}
+		collections = append(collections, collection)
+	}
+	return collections, nil
+}
+
+func ProtoToPtrBool(protoSingle *bool) (*bool, error) {
+	panic("function not provided") // TODO: provide converter
+}
+
+func PtrBoolToProto(single *bool) (*bool, error) {
+	panic("function not provided") // TODO: provide converter
+}
+
+func PtrFilterToProto(filter *service.Filter) (*pb.ListRequest_Filter, error) {
+	if filter == nil {
+		return nil, nil
+	}
+	return &pb.ListRequest_Filter{
+		ExcludeSystem: filter.ExcludeSystem,
+		IncludeNoData: filter.IncludeNoData,
+		IncludeHidden: filter.IncludeHidden,
+		Name:          filter.Name,
+		Id:            filter.ID,
+	}, nil
+}
+
+func ProtoToPtrFilter(protoFilter *pb.ListRequest_Filter) (*service.Filter, error) {
+	if protoFilter == nil {
+		return nil, nil
+	}
+	return &service.Filter{
+		IncludeNoData: protoFilter.IncludeNoData,
+		IncludeHidden: protoFilter.IncludeHidden,
+		ExcludeSystem: protoFilter.ExcludeSystem,
+		Name:          protoFilter.Name,
+		ID:            protoFilter.Id,
+	}, nil
+}
+
+func GetOptionsToProto(options []*service.GetOptions) *pb.GetOptions {
+	opts := service.MergeGetOptions(options...)
+	return &pb.GetOptions{DisableSchemaIncludes: opts.DisableSchemaIncludes}
+}
+
+func ProtoToGetOptions(protoOptions *pb.GetOptions) []*service.GetOptions {
+	if protoOptions == nil {
+		return nil
+	}
+	opts := &service.GetOptions{
+		DisableSchemaIncludes: protoOptions.DisableSchemaIncludes,
+	}
+	return []*service.GetOptions{opts}
+}

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

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// DO NOT EDIT.
+package transportgrpc
+
+import (
+	pb "git.perx.ru/perxis/perxis-go/proto/collections"
+	transport "git.perx.ru/perxis/perxis/services/collections/transport"
+	grpc "github.com/go-kit/kit/transport/grpc"
+	empty "github.com/golang/protobuf/ptypes/empty"
+	context "golang.org/x/net/context"
+)
+
+type collectionsServer struct {
+	create    grpc.Handler
+	get       grpc.Handler
+	list      grpc.Handler
+	update    grpc.Handler
+	setSchema grpc.Handler
+	delete    grpc.Handler
+
+	pb.UnimplementedCollectionsServer
+}
+
+func NewGRPCServer(endpoints *transport.EndpointsSet, opts ...grpc.ServerOption) pb.CollectionsServer {
+	return &collectionsServer{
+		create: grpc.NewServer(
+			endpoints.CreateEndpoint,
+			_Decode_Create_Request,
+			_Encode_Create_Response,
+			opts...,
+		),
+		delete: grpc.NewServer(
+			endpoints.DeleteEndpoint,
+			_Decode_Delete_Request,
+			_Encode_Delete_Response,
+			opts...,
+		),
+		get: grpc.NewServer(
+			endpoints.GetEndpoint,
+			_Decode_Get_Request,
+			_Encode_Get_Response,
+			opts...,
+		),
+		list: grpc.NewServer(
+			endpoints.ListEndpoint,
+			_Decode_List_Request,
+			_Encode_List_Response,
+			opts...,
+		),
+		setSchema: grpc.NewServer(
+			endpoints.SetSchemaEndpoint,
+			_Decode_SetSchema_Request,
+			_Encode_SetSchema_Response,
+			opts...,
+		),
+		update: grpc.NewServer(
+			endpoints.UpdateEndpoint,
+			_Decode_Update_Request,
+			_Encode_Update_Response,
+			opts...,
+		),
+	}
+}
+
+func (S *collectionsServer) Create(ctx context.Context, req *pb.CreateRequest) (*pb.CreateResponse, error) {
+	_, resp, err := S.create.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*pb.CreateResponse), nil
+}
+
+func (S *collectionsServer) 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
+}
+
+func (S *collectionsServer) List(ctx context.Context, req *pb.ListRequest) (*pb.ListResponse, error) {
+	_, resp, err := S.list.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*pb.ListResponse), nil
+}
+
+func (S *collectionsServer) Update(ctx context.Context, req *pb.UpdateRequest) (*empty.Empty, error) {
+	_, resp, err := S.update.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*empty.Empty), nil
+}
+
+func (S *collectionsServer) SetSchema(ctx context.Context, req *pb.SetSchemaRequest) (*empty.Empty, error) {
+	_, resp, err := S.setSchema.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*empty.Empty), nil
+}
+
+func (S *collectionsServer) Delete(ctx context.Context, req *pb.DeleteRequest) (*empty.Empty, error) {
+	_, resp, err := S.delete.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*empty.Empty), nil
+}

pkg/collections/transport/server.microgen.go

+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+	"context"
+
+	collections "git.perx.ru/perxis/perxis-go/pkg/collections"
+	endpoint "github.com/go-kit/kit/endpoint"
+)
+
+func Endpoints(svc collections.Collections) EndpointsSet {
+	return EndpointsSet{
+		CreateEndpoint:    CreateEndpoint(svc),
+		DeleteEndpoint:    DeleteEndpoint(svc),
+		GetEndpoint:       GetEndpoint(svc),
+		ListEndpoint:      ListEndpoint(svc),
+		SetSchemaEndpoint: SetSchemaEndpoint(svc),
+		UpdateEndpoint:    UpdateEndpoint(svc),
+	}
+}
+
+func CreateEndpoint(svc collections.Collections) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*CreateRequest)
+		res0, res1 := svc.Create(arg0, req.Collection)
+		return &CreateResponse{Created: res0}, res1
+	}
+}
+
+func GetEndpoint(svc collections.Collections) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*GetRequest)
+		res0, res1 := svc.Get(arg0, req.SpaceId, req.EnvId, req.CollectionId, req.Options...)
+		return &GetResponse{Collection: res0}, res1
+	}
+}
+
+func ListEndpoint(svc collections.Collections) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*ListRequest)
+		res0, res1 := svc.List(arg0, req.SpaceId, req.EnvId, req.Filter)
+		return &ListResponse{Collections: res0}, res1
+	}
+}
+
+func UpdateEndpoint(svc collections.Collections) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*UpdateRequest)
+		res0 := svc.Update(arg0, req.Coll)
+		return &UpdateResponse{}, res0
+	}
+}
+
+func SetSchemaEndpoint(svc collections.Collections) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*SetSchemaRequest)
+		res0 := svc.SetSchema(arg0, req.SpaceId, req.EnvId, req.CollectionId, req.Schema)
+		return &SetSchemaResponse{}, res0
+	}
+}
+
+func DeleteEndpoint(svc collections.Collections) endpoint.Endpoint {
+	return func(arg0 context.Context, request interface{}) (interface{}, error) {
+		req := request.(*DeleteRequest)
+		res0 := svc.Delete(arg0, req.SpaceId, req.EnvId, req.CollectionId)
+		return &DeleteResponse{}, res0
+	}
+}