anyproto/anytype-heart
1
0
Fork 0
mirror of https://github.com/anyproto/anytype-heart.git synced 2025-06-12 10:40:55 +09:00
Code Activity

Rename relation service to system object service

Browse source
This commit is contained in:
Sergey 2023-08-25 16:47:58 +05:00
parent f3c13ad4b4
commit 62d72a94d1
No known key found for this signature in database
GPG key ID: 3B6BEF79160221C6
68 changed files with 442 additions and 1260 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.mockery.yaml
View file

@ -35,6 +35,6 @@ packages:
github.com/anyproto/anytype-heart/core/block/restriction:
interfaces:
Service:
github.com/anyproto/anytype-heart/core/relation:
github.com/anyproto/anytype-heart/core/system_object:
interfaces:
Service:

2
cmd/archiveprocessor/main.go
View file

@ -13,7 +13,7 @@ import (
"github.com/gogo/protobuf/types"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/addr"

4
core/anytype/bootstrap.go
View file

@ -49,10 +49,10 @@ import (
"github.com/anyproto/anytype-heart/core/indexer"
"github.com/anyproto/anytype-heart/core/kanban"
"github.com/anyproto/anytype-heart/core/recordsbatcher"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/subscription"
"github.com/anyproto/anytype-heart/core/syncstatus"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/core/wallet"
"github.com/anyproto/anytype-heart/metrics"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -203,7 +203,7 @@ func Bootstrap(a *app.App, components ...app.Component) {
Register(localdiscovery.New()).
Register(peermanager.New()).
Register(typeprovider.New()).
Register(relation.New()).
Register(system_object.New()).
Register(converter.NewLayoutConverter()).
Register(recordsbatcher.New()).
Register(files.New()).

14
core/block/collection/service.go
View file

@ -12,8 +12,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/smartblock"
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -27,11 +27,11 @@ import (
var log = logging.Logger("collection-service")
type Service struct {
lock *sync.RWMutex
collections map[string]map[string]chan []string
relationService relation.Service
picker block.Picker
objectStore objectstore.ObjectStore
lock *sync.RWMutex
collections map[string]map[string]chan []string
systemObjectService system_object.Service
picker block.Picker
objectStore objectstore.ObjectStore
}
func New() *Service {
@ -44,7 +44,7 @@ func New() *Service {
func (s *Service) Init(a *app.App) (err error) {
s.picker = app.MustComponent[block.Picker](a)
s.objectStore = app.MustComponent[objectstore.ObjectStore](a)
s.relationService = app.MustComponent[relation.Service](a)
s.systemObjectService = app.MustComponent[system_object.Service](a)
return nil
}

8
core/block/collection/service_test.go
View file

@ -12,7 +12,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/smartblock"
"github.com/anyproto/anytype-heart/core/block/editor/smartblock/smarttest"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore/mock_objectstore"
)
@ -39,12 +39,12 @@ func newFixture(t *testing.T) *fixture {
objectStore := mock_objectstore.NewMockObjectStore(t)
objectStore.EXPECT().Name().Return("objectStore")
relationService := mock_relation.NewMockService(t)
relationService.EXPECT().Name().Return("relationService")
systemObjectService := mock_system_object.NewMockService(t)
systemObjectService.EXPECT().Name().Return("systemObjectService")
a.Register(picker)
a.Register(objectStore)
a.Register(relationService)
a.Register(systemObjectService)
s := New()
err := s.Init(a)

2
core/block/create.go
View file

@ -69,7 +69,7 @@ func (s *Service) TemplateClone(spaceID string, id string) (templateID string, e
if err != nil {
return fmt.Errorf("get target object type key: %w", err)
}
targetObjectTypeID, err := s.relationService.GetTypeIdByKey(context.Background(), spaceID, targetObjectTypeKey)
targetObjectTypeID, err := s.systemObjectService.GetTypeIdByKey(context.Background(), spaceID, targetObjectTypeKey)
if err != nil {
return fmt.Errorf("get target object type id: %w", err)
}

6
core/block/editor.go
View file

@ -577,11 +577,11 @@ func (s *Service) SetRelationKey(ctx session.Context, req pb.RpcBlockRelationSet
return Do(s, req.ContextId, func(b basic.CommonOperations) error {
return fmt.Errorf("not implemented")
// todo: implement me
/*rel, err := s.relationService.FetchRelationByKey(b.req.Key)
/*rel, err := s.systemObjectService.FetchRelationByKey(b.req.Key)
if err != nil {
return err
}
return b.AddRelationAndSet(ctx, s.relationService, pb.RpcBlockRelationAddRequest{
return b.AddRelationAndSet(ctx, s.systemObjectService, pb.RpcBlockRelationAddRequest{
RelationKey: rel.Key, BlockId: req.BlockId, ContextId: req.ContextId,
})*/
})
@ -589,7 +589,7 @@ func (s *Service) SetRelationKey(ctx session.Context, req pb.RpcBlockRelationSet
func (s *Service) AddRelationBlock(ctx session.Context, req pb.RpcBlockRelationAddRequest) error {
return Do(s, req.ContextId, func(b basic.CommonOperations) error {
return b.AddRelationAndSet(ctx, s.relationService, req)
return b.AddRelationAndSet(ctx, s.systemObjectService, req)
})
}

2
core/block/editor/archive.go
View file

@ -8,8 +8,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/migration"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/database"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"

24
core/block/editor/basic/basic.go
View file

@ -16,8 +16,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/simple/link"
relationblock "github.com/anyproto/anytype-heart/core/block/simple/relation"
"github.com/anyproto/anytype-heart/core/block/simple/text"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
@ -45,7 +45,7 @@ type CommonOperations interface {
SetLatexText(ctx session.Context, req pb.RpcBlockLatexSetTextRequest) error
SetRelationKey(ctx session.Context, req pb.RpcBlockRelationSetKeyRequest) error
AddRelationAndSet(ctx session.Context, service relation.Service, req pb.RpcBlockRelationAddRequest) error
AddRelationAndSet(ctx session.Context, service system_object.Service, req pb.RpcBlockRelationAddRequest) error
FeaturedRelationAdd(ctx session.Context, relations ...string) error
FeaturedRelationRemove(ctx session.Context, relations ...string) error
@ -97,23 +97,23 @@ var ErrNotSupported = fmt.Errorf("operation not supported for this type of smart
func NewBasic(
sb smartblock.SmartBlock,
objectStore objectstore.ObjectStore,
relationService relation.Service,
systemObjectService system_object.Service,
layoutConverter converter.LayoutConverter,
) AllOperations {
return &basic{
SmartBlock: sb,
objectStore: objectStore,
relationService: relationService,
layoutConverter: layoutConverter,
SmartBlock: sb,
objectStore: objectStore,
systemObjectService: systemObjectService,
layoutConverter: layoutConverter,
}
}
type basic struct {
smartblock.SmartBlock
objectStore objectstore.ObjectStore
relationService relation.Service
layoutConverter converter.LayoutConverter
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
layoutConverter converter.LayoutConverter
}
func (bs *basic) CreateBlock(s *state.State, req pb.RpcBlockCreateRequest) (id string, err error) {
@ -366,14 +366,14 @@ func (bs *basic) SetLatexText(ctx session.Context, req pb.RpcBlockLatexSetTextRe
return bs.Apply(s, smartblock.NoEvent)
}
func (bs *basic) AddRelationAndSet(ctx session.Context, relationService relation.Service, req pb.RpcBlockRelationAddRequest) (err error) {
func (bs *basic) AddRelationAndSet(ctx session.Context, systemObjectService system_object.Service, req pb.RpcBlockRelationAddRequest) (err error) {
s := bs.NewStateCtx(ctx)
b := s.Get(req.BlockId)
if b == nil {
return smartblock.ErrSimpleBlockNotFound
}
rel, err := relationService.FetchRelationByKey(s.SpaceID(), req.RelationKey)
rel, err := systemObjectService.FetchRelationByKey(s.SpaceID(), req.RelationKey)
if err != nil {
return
}

10
core/block/editor/basic/details.go
View file

@ -11,8 +11,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/restriction"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -99,7 +99,7 @@ func (bs *basic) createDetailUpdate(st *state.State, detail *pb.RpcObjectSetDeta
}
func (bs *basic) validateDetailFormat(spaceID string, key string, v *types.Value) error {
r, err := bs.relationService.FetchRelationByKey(spaceID, key)
r, err := bs.systemObjectService.FetchRelationByKey(spaceID, key)
if err != nil {
return err
}
@ -243,7 +243,7 @@ func (bs *basic) setDetailSpecialCases(st *state.State, detail *pb.RpcObjectSetD
func (bs *basic) addRelationLink(relationKey string, st *state.State) error {
// TODO: add relation.WithWorkspaceId(workspaceId) filter
rel, err := bs.relationService.FetchRelationByKey(st.SpaceID(), relationKey)
rel, err := bs.systemObjectService.FetchRelationByKey(st.SpaceID(), relationKey)
if err != nil || rel == nil {
return fmt.Errorf("failed to get relation: %w", err)
}
@ -316,7 +316,7 @@ func (bs *basic) SetObjectTypesInState(s *state.State, objectTypeKeys []bundle.T
prevTypeID := pbtypes.GetString(s.LocalDetails(), bundle.RelationKeyType.String())
// nolint:errcheck
prevType, _ := bs.relationService.GetObjectType(prevTypeID)
prevType, _ := bs.systemObjectService.GetObjectType(prevTypeID)
s.SetObjectTypeKeys(objectTypeKeys)
@ -339,7 +339,7 @@ func (bs *basic) getLayoutForType(objectTypeKey bundle.TypeKey) (model.ObjectTyp
if err != nil {
return 0, fmt.Errorf("create unique key: %w", err)
}
typeDetails, err := bs.relationService.GetObjectByUniqueKey(bs.SpaceID(), uk)
typeDetails, err := bs.systemObjectService.GetObjectByUniqueKey(bs.SpaceID(), uk)
if err != nil {
return 0, fmt.Errorf("get object by unique key: %w", err)
}

2
core/block/editor/basic/extract_objects.go
View file

@ -76,7 +76,7 @@ func (bs *basic) prepareTargetObjectDetails(
rootBlock simple.Block,
objectCreator ObjectCreator,
) (*types.Struct, error) {
objType, err := bs.relationService.GetObjectByUniqueKey(spaceID, typeUniqueKey)
objType, err := bs.systemObjectService.GetObjectByUniqueKey(spaceID, typeUniqueKey)
if err != nil {
return nil, err
}

24
core/block/editor/basic/extract_objects_test.go
View file

@ -16,8 +16,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -195,7 +195,7 @@ func TestExtractObjects(t *testing.T) {
ObjectTypeUniqueKey: domain.MustUniqueKey(coresb.SmartBlockTypeObjectType, bundle.TypeKeyNote.String()).Marshal(),
}
ctx := session.NewContext()
linkIds, err := NewBasic(sb, fixture.store, fixture.relationService, converter.NewLayoutConverter()).ExtractBlocksToObjects(ctx, ts, req)
linkIds, err := NewBasic(sb, fixture.store, fixture.systemObjectService, converter.NewLayoutConverter()).ExtractBlocksToObjects(ctx, ts, req)
assert.NoError(t, err)
var gotBlockIds []string
@ -229,10 +229,10 @@ func TestExtractObjects(t *testing.T) {
}
type fixture struct {
t *testing.T
ctrl *gomock.Controller
store *testMock.MockObjectStore
relationService *mock_relation.MockService
t *testing.T
ctrl *gomock.Controller
store *testMock.MockObjectStore
systemObjectService *mock_system_object.MockService
}
func newFixture(t *testing.T) *fixture {
@ -247,14 +247,14 @@ func newFixture(t *testing.T) *fixture {
},
}
relationService := mock_relation.NewMockService(t)
relationService.EXPECT().GetObjectByUniqueKey(mock.Anything, mock.Anything).Return(objectTypeDetails, nil).Maybe()
systemObjectService := mock_system_object.NewMockService(t)
systemObjectService.EXPECT().GetObjectByUniqueKey(mock.Anything, mock.Anything).Return(objectTypeDetails, nil).Maybe()
return &fixture{
t: t,
ctrl: ctrl,
store: objectStore,
relationService: relationService,
t: t,
ctrl: ctrl,
store: objectStore,
systemObjectService: systemObjectService,
}
}

24
core/block/editor/clipboard/clipboard.go
View file

@ -19,8 +19,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/simple/text"
"github.com/anyproto/anytype-heart/core/converter/html"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/logging"
@ -45,24 +45,24 @@ func NewClipboard(
sb smartblock.SmartBlock,
file file.File,
tempDirProvider core.TempDirProvider,
relationService relation.Service,
systemObjectService system_object.Service,
fileService files.Service,
) Clipboard {
return &clipboard{
SmartBlock: sb,
file: file,
tempDirProvider: tempDirProvider,
relationService: relationService,
fileService: fileService,
SmartBlock: sb,
file: file,
tempDirProvider: tempDirProvider,
systemObjectService: systemObjectService,
fileService: fileService,
}
}
type clipboard struct {
smartblock.SmartBlock
file file.File
tempDirProvider core.TempDirProvider
relationService relation.Service
fileService files.Service
file file.File
tempDirProvider core.TempDirProvider
systemObjectService system_object.Service
fileService files.Service
}
func (cb *clipboard) Paste(ctx session.Context, req *pb.RpcBlockPasteRequest, groupId string) (blockIds []string, uploadArr []pb.RpcBlockUploadRequest, caretPosition int32, isSameBlockCaret bool, err error) {
@ -560,7 +560,7 @@ func (cb *clipboard) addRelationLinksToDataview(d *model.BlockContentDataview) (
for k := range relationKeys {
relationKeysList = append(relationKeysList, k)
}
relations, err := cb.relationService.FetchRelationByKeys(cb.SpaceID(), relationKeysList...)
relations, err := cb.systemObjectService.FetchRelationByKeys(cb.SpaceID(), relationKeysList...)
if err != nil {
return fmt.Errorf("failed to fetch relation keys of dataview: %v", err)
}

8
core/block/editor/common_migrations.go
View file

@ -7,11 +7,11 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/simple"
dataview2 "github.com/anyproto/anytype-heart/core/block/simple/dataview"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
)
func migrateSourcesInDataview(sb smartblock.SmartBlock, s *state.State, relationService relation.Service) {
func migrateSourcesInDataview(sb smartblock.SmartBlock, s *state.State, systemObjectService system_object.Service) {
s.Iterate(func(block simple.Block) bool {
if block.Model().GetDataview() != nil {
// Mark block as mutable
@ -20,7 +20,7 @@ func migrateSourcesInDataview(sb smartblock.SmartBlock, s *state.State, relation
for _, src := range dv.GetSource() {
typeKey, err := bundle.TypeKeyFromUrl(src)
if err == nil {
typeID, err := relationService.GetTypeIdByKey(context.Background(), sb.SpaceID(), typeKey)
typeID, err := systemObjectService.GetTypeIdByKey(context.Background(), sb.SpaceID(), typeKey)
if err != nil {
log.Errorf("migrate dataview sources: failed to get type id by key: %v", err)
continue
@ -31,7 +31,7 @@ func migrateSourcesInDataview(sb smartblock.SmartBlock, s *state.State, relation
relationKey, err := bundle.RelationKeyFromID(src)
if err == nil {
relationID, err := relationService.GetRelationIdByKey(context.Background(), sb.SpaceID(), relationKey)
relationID, err := systemObjectService.GetRelationIdByKey(context.Background(), sb.SpaceID(), relationKey)
if err != nil {
log.Errorf("migrate dataview sources: failed to get relation id by key: %v", err)
continue

10
core/block/editor/converter/layout.go
View file

@ -10,7 +10,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/database"
@ -29,9 +29,9 @@ type LayoutConverter interface {
}
type layoutConverter struct {
objectStore objectstore.ObjectStore
sbtProvider typeprovider.SmartBlockTypeProvider
relationService relation.Service
objectStore objectstore.ObjectStore
sbtProvider typeprovider.SmartBlockTypeProvider
systemObjectService system_object.Service
}
func NewLayoutConverter() LayoutConverter {
@ -145,7 +145,7 @@ func (c *layoutConverter) fromAnyToSet(st *state.State) error {
return nil
}
dvBlock, _, err := dataview.BlockBySource(st.SpaceID(), c.sbtProvider, c.relationService, source)
dvBlock, _, err := dataview.BlockBySource(st.SpaceID(), c.sbtProvider, c.systemObjectService, source)
if err != nil {
return err
}

6
core/block/editor/dashboard.go
View file

@ -10,7 +10,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/migration"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/database"
@ -34,13 +34,13 @@ func NewDashboard(
sb smartblock.SmartBlock,
detailsModifier DetailsModifier,
objectStore objectstore.ObjectStore,
relationService relation.Service,
systemObjectService system_object.Service,
anytype core.Service,
layoutConverter converter.LayoutConverter,
) *Dashboard {
return &Dashboard{
SmartBlock: sb,
AllOperations: basic.NewBasic(sb, objectStore, relationService, layoutConverter),
AllOperations: basic.NewBasic(sb, objectStore, systemObjectService, layoutConverter),
Collection: collection.NewCollection(sb),
DetailsModifier: detailsModifier,
objectStore: objectStore,

38
core/block/editor/dataview/dataview.go
View file

@ -12,9 +12,9 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/block/simple/dataview"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -59,15 +59,15 @@ func NewDataview(
sb smartblock.SmartBlock,
anytype core.Service,
objectStore objectstore.ObjectStore,
relationService relation.Service,
systemObjectService system_object.Service,
sbtProvider typeprovider.SmartBlockTypeProvider,
) Dataview {
dv := &sdataview{
SmartBlock: sb,
anytype: anytype,
objectStore: objectStore,
relationService: relationService,
sbtProvider: sbtProvider,
SmartBlock: sb,
anytype: anytype,
objectStore: objectStore,
systemObjectService: systemObjectService,
sbtProvider: sbtProvider,
}
sb.AddHook(dv.checkDVBlocks, smartblock.HookBeforeApply)
return dv
@ -75,10 +75,10 @@ func NewDataview(
type sdataview struct {
smartblock.SmartBlock
anytype core.Service
objectStore objectstore.ObjectStore
relationService relation.Service
sbtProvider typeprovider.SmartBlockTypeProvider
anytype core.Service
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
sbtProvider typeprovider.SmartBlockTypeProvider
}
func (d *sdataview) GetDataviewBlock(s *state.State, blockID string) (dataview.Block, error) {
@ -105,7 +105,7 @@ func (d *sdataview) SetSource(ctx session.Context, blockId string, source []stri
return d.Apply(s, smartblock.NoRestrictions)
}
dvContent, _, err := BlockBySource(s.SpaceID(), d.sbtProvider, d.relationService, source)
dvContent, _, err := BlockBySource(s.SpaceID(), d.sbtProvider, d.systemObjectService, source)
if err != nil {
return
}
@ -130,7 +130,7 @@ func (d *sdataview) AddRelations(ctx session.Context, blockId string, relationKe
return err
}
for _, key := range relationKeys {
relation, err2 := d.relationService.FetchRelationByKey(s.SpaceID(), key)
relation, err2 := d.systemObjectService.FetchRelationByKey(s.SpaceID(), key)
if err2 != nil {
return err2
}
@ -368,7 +368,7 @@ func (d *sdataview) DataviewMoveObjectsInView(ctx session.Context, req *pb.RpcBl
return d.Apply(st)
}
func SchemaBySources(spaceID string, sbtProvider typeprovider.SmartBlockTypeProvider, sources []string, relationService relation.Service) (database.Schema, error) {
func SchemaBySources(spaceID string, sbtProvider typeprovider.SmartBlockTypeProvider, sources []string, systemObjectService system_object.Service) (database.Schema, error) {
var relationFound, typeFound bool
for _, source := range sources {
@ -395,7 +395,7 @@ func SchemaBySources(spaceID string, sbtProvider typeprovider.SmartBlockTypeProv
}
}
if typeFound {
objectType, err := relationService.GetObjectType(sources[0])
objectType, err := systemObjectService.GetObjectType(sources[0])
if err != nil {
return nil, err
}
@ -406,7 +406,7 @@ func SchemaBySources(spaceID string, sbtProvider typeprovider.SmartBlockTypeProv
if relationFound {
var relations []*model.RelationLink
for _, relId := range sources {
rel, err := relationService.GetRelationByID(relId)
rel, err := systemObjectService.GetRelationByID(relId)
if err != nil {
return nil, fmt.Errorf("failed to get relation %s: %s", relId, err.Error())
}
@ -550,8 +550,8 @@ func calculateEntriesDiff(a, b []database.Record) (updated []*types.Struct, remo
return
}
func BlockBySource(spaceID string, sbtProvider typeprovider.SmartBlockTypeProvider, relationService relation.Service, source []string) (res model.BlockContentOfDataview, schema database.Schema, err error) {
if schema, err = SchemaBySources(spaceID, sbtProvider, source, relationService); err != nil {
func BlockBySource(spaceID string, sbtProvider typeprovider.SmartBlockTypeProvider, systemObjectService system_object.Service, source []string) (res model.BlockContentOfDataview, schema database.Schema, err error) {
if schema, err = SchemaBySources(spaceID, sbtProvider, source, systemObjectService); err != nil {
return
}

52
core/block/editor/factory.go
View file

@ -17,7 +17,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/source"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/core"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
@ -28,23 +28,23 @@ import (
var log = logging.Logger("anytype-mw-editor")
type ObjectFactory struct {
anytype core.Service
bookmarkService bookmark.BookmarkService
detailsModifier DetailsModifier
fileBlockService file.BlockService
layoutConverter converter.LayoutConverter
objectStore objectstore.ObjectStore
relationService relation.Service
sbtProvider typeprovider.SmartBlockTypeProvider
sourceService source.Service
tempDirProvider core.TempDirProvider
templateCloner templateCloner
fileService files.Service
config *config.Config
picker getblock.Picker
eventSender event.Sender
restrictionService restriction.Service
indexer smartblock.Indexer
anytype core.Service
bookmarkService bookmark.BookmarkService
detailsModifier DetailsModifier
fileBlockService file.BlockService
layoutConverter converter.LayoutConverter
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
sbtProvider typeprovider.SmartBlockTypeProvider
sourceService source.Service
tempDirProvider core.TempDirProvider
templateCloner templateCloner
fileService files.Service
config *config.Config
picker getblock.Picker
eventSender event.Sender
restrictionService restriction.Service
indexer smartblock.Indexer
}
func NewObjectFactory() *ObjectFactory {
@ -57,7 +57,7 @@ func (f *ObjectFactory) Init(a *app.App) (err error) {
f.detailsModifier = app.MustComponent[DetailsModifier](a)
f.fileBlockService = app.MustComponent[file.BlockService](a)
f.objectStore = app.MustComponent[objectstore.ObjectStore](a)
f.relationService = app.MustComponent[relation.Service](a)
f.systemObjectService = app.MustComponent[system_object.Service](a)
f.restrictionService = app.MustComponent[restriction.Service](a)
f.sourceService = app.MustComponent[source.Service](a)
f.templateCloner = app.MustComponent[templateCloner](a)
@ -127,7 +127,7 @@ func (f *ObjectFactory) produceSmartblock() smartblock.SmartBlock {
f.fileService,
f.restrictionService,
f.objectStore,
f.relationService,
f.systemObjectService,
f.indexer,
f.eventSender,
)
@ -149,7 +149,7 @@ func (f *ObjectFactory) New(sbType coresb.SmartBlockType) (smartblock.SmartBlock
f.fileBlockService,
f.picker,
f.bookmarkService,
f.relationService,
f.systemObjectService,
f.tempDirProvider,
f.sbtProvider,
f.layoutConverter,
@ -167,7 +167,7 @@ func (f *ObjectFactory) New(sbType coresb.SmartBlockType) (smartblock.SmartBlock
sb,
f.detailsModifier,
f.objectStore,
f.relationService,
f.systemObjectService,
f.anytype,
f.layoutConverter,
), nil
@ -176,7 +176,7 @@ func (f *ObjectFactory) New(sbType coresb.SmartBlockType) (smartblock.SmartBlock
return NewProfile(
sb,
f.objectStore,
f.relationService,
f.systemObjectService,
f.fileBlockService,
f.anytype,
f.picker,
@ -197,7 +197,7 @@ func (f *ObjectFactory) New(sbType coresb.SmartBlockType) (smartblock.SmartBlock
f.fileBlockService,
f.picker,
f.bookmarkService,
f.relationService,
f.systemObjectService,
f.tempDirProvider,
f.sbtProvider,
f.layoutConverter,
@ -209,7 +209,7 @@ func (f *ObjectFactory) New(sbType coresb.SmartBlockType) (smartblock.SmartBlock
sb,
f.objectStore,
f.anytype,
f.relationService,
f.systemObjectService,
f.sourceService,
f.detailsModifier,
f.sbtProvider,
@ -221,7 +221,7 @@ func (f *ObjectFactory) New(sbType coresb.SmartBlockType) (smartblock.SmartBlock
case coresb.SmartBlockTypeMissingObject:
return NewMissingObject(sb), nil
case coresb.SmartBlockTypeWidget:
return NewWidgetObject(sb, f.objectStore, f.relationService, f.layoutConverter), nil
return NewWidgetObject(sb, f.objectStore, f.systemObjectService, f.layoutConverter), nil
case coresb.SmartBlockTypeSubObject:
return nil, fmt.Errorf("subobject not supported via factory")
default:

24
core/block/editor/page.go
View file

@ -17,7 +17,7 @@ import (
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -39,8 +39,8 @@ type Page struct {
dataview.Dataview
table.TableEditor
objectStore objectstore.ObjectStore
relationService relation.Service
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
}
func NewPage(
@ -50,7 +50,7 @@ func NewPage(
fileBlockService file.BlockService,
picker getblock.Picker,
bookmarkService bookmark.BookmarkService,
relationService relation.Service,
systemObjectService system_object.Service,
tempDirProvider core.TempDirProvider,
sbtProvider typeprovider.SmartBlockTypeProvider,
layoutConverter converter.LayoutConverter,
@ -67,7 +67,7 @@ func NewPage(
)
return &Page{
SmartBlock: sb,
AllOperations: basic.NewBasic(sb, objectStore, relationService, layoutConverter),
AllOperations: basic.NewBasic(sb, objectStore, systemObjectService, layoutConverter),
IHistory: basic.NewHistory(sb),
Text: stext.NewText(
sb,
@ -79,7 +79,7 @@ func NewPage(
sb,
f,
tempDirProvider,
relationService,
systemObjectService,
fileService,
),
Bookmark: bookmark.NewBookmark(
@ -92,12 +92,12 @@ func NewPage(
sb,
anytype,
objectStore,
relationService,
systemObjectService,
sbtProvider,
),
TableEditor: table.NewEditor(sb),
objectStore: objectStore,
relationService: relationService,
TableEditor: table.NewEditor(sb),
objectStore: objectStore,
systemObjectService: systemObjectService,
}
}
@ -124,7 +124,7 @@ func (p *Page) CreationStateMigration(ctx *smartblock.InitContext) migration.Mig
if err != nil {
log.Errorf("failed to create unique key: %v", err)
} else {
otype, err := p.relationService.GetObjectByUniqueKey(s.SpaceID(), uk)
otype, err := p.systemObjectService.GetObjectByUniqueKey(s.SpaceID(), uk)
if err != nil {
log.Errorf("failed to get object by unique key: %v", err)
} else {
@ -197,7 +197,7 @@ func (p *Page) StateMigrations() migration.Migrations {
{
Version: 2,
Proc: func(s *state.State) {
migrateSourcesInDataview(p, s, p.relationService)
migrateSourcesInDataview(p, s, p.systemObjectService)
},
},
})

8
core/block/editor/profile.go
View file

@ -15,8 +15,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/migration"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -42,7 +42,7 @@ type Profile struct {
func NewProfile(
sb smartblock.SmartBlock,
objectStore objectstore.ObjectStore,
relationService relation.Service,
systemObjectService system_object.Service,
fileBlockService file.BlockService,
anytype core.Service,
picker getblock.Picker,
@ -62,7 +62,7 @@ func NewProfile(
)
return &Profile{
SmartBlock: sb,
AllOperations: basic.NewBasic(sb, objectStore, relationService, layoutConverter),
AllOperations: basic.NewBasic(sb, objectStore, systemObjectService, layoutConverter),
IHistory: basic.NewHistory(sb),
Text: stext.NewText(
sb,
@ -74,7 +74,7 @@ func NewProfile(
sb,
f,
tempDirProvider,
relationService,
systemObjectService,
fileService,
),
Bookmark: bookmark.NewBookmark(

50
core/block/editor/smartblock/smartblock.go
View file

@ -26,9 +26,9 @@ import (
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/metrics"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
@ -89,7 +89,7 @@ func New(
fileService files.Service,
restrictionService restriction.Service,
objectStore objectstore.ObjectStore,
relationService relation.Service,
systemObjectService system_object.Service,
indexer Indexer,
eventSender event.Sender,
) SmartBlock {
@ -99,13 +99,13 @@ func New(
Locker: &sync.Mutex{},
sessions: map[string]session.Context{},
coreService: coreService,
fileService: fileService,
restrictionService: restrictionService,
objectStore: objectStore,
relationService: relationService,
indexer: indexer,
eventSender: eventSender,
coreService: coreService,
fileService: fileService,
restrictionService: restrictionService,
objectStore: objectStore,
systemObjectService: systemObjectService,
indexer: indexer,
eventSender: eventSender,
}
return s
}
@ -213,13 +213,13 @@ type smartBlock struct {
closeRecordsSub func()
// Deps
coreService core.Service
fileService files.Service
restrictionService restriction.Service
objectStore objectstore.ObjectStore
relationService relation.Service
indexer Indexer
eventSender event.Sender
coreService core.Service
fileService files.Service
restrictionService restriction.Service
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
indexer Indexer
eventSender event.Sender
}
type LockerSetter interface {
@ -504,7 +504,7 @@ func (sb *smartBlock) onMetaChange(details *types.Struct) {
// dependentSmartIds returns list of dependent objects in this order: Simple blocks(Link, mentions in Text), Relations. Both of them are returned in the order of original blocks/relations
func (sb *smartBlock) dependentSmartIds(includeRelations, includeObjTypes, includeCreatorModifier, _ bool) (ids []string) {
return objectlink.DependentObjectIDs(sb.Doc.(*state.State), sb.relationService, true, true, includeRelations, includeObjTypes, includeCreatorModifier)
return objectlink.DependentObjectIDs(sb.Doc.(*state.State), sb.systemObjectService, true, true, includeRelations, includeObjTypes, includeCreatorModifier)
}
func (sb *smartBlock) navigationalLinks(s *state.State) []string {
@ -550,7 +550,7 @@ func (sb *smartBlock) navigationalLinks(s *state.State) []string {
for _, rel := range s.GetRelationLinks() {
if includeRelations {
relId, err := sb.relationService.GetRelationIdByKey(context.TODO(), sb.SpaceID(), bundle.RelationKey(rel.Key))
relId, err := sb.systemObjectService.GetRelationIdByKey(context.TODO(), sb.SpaceID(), bundle.RelationKey(rel.Key))
if err != nil {
log.With("objectID", s.RootId()).Errorf("failed to derive object id for relation: %s", err)
continue
@ -858,10 +858,6 @@ func (sb *smartBlock) Anytype() core.Service {
return sb.coreService
}
func (sb *smartBlock) RelationService() relation.Service {
return sb.relationService
}
func (sb *smartBlock) AddRelationLinks(ctx session.Context, relationKeys ...string) (err error) {
s := sb.NewStateCtx(ctx)
if err = sb.AddRelationLinksToState(s, relationKeys...); err != nil {
@ -874,7 +870,7 @@ func (sb *smartBlock) AddRelationLinksToState(s *state.State, relationKeys ...st
if len(relationKeys) == 0 {
return
}
relations, err := sb.relationService.FetchRelationByKeys(s.SpaceID(), relationKeys...)
relations, err := sb.systemObjectService.FetchRelationByKeys(s.SpaceID(), relationKeys...)
if err != nil {
return
}
@ -974,7 +970,7 @@ func (sb *smartBlock) SetVerticalAlign(ctx session.Context, align model.BlockVer
func (sb *smartBlock) TemplateCreateFromObjectState() (*state.State, error) {
st := sb.NewState().Copy()
st.SetLocalDetails(nil)
targetObjectTypeID, err := sb.relationService.GetTypeIdByKey(context.Background(), st.SpaceID(), st.ObjectTypeKey())
targetObjectTypeID, err := sb.systemObjectService.GetTypeIdByKey(context.Background(), st.SpaceID(), st.ObjectTypeKey())
if err != nil {
return nil, fmt.Errorf("get type id by key: %s", err)
}
@ -1234,7 +1230,7 @@ func (sb *smartBlock) Relations(s *state.State) relationutils.Relations {
} else {
links = s.GetRelationLinks()
}
rels, _ := sb.RelationService().FetchRelationByLinks(sb.spaceID, links)
rels, _ := sb.systemObjectService.FetchRelationByLinks(sb.spaceID, links)
return rels
}
@ -1385,7 +1381,7 @@ func (sb *smartBlock) injectDerivedDetails(s *state.State, spaceId string, sbt s
log.Errorf("InjectDerivedDetails: failed to set space id for %s: no space id provided", id)
}
if ot := s.ObjectTypeKey(); ot != "" {
typeID, err := sb.relationService.GetTypeIdByKey(context.Background(), s.SpaceID(), ot)
typeID, err := sb.systemObjectService.GetTypeIdByKey(context.Background(), s.SpaceID(), ot)
if err != nil {
log.Errorf("failed to get type id for %s: %v", ot, err)
}

8
core/block/editor/smartblock/smartblock_test.go
View file

@ -14,8 +14,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/restriction/mock_restriction"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/event/mock_event"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/mock_core"
@ -132,15 +132,15 @@ func newFixture(t *testing.T) *fixture {
restrictionService := mock_restriction.NewMockService(t)
restrictionService.EXPECT().GetRestrictions(mock.Anything).Return(restriction.Restrictions{})
relationService := mock_relation.NewMockService(t)
relationService.EXPECT().GetObjectType(mock.Anything).Return(&model.ObjectType{}, nil).Maybe()
systemObjectService := mock_system_object.NewMockService(t)
systemObjectService.EXPECT().GetObjectType(mock.Anything).Return(&model.ObjectType{}, nil).Maybe()
fileService := testMock.NewMockFileService(ctrl)
sender := mock_event.NewMockSender(t)
return &fixture{
SmartBlock: New(coreService, fileService, restrictionService, objectStore, relationService, indexer, sender),
SmartBlock: New(coreService, fileService, restrictionService, objectStore, systemObjectService, indexer, sender),
t: t,
at: coreService,
ctrl: ctrl,

7
core/block/editor/smartblock/smarttest/smarttest.go
View file

@ -13,9 +13,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/restriction"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/block/undo"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/core"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -62,10 +61,6 @@ func (st *SmartTest) IsLocked() bool {
return false
}
func (st *SmartTest) RelationService() relation.Service {
return st.App.Component(relation.CName).(relation.Service)
}
func (st *SmartTest) Locked() bool {
return false
}

2
core/block/editor/state/change.go
View file

@ -11,7 +11,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"

8
core/block/editor/subobjectcollection.go
View file

@ -17,7 +17,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/block/source"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/addr"
@ -66,7 +66,7 @@ func NewSubObjectCollection(
defaultCollectionName string,
objectStore objectstore.ObjectStore,
anytype core.Service,
relationService relation.Service,
systemObjectService system_object.Service,
sourceService source.Service,
sbtProvider typeprovider.SmartBlockTypeProvider,
layoutConverter converter.LayoutConverter,
@ -74,7 +74,7 @@ func NewSubObjectCollection(
) *SubObjectCollection {
return &SubObjectCollection{
SmartBlock: sb,
AllOperations: basic.NewBasic(sb, objectStore, relationService, layoutConverter),
AllOperations: basic.NewBasic(sb, objectStore, systemObjectService, layoutConverter),
IHistory: basic.NewHistory(sb),
Text: stext.NewText(
sb,
@ -85,7 +85,7 @@ func NewSubObjectCollection(
sb,
anytype,
objectStore,
relationService,
systemObjectService,
sbtProvider,
),

10
core/block/editor/template.go
View file

@ -14,7 +14,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/migration"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -34,7 +34,7 @@ func NewTemplate(
fileBlockService file.BlockService,
picker getblock.Picker,
bookmarkService bookmark.BookmarkService,
relationService relation.Service,
systemObjectService system_object.Service,
tempDirProvider core.TempDirProvider,
sbtProvider typeprovider.SmartBlockTypeProvider,
layoutConverter converter.LayoutConverter,
@ -48,7 +48,7 @@ func NewTemplate(
fileBlockService,
picker,
bookmarkService,
relationService,
systemObjectService,
tempDirProvider,
sbtProvider,
layoutConverter,
@ -83,7 +83,7 @@ func (t *Template) CreationStateMigration(ctx *smartblock.InitContext) migration
if t.Type() == coresb.SmartBlockTypeTemplate && (len(t.ObjectTypeKeys()) != 2 || fixOt) {
targetObjectTypeID := pbtypes.GetString(s.Details(), bundle.RelationKeyTargetObjectType.String())
if targetObjectTypeID != "" {
targetObjectType, err := t.relationService.GetObjectType(targetObjectTypeID)
targetObjectType, err := t.systemObjectService.GetObjectType(targetObjectTypeID)
if err != nil {
log.Errorf("template createion state: failed to get target object type %s: %s", targetObjectTypeID, err)
return
@ -101,7 +101,7 @@ func (t *Template) GetNewPageState(name string) (st *state.State, err error) {
st = t.NewState().Copy()
objectTypeID := pbtypes.GetString(st.Details(), bundle.RelationKeyTargetObjectType.String())
if objectTypeID != "" {
objectType, err := t.relationService.GetObjectType(objectTypeID)
objectType, err := t.systemObjectService.GetObjectType(objectTypeID)
if err != nil {
return nil, fmt.Errorf("get target object type: %w", err)
}

14
core/block/editor/template_test.go
View file

@ -13,7 +13,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/migration"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -31,19 +31,19 @@ func NewTemplateTest(t *testing.T, ctrl *gomock.Controller, templateName string)
objectStore := testMock.NewMockObjectStore(ctrl)
relationService := mock_relation.NewMockService(t)
relationService.EXPECT().GetObjectTypes(mock.Anything).Return(nil, nil).Maybe()
systemObjectService := mock_system_object.NewMockService(t)
systemObjectService.EXPECT().GetObjectTypes(mock.Anything).Return(nil, nil).Maybe()
templ := &Template{
Page: &Page{
SmartBlock: sb,
objectStore: objectStore,
relationService: relationService,
SmartBlock: sb,
objectStore: objectStore,
systemObjectService: systemObjectService,
},
}
uniqueKey, err := domain.NewUniqueKey(coresb.SmartBlockTypeObjectType, bundle.TypeKeyPage.String())
require.NoError(t, err)
relationService.EXPECT().GetObjectByUniqueKey(mock.Anything, uniqueKey).Return(&model.ObjectDetails{
systemObjectService.EXPECT().GetObjectByUniqueKey(mock.Anything, uniqueKey).Return(&model.ObjectDetails{
Details: &types.Struct{
Fields: map[string]*types.Value{
bundle.RelationKeyRecommendedLayout.String(): pbtypes.Int64(int64(model.ObjectType_basic)),

22
core/block/editor/widget.go
View file

@ -8,8 +8,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/editor/widget"
"github.com/anyproto/anytype-heart/core/block/migration"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
@ -27,23 +27,23 @@ type WidgetObject struct {
basic.Updatable
widget.Widget
relationService relation.Service
systemObjectService system_object.Service
}
func NewWidgetObject(
sb smartblock.SmartBlock,
objectStore objectstore.ObjectStore,
relationService relation.Service,
systemObjectService system_object.Service,
layoutConverter converter.LayoutConverter,
) *WidgetObject {
bs := basic.NewBasic(sb, objectStore, relationService, layoutConverter)
bs := basic.NewBasic(sb, objectStore, systemObjectService, layoutConverter)
return &WidgetObject{
SmartBlock: sb,
Movable: bs,
Updatable: bs,
IHistory: basic.NewHistory(sb),
Widget: widget.NewWidget(sb),
relationService: relationService,
SmartBlock: sb,
Movable: bs,
Updatable: bs,
IHistory: basic.NewHistory(sb),
Widget: widget.NewWidget(sb),
systemObjectService: systemObjectService,
}
}
@ -103,7 +103,7 @@ func (w *WidgetObject) StateMigrations() migration.Migrations {
{
Version: 2,
Proc: func(s *state.State) {
migrateSourcesInDataview(w, s, w.relationService)
migrateSourcesInDataview(w, s, w.systemObjectService)
},
},
})

6
core/block/editor/workspaces.go
View file

@ -11,7 +11,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/source"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/metrics"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -58,7 +58,7 @@ func NewWorkspace(
sb smartblock.SmartBlock,
objectStore objectstore.ObjectStore,
anytype core.Service,
relationService relation.Service,
systemObjectService system_object.Service,
sourceService source.Service,
modifier DetailsModifier,
sbtProvider typeprovider.SmartBlockTypeProvider,
@ -73,7 +73,7 @@ func NewWorkspace(
collectionKeyRelationOptions,
objectStore,
anytype,
relationService,
systemObjectService,
sourceService,
sbtProvider,
layoutConverter,

22
core/block/export/export.go
View file

@ -28,7 +28,7 @@ import (
"github.com/anyproto/anytype-heart/core/converter/pbjson"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -57,13 +57,13 @@ type Export interface {
}
type export struct {
blockService *block.Service
picker getblock.Picker
objectStore objectstore.ObjectStore
coreService core.Service
sbtProvider typeprovider.SmartBlockTypeProvider
fileService files.Service
relationService relation.Service
blockService *block.Service
picker getblock.Picker
objectStore objectstore.ObjectStore
coreService core.Service
sbtProvider typeprovider.SmartBlockTypeProvider
fileService files.Service
systemObjectService system_object.Service
}
func New() Export {
@ -77,7 +77,7 @@ func (e *export) Init(a *app.App) (err error) {
e.fileService = app.MustComponent[files.Service](a)
e.picker = app.MustComponent[getblock.Picker](a)
e.sbtProvider = app.MustComponent[typeprovider.SmartBlockTypeProvider](a)
e.relationService = app.MustComponent[relation.Service](a)
e.systemObjectService = app.MustComponent[system_object.Service](a)
return
}
@ -122,14 +122,14 @@ func (e *export) Export(ctx context.Context, req pb.RpcObjectListExportRequest)
if req.Format == pb.RpcObjectListExport_SVG {
format = dot.ExportFormatSVG
}
mc := dot.NewMultiConverter(format, e.sbtProvider, e.relationService)
mc := dot.NewMultiConverter(format, e.sbtProvider, e.systemObjectService)
mc.SetKnownDocs(docs)
var werr error
if succeed, werr = e.writeMultiDoc(ctx, mc, wr, docs, queue, req.IncludeFiles); werr != nil {
log.Warnf("can't export docs: %v", werr)
}
} else if req.Format == pb.RpcObjectListExport_GRAPH_JSON {
mc := graphjson.NewMultiConverter(e.sbtProvider, e.relationService)
mc := graphjson.NewMultiConverter(e.sbtProvider, e.systemObjectService)
mc.SetKnownDocs(docs)
var werr error
if succeed, werr = e.writeMultiDoc(ctx, mc, wr, docs, queue, req.IncludeFiles); werr != nil {

28
core/block/object/objectcreator/creator.go
View file

@ -17,8 +17,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/metrics"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
@ -50,16 +50,16 @@ type Service interface {
}
type Creator struct {
blockService BlockService
blockPicker block.Picker
objectStore objectstore.ObjectStore
collectionService CollectionService
relationService relation.Service
bookmark bookmark.Service
objectFactory *editor.ObjectFactory
app *app.App
sbtProvider typeprovider.SmartBlockTypeProvider
creator Service //nolint:unused
blockService BlockService
blockPicker block.Picker
objectStore objectstore.ObjectStore
collectionService CollectionService
systemObjectService system_object.Service
bookmark bookmark.Service
objectFactory *editor.ObjectFactory
app *app.App
sbtProvider typeprovider.SmartBlockTypeProvider
creator Service //nolint:unused
// TODO: remove it?
coreService core.Service
@ -81,7 +81,7 @@ func (c *Creator) Init(a *app.App) (err error) {
c.bookmark = a.MustComponent(bookmark.CName).(bookmark.Service)
c.objectFactory = app.MustComponent[*editor.ObjectFactory](a)
c.collectionService = app.MustComponent[CollectionService](a)
c.relationService = app.MustComponent[relation.Service](a)
c.systemObjectService = app.MustComponent[system_object.Service](a)
c.coreService = app.MustComponent[core.Service](a)
c.sbtProvider = app.MustComponent[typeprovider.SmartBlockTypeProvider](a)
c.app = a
@ -232,7 +232,7 @@ func (c *Creator) CreateSet(ctx context.Context, req *pb.RpcObjectCreateSetReque
if len(source) > 0 {
// todo: decide the behavior in case of empty source
if dvContent, dvSchema, err = dataview.BlockBySource(req.SpaceId, c.sbtProvider, c.relationService, source); err != nil {
if dvContent, dvSchema, err = dataview.BlockBySource(req.SpaceId, c.sbtProvider, c.systemObjectService, source); err != nil {
return
}

18
core/block/object/objectgraph/graph.go
View file

@ -6,8 +6,8 @@ import (
"github.com/opentracing/opentracing-go/log"
"github.com/samber/lo"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -35,11 +35,11 @@ type Service interface {
}
type Builder struct {
graphService Service //nolint:unused
relationService relation.Service
sbtProvider typeprovider.SmartBlockTypeProvider
coreService core.Service
objectStore objectstore.ObjectStore
graphService Service //nolint:unused
systemObjectService system_object.Service
sbtProvider typeprovider.SmartBlockTypeProvider
coreService core.Service
objectStore objectstore.ObjectStore
*app.App
}
@ -50,7 +50,7 @@ func NewBuilder() *Builder {
func (gr *Builder) Init(a *app.App) (err error) {
gr.sbtProvider = app.MustComponent[typeprovider.SmartBlockTypeProvider](a)
gr.relationService = app.MustComponent[relation.Service](a)
gr.systemObjectService = app.MustComponent[system_object.Service](a)
gr.objectStore = app.MustComponent[objectstore.ObjectStore](a)
gr.coreService = app.MustComponent[core.Service](a)
return nil
@ -116,7 +116,7 @@ func (gr *Builder) extractGraph(
}
func (gr *Builder) provideRelations(spaceID string) (relationutils.Relations, error) {
relations, err := gr.relationService.ListAllRelations(spaceID)
relations, err := gr.systemObjectService.ListAllRelations(spaceID)
return relations, err
}

2
core/block/object/objectgraph/graph_test.go
View file

@ -3,7 +3,7 @@ package objectgraph
import (
"testing"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
)

4
core/block/object/objectlink/dependent_objects_test.go
View file

@ -11,14 +11,14 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/util/pbtypes"
)
func newTestConverter(t *testing.T) KeyToIDConverter {
converter := mock_relation.NewMockService(t)
converter := mock_system_object.NewMockService(t)
converter.EXPECT().GetRelationIdByKey(mock.Anything, mock.Anything, mock.Anything).RunAndReturn(func(ctx context.Context, spaceId string, key bundle.RelationKey) (string, error) {
return fakeDerivedID(key.String()), nil
}).Maybe()

2
core/block/restriction/dataview_test.go
View file

@ -39,7 +39,7 @@ func TestService_DataviewRestrictions(t *testing.T) {
t.Run("ordinary objects don't have restrictions", func(t *testing.T) {
objectTypeID := "derivedFrom(page)"
s.relationServiceMock.EXPECT().HasObjectType(objectTypeID).Return(true, nil)
s.systemObjectServiceMock.EXPECT().HasObjectType(objectTypeID).Return(true, nil)
restrictions := s.GetRestrictions(
newRestrictionHolder(
smartblock.SmartBlockTypePage,

16
core/block/restriction/fixture_test.go
View file

@ -8,7 +8,7 @@ import (
"github.com/stretchr/testify/require"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore/mock_objectstore"
@ -19,8 +19,8 @@ import (
type fixture struct {
Service
objectStoreMock *mock_objectstore.MockObjectStore
relationServiceMock *mock_relation.MockService
objectStoreMock *mock_objectstore.MockObjectStore
systemObjectServiceMock *mock_system_object.MockService
}
func newFixture(t *testing.T) *fixture {
@ -30,19 +30,19 @@ func newFixture(t *testing.T) *fixture {
sbtProvider := mock_typeprovider.NewMockSmartBlockTypeProvider(t)
sbtProvider.EXPECT().Name().Return("sbtProvider")
relationService := mock_relation.NewMockService(t)
systemObjectService := mock_system_object.NewMockService(t)
a := &app.App{}
a.Register(objectStore)
a.Register(sbtProvider)
a.Register(testutil.PrepareMock(a, relationService))
a.Register(testutil.PrepareMock(a, systemObjectService))
s := New()
err := s.Init(a)
require.NoError(t, err)
return &fixture{
Service: s,
objectStoreMock: objectStore,
relationServiceMock: relationService,
Service: s,
objectStoreMock: objectStore,
systemObjectServiceMock: systemObjectService,
}
}

2
core/block/restriction/object.go
View file

@ -212,7 +212,7 @@ func (s *service) getObjectRestrictions(rh RestrictionHolder) (r ObjectRestricti
}
if !errors.Is(r.Check(model.Restrictions_Template), ErrRestricted) {
if ok, err := s.relationService.HasObjectType(rh.ObjectTypeID()); err != nil || !ok {
if ok, err := s.systemObjectService.HasObjectType(rh.ObjectTypeID()); err != nil || !ok {
r = append(r, model.Restrictions_Template)
}
}

6
core/block/restriction/object_test.go
View file

@ -14,7 +14,7 @@ import (
// TODO Use constructors instead for initializing restrictionHolder structures by hand. See givenObjectType and givenRelation
func TestService_ObjectRestrictionsById(t *testing.T) {
rest := newFixture(t)
rest.relationServiceMock.EXPECT().HasObjectType(mock.Anything).Return(false, nil)
rest.systemObjectServiceMock.EXPECT().HasObjectType(mock.Anything).Return(false, nil)
assert.ErrorIs(t, rest.GetRestrictions(&restrictionHolder{
sbType: coresb.SmartBlockTypeAnytypeProfile,
@ -93,8 +93,8 @@ func TestService_ObjectRestrictionsById(t *testing.T) {
// TODO Use constructors instead for initializing restrictionHolder structures by hand. See givenObjectType and givenRelation
func TestTemplateRestriction(t *testing.T) {
rs := newFixture(t)
rs.relationServiceMock.EXPECT().HasObjectType(bundle.TypeKeyPage.URL()).Return(false, nil)
rs.relationServiceMock.EXPECT().HasObjectType(bundle.TypeKeyContact.URL()).Return(true, nil)
rs.systemObjectServiceMock.EXPECT().HasObjectType(bundle.TypeKeyPage.URL()).Return(false, nil)
rs.systemObjectServiceMock.EXPECT().HasObjectType(bundle.TypeKeyContact.URL()).Return(true, nil)
assert.ErrorIs(t, rs.GetRestrictions(&restrictionHolder{
// id: "cannot make template from Template smartblock type",

10
core/block/restriction/service.go
View file

@ -7,7 +7,7 @@ import (
"github.com/anyproto/any-sync/app"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
"github.com/anyproto/anytype-heart/pkg/lib/logging"
@ -34,9 +34,9 @@ type Service interface {
}
type service struct {
sbtProvider typeprovider.SmartBlockTypeProvider
objectStore objectstore.ObjectStore
relationService relation.Service
sbtProvider typeprovider.SmartBlockTypeProvider
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
}
func New() Service {
@ -46,7 +46,7 @@ func New() Service {
func (s *service) Init(a *app.App) (err error) {
s.sbtProvider = app.MustComponent[typeprovider.SmartBlockTypeProvider](a)
s.objectStore = app.MustComponent[objectstore.ObjectStore](a)
s.relationService = app.MustComponent[relation.Service](a)
s.systemObjectService = app.MustComponent[system_object.Service](a)
return
}

36
core/block/service.go
View file

@ -34,9 +34,9 @@ import (
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/filestorage/filesync"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/syncstatus"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/metrics"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
@ -128,20 +128,20 @@ type builtinObjects interface {
}
type Service struct {
anytype core.Service
syncStatus syncstatus.Service
eventSender event.Sender
closed bool
linkPreview linkpreview.LinkPreview
process process.Service
app *app.App
source source.Service
objectStore objectstore.ObjectStore
restriction restriction.Service
bookmark bookmarksvc.Service
relationService relation.Service
cache ocache.OCache
indexer indexer
anytype core.Service
syncStatus syncstatus.Service
eventSender event.Sender
closed bool
linkPreview linkpreview.LinkPreview
process process.Service
app *app.App
source source.Service
objectStore objectstore.ObjectStore
restriction restriction.Service
bookmark bookmarksvc.Service
systemObjectService system_object.Service
cache ocache.OCache
indexer indexer
objectCreator objectCreator
objectFactory *editor.ObjectFactory
@ -184,7 +184,7 @@ func (s *Service) Init(a *app.App) (err error) {
s.objectStore = a.MustComponent(objectstore.CName).(objectstore.ObjectStore)
s.restriction = a.MustComponent(restriction.CName).(restriction.Service)
s.bookmark = a.MustComponent("bookmark-importer").(bookmarksvc.Service)
s.relationService = a.MustComponent(relation.CName).(relation.Service)
s.systemObjectService = a.MustComponent(system_object.CName).(system_object.Service)
s.objectCreator = a.MustComponent("objectCreator").(objectCreator)
s.spaceService = a.MustComponent(space.CName).(space.Service)
s.objectFactory = app.MustComponent[*editor.ObjectFactory](a)
@ -524,11 +524,11 @@ func (s *Service) installTemplatesForObjectType(spaceID string, typeKey bundle.T
}
func (s *Service) listInstalledTemplatesForType(spaceID string, typeKey bundle.TypeKey) (map[string]struct{}, error) {
templateTypeID, err := s.relationService.GetTypeIdByKey(context.Background(), spaceID, bundle.TypeKeyTemplate)
templateTypeID, err := s.systemObjectService.GetTypeIdByKey(context.Background(), spaceID, bundle.TypeKeyTemplate)
if err != nil {
return nil, fmt.Errorf("get template type id by key: %w", err)
}
targetObjectTypeID, err := s.relationService.GetTypeIdByKey(context.Background(), spaceID, typeKey)
targetObjectTypeID, err := s.systemObjectService.GetTypeIdByKey(context.Background(), spaceID, typeKey)
if err != nil {
return nil, fmt.Errorf("get type id by key: %w", err)
}

2
core/block/source/bundledobjecttype.go
View file

@ -9,7 +9,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"

2
core/block/source/bundledrelation.go
View file

@ -9,7 +9,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"

34
core/block/source/service.go
View file

@ -15,7 +15,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/addr"
@ -43,13 +43,13 @@ type Service interface {
}
type service struct {
coreService core.Service
sbtProvider typeprovider.SmartBlockTypeProvider
account accountservice.Service
fileStore filestore.FileStore
spaceService space.Service
fileService files.Service
relationService relation.Service
coreService core.Service
sbtProvider typeprovider.SmartBlockTypeProvider
account accountservice.Service
fileStore filestore.FileStore
spaceService space.Service
fileService files.Service
systemObjectService system_object.Service
objectStore objectstore.ObjectStore
@ -64,7 +64,7 @@ func (s *service) Init(a *app.App) (err error) {
s.account = a.MustComponent(accountservice.CName).(accountservice.Service)
s.fileStore = app.MustComponent[filestore.FileStore](a)
s.spaceService = app.MustComponent[space.Service](a)
s.relationService = app.MustComponent[relation.Service](a)
s.systemObjectService = app.MustComponent[system_object.Service](a)
s.fileService = app.MustComponent[files.Service](a)
s.objectStore = app.MustComponent[objectstore.ObjectStore](a)
@ -138,14 +138,14 @@ func (s *service) NewSource(ctx context.Context, id string, spaceID string, buil
return nil, err
}
deps := sourceDeps{
coreService: s.coreService,
accountService: s.account,
sbt: sbt,
ot: ot,
spaceService: s.spaceService,
sbtProvider: s.sbtProvider,
fileService: s.fileService,
relationService: s.relationService,
coreService: s.coreService,
accountService: s.account,
sbt: sbt,
ot: ot,
spaceService: s.spaceService,
sbtProvider: s.sbtProvider,
fileService: s.fileService,
systemObjectService: s.systemObjectService,
}
return newTreeSource(spaceID, id, deps)
}

48
core/block/source/source.go
View file

@ -18,7 +18,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -76,27 +76,27 @@ type sourceDeps struct {
sbt smartblock.SmartBlockType
ot objecttree.ObjectTree
coreService core.Service
accountService accountservice.Service
spaceService space.Service
sbtProvider typeprovider.SmartBlockTypeProvider
fileService files.Service
relationService relation.Service
coreService core.Service
accountService accountservice.Service
spaceService space.Service
sbtProvider typeprovider.SmartBlockTypeProvider
fileService files.Service
systemObjectService system_object.Service
}
func newTreeSource(spaceID string, id string, deps sourceDeps) (s Source, err error) {
return &source{
ObjectTree: deps.ot,
id: id,
spaceID: spaceID,
coreService: deps.coreService,
spaceService: deps.spaceService,
openedAt: time.Now(),
smartblockType: deps.sbt,
accountService: deps.accountService,
sbtProvider: deps.sbtProvider,
fileService: deps.fileService,
relationService: deps.relationService,
ObjectTree: deps.ot,
id: id,
spaceID: spaceID,
coreService: deps.coreService,
spaceService: deps.spaceService,
openedAt: time.Now(),
smartblockType: deps.sbt,
accountService: deps.accountService,
sbtProvider: deps.sbtProvider,
fileService: deps.fileService,
systemObjectService: deps.systemObjectService,
}, nil
}
@ -117,12 +117,12 @@ type source struct {
closed chan struct{}
openedAt time.Time
coreService core.Service
fileService files.Service
accountService accountservice.Service
spaceService space.Service
sbtProvider typeprovider.SmartBlockTypeProvider
relationService relation.Service
coreService core.Service
fileService files.Service
accountService accountservice.Service
spaceService space.Service
sbtProvider typeprovider.SmartBlockTypeProvider
systemObjectService system_object.Service
}
func (s *source) Tree() objecttree.ObjectTree {

40
core/converter/dot/dot.go
View file

@ -15,7 +15,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/object/objectlink"
"github.com/anyproto/anytype-heart/core/converter"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
@ -43,22 +43,22 @@ type linkInfo struct {
}
type dot struct {
graph *cgraph.Graph
graphviz *graphviz.Graphviz
knownDocs map[string]*types.Struct
fileHashes []string
imageHashes []string
exportFormat graphviz.Format
nodes map[string]*cgraph.Node
linksByNode map[string][]linkInfo
sbtProvider typeprovider.SmartBlockTypeProvider
relationService relation.Service
graph *cgraph.Graph
graphviz *graphviz.Graphviz
knownDocs map[string]*types.Struct
fileHashes []string
imageHashes []string
exportFormat graphviz.Format
nodes map[string]*cgraph.Node
linksByNode map[string][]linkInfo
sbtProvider typeprovider.SmartBlockTypeProvider
systemObjectService system_object.Service
}
func NewMultiConverter(
format graphviz.Format,
sbtProvider typeprovider.SmartBlockTypeProvider,
relationService relation.Service,
systemObjectService system_object.Service,
) converter.MultiConverter {
g := graphviz.New()
graph, err := g.Graph()
@ -67,13 +67,13 @@ func NewMultiConverter(
}
return &dot{
graph: graph,
graphviz: g,
exportFormat: format,
linksByNode: map[string][]linkInfo{},
nodes: map[string]*cgraph.Node{},
sbtProvider: sbtProvider,
relationService: relationService,
graph: graph,
graphviz: g,
exportFormat: format,
linksByNode: map[string][]linkInfo{},
nodes: map[string]*cgraph.Node{},
sbtProvider: sbtProvider,
systemObjectService: systemObjectService,
}
}
@ -120,7 +120,7 @@ func (d *dot) Add(st *state.State) error {
// TODO: add relations
dependentObjectIDs := objectlink.DependentObjectIDs(st, d.relationService, true, true, false, false, false)
dependentObjectIDs := objectlink.DependentObjectIDs(st, d.systemObjectService, true, true, false, false, false)
for _, depID := range dependentObjectIDs {
t, err := d.sbtProvider.Type(st.SpaceID(), depID)
if err != nil {

4
core/converter/dot/dot_notsupported.go
View file

@ -8,12 +8,12 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/converter"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/space/typeprovider"
)
func NewMultiConverter(format int, _ typeprovider.SmartBlockTypeProvider, _ relation.Service) converter.MultiConverter {
func NewMultiConverter(format int, _ typeprovider.SmartBlockTypeProvider, _ system_object.Service) converter.MultiConverter {
return &dot{}
}

18
core/converter/graphjson/graphjson.go
View file

@ -8,7 +8,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/object/objectlink"
"github.com/anyproto/anytype-heart/core/converter"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
@ -52,19 +52,19 @@ type graphjson struct {
nodes map[string]*Node
linksByNode map[string][]*Edge
sbtProvider typeprovider.SmartBlockTypeProvider
relationService relation.Service
sbtProvider typeprovider.SmartBlockTypeProvider
systemObjectService system_object.Service
}
func NewMultiConverter(
sbtProvider typeprovider.SmartBlockTypeProvider,
relationService relation.Service,
systemObjectService system_object.Service,
) converter.MultiConverter {
return &graphjson{
linksByNode: map[string][]*Edge{},
nodes: map[string]*Node{},
sbtProvider: sbtProvider,
relationService: relationService,
linksByNode: map[string][]*Edge{},
nodes: map[string]*Node{},
sbtProvider: sbtProvider,
systemObjectService: systemObjectService,
}
}
@ -95,7 +95,7 @@ func (g *graphjson) Add(st *state.State) error {
g.nodes[st.RootId()] = &n
// TODO: add relations
dependentObjectIDs := objectlink.DependentObjectIDs(st, g.relationService, true, true, false, false, false)
dependentObjectIDs := objectlink.DependentObjectIDs(st, g.systemObjectService, true, true, false, false, false)
for _, depID := range dependentObjectIDs {
t, err := g.sbtProvider.Type(st.SpaceID(), depID)
if err != nil {

16
core/core.go
View file

@ -13,7 +13,6 @@ import (
"github.com/anyproto/anytype-heart/core/block"
"github.com/anyproto/anytype-heart/core/block/collection"
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/wallet"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -65,13 +64,6 @@ func (mw *Middleware) getBlockService() (bs *block.Service, err error) {
return nil, ErrNotLoggedIn
}
func (mw *Middleware) getRelationService() (rs relation.Service, err error) {
if a := mw.applicationService.GetApp(); a != nil {
return a.MustComponent(relation.CName).(relation.Service), nil
}
return nil, ErrNotLoggedIn
}
func (mw *Middleware) getAccountService() (a space.Service, err error) {
if a := mw.applicationService.GetApp(); a != nil {
return a.MustComponent(space.CName).(space.Service), nil
@ -107,14 +99,6 @@ func requireApp(a *app.App) {
}
}
func (mw *Middleware) doRelationService(f func(rs relation.Service) error) (err error) {
rs, err := mw.getRelationService()
if err != nil {
return
}
return f(rs)
}
func (mw *Middleware) doAccountService(f func(a space.Service) error) (err error) {
bs, err := mw.getAccountService()
if err != nil {

18
core/history/history.go
View file

@ -16,7 +16,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/object/objectlink"
"github.com/anyproto/anytype-heart/core/block/source"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -48,18 +48,18 @@ type History interface {
}
type history struct {
a core.Service
picker block.Picker
objectStore objectstore.ObjectStore
relationService relation.Service
spaceService space.Service
a core.Service
picker block.Picker
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
spaceService space.Service
}
func (h *history) Init(a *app.App) (err error) {
h.a = a.MustComponent(core.CName).(core.Service)
h.picker = app.MustComponent[block.Picker](a)
h.objectStore = a.MustComponent(objectstore.CName).(objectstore.ObjectStore)
h.relationService = a.MustComponent(relation.CName).(relation.Service)
h.systemObjectService = a.MustComponent(system_object.CName).(system_object.Service)
h.spaceService = a.MustComponent(space.CName).(space.Service)
return
}
@ -73,7 +73,7 @@ func (h *history) Show(id domain.FullID, versionID string) (bs *model.ObjectView
if err != nil {
return
}
dependentObjectIDs := objectlink.DependentObjectIDs(s, h.relationService, true, true, false, true, false)
dependentObjectIDs := objectlink.DependentObjectIDs(s, h.systemObjectService, true, true, false, true, false)
// nolint:errcheck
metaD, _ := h.objectStore.QueryByID(dependentObjectIDs)
details := make([]*model.ObjectViewDetailsSet, 0, len(metaD))
@ -93,7 +93,7 @@ func (h *history) Show(id domain.FullID, versionID string) (bs *model.ObjectView
}
}
rels, _ := h.relationService.FetchRelationByLinks(id.SpaceID, s.PickRelationLinks())
rels, _ := h.systemObjectService.FetchRelationByLinks(id.SpaceID, s.PickRelationLinks())
return &model.ObjectView{
RootId: id.ObjectID,
Type: model.SmartBlockType(sbType),

12
core/kanban/service.go
View file

@ -8,7 +8,7 @@ import (
"github.com/anyproto/any-sync/app"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pkg/lib/database"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
@ -31,9 +31,9 @@ type Grouper interface {
}
type service struct {
objectStore objectstore.ObjectStore
groupColumns map[model.RelationFormat]func(string) Grouper
relationService relation.Service
objectStore objectstore.ObjectStore
groupColumns map[model.RelationFormat]func(string) Grouper
systemObjectService system_object.Service
}
func New() Service {
@ -42,7 +42,7 @@ func New() Service {
func (s *service) Init(a *app.App) (err error) {
s.objectStore = a.MustComponent(objectstore.CName).(objectstore.ObjectStore)
s.relationService = app.MustComponent[relation.Service](a)
s.systemObjectService = app.MustComponent[system_object.Service](a)
s.groupColumns[model.RelationFormat_status] = func(key string) Grouper {
return &GroupStatus{key: key, store: s.objectStore}
@ -62,7 +62,7 @@ func (s *service) Name() (name string) {
}
func (s *service) Grouper(spaceID string, key string) (Grouper, error) {
rel, err := s.relationService.FetchRelationByKey(spaceID, key)
rel, err := s.systemObjectService.FetchRelationByKey(spaceID, key)
if err != nil {
return nil, fmt.Errorf("can't get relation %s: %v", key, err)
}

14
core/kanban/service_test.go
View file

@ -12,8 +12,8 @@ import (
"github.com/stretchr/testify/require"
"github.com/anyproto/anytype-heart/core/anytype/config"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/core/wallet"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/database"
@ -34,12 +34,12 @@ func Test_GrouperTags(t *testing.T) {
tp.EXPECT().Name().Return("typeprovider")
tp.EXPECT().Init(a).Return(nil)
relationService := mock_relation.NewMockService(t)
relationService.EXPECT().Name().Return("relation")
relationService.EXPECT().Init(a).Return(nil)
systemObjectService := mock_system_object.NewMockService(t)
systemObjectService.EXPECT().Name().Return("relation")
systemObjectService.EXPECT().Init(a).Return(nil)
relationWithFormatTag := &relationutils.Relation{&model.Relation{Format: model.RelationFormat_tag}}
relationService.EXPECT().FetchRelationByKey("", "tag").Return(relationWithFormatTag, nil)
systemObjectService.EXPECT().FetchRelationByKey("", "tag").Return(relationWithFormatTag, nil)
ds := objectstore.New()
kanbanSrv := New()
@ -50,7 +50,7 @@ func Test_GrouperTags(t *testing.T) {
Register(ds).
Register(kanbanSrv).
Register(tp).
Register(relationService).
Register(systemObjectService).
Start(context.Background())
require.NoError(t, err)

791
core/relation/mock_relation/mock_Service.go
View file

@ -1,791 +0,0 @@
// Code generated by mockery v2.26.1. DO NOT EDIT.
package mock_relation
import (
context "context"
app "github.com/anyproto/any-sync/app"
mock "github.com/stretchr/testify/mock"
domain "github.com/anyproto/anytype-heart/core/domain"
relationutils "github.com/anyproto/anytype-heart/core/relation/relationutils"
bundle "github.com/anyproto/anytype-heart/pkg/lib/bundle"
model "github.com/anyproto/anytype-heart/pkg/lib/pb/model"
pbtypes "github.com/anyproto/anytype-heart/util/pbtypes"
)
// MockService is an autogenerated mock type for the Service type
type MockService struct {
mock.Mock
}
type MockService_Expecter struct {
mock *mock.Mock
}
func (_m *MockService) EXPECT() *MockService_Expecter {
return &MockService_Expecter{mock: &_m.Mock}
}
// FetchRelationByKey provides a mock function with given fields: spaceId, key
func (_m *MockService) FetchRelationByKey(spaceId string, key string) (*relationutils.Relation, error) {
ret := _m.Called(spaceId, key)
var r0 *relationutils.Relation
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*relationutils.Relation, error)); ok {
return rf(spaceId, key)
}
if rf, ok := ret.Get(0).(func(string, string) *relationutils.Relation); ok {
r0 = rf(spaceId, key)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*relationutils.Relation)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(spaceId, key)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_FetchRelationByKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchRelationByKey'
type MockService_FetchRelationByKey_Call struct {
*mock.Call
}
// FetchRelationByKey is a helper method to define mock.On call
// - spaceId string
// - key string
func (_e *MockService_Expecter) FetchRelationByKey(spaceId interface{}, key interface{}) *MockService_FetchRelationByKey_Call {
return &MockService_FetchRelationByKey_Call{Call: _e.mock.On("FetchRelationByKey", spaceId, key)}
}
func (_c *MockService_FetchRelationByKey_Call) Run(run func(spaceId string, key string)) *MockService_FetchRelationByKey_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string), args[1].(string))
})
return _c
}
func (_c *MockService_FetchRelationByKey_Call) Return(_a0 *relationutils.Relation, err error) *MockService_FetchRelationByKey_Call {
_c.Call.Return(_a0, err)
return _c
}
func (_c *MockService_FetchRelationByKey_Call) RunAndReturn(run func(string, string) (*relationutils.Relation, error)) *MockService_FetchRelationByKey_Call {
_c.Call.Return(run)
return _c
}
// FetchRelationByKeys provides a mock function with given fields: spaceId, keys
func (_m *MockService) FetchRelationByKeys(spaceId string, keys ...string) (relationutils.Relations, error) {
_va := make([]interface{}, len(keys))
for _i := range keys {
_va[_i] = keys[_i]
}
var _ca []interface{}
_ca = append(_ca, spaceId)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 relationutils.Relations
var r1 error
if rf, ok := ret.Get(0).(func(string, ...string) (relationutils.Relations, error)); ok {
return rf(spaceId, keys...)
}
if rf, ok := ret.Get(0).(func(string, ...string) relationutils.Relations); ok {
r0 = rf(spaceId, keys...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(relationutils.Relations)
}
}
if rf, ok := ret.Get(1).(func(string, ...string) error); ok {
r1 = rf(spaceId, keys...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_FetchRelationByKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchRelationByKeys'
type MockService_FetchRelationByKeys_Call struct {
*mock.Call
}
// FetchRelationByKeys is a helper method to define mock.On call
// - spaceId string
// - keys ...string
func (_e *MockService_Expecter) FetchRelationByKeys(spaceId interface{}, keys ...interface{}) *MockService_FetchRelationByKeys_Call {
return &MockService_FetchRelationByKeys_Call{Call: _e.mock.On("FetchRelationByKeys",
append([]interface{}{spaceId}, keys...)...)}
}
func (_c *MockService_FetchRelationByKeys_Call) Run(run func(spaceId string, keys ...string)) *MockService_FetchRelationByKeys_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]string, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(string)
}
}
run(args[0].(string), variadicArgs...)
})
return _c
}
func (_c *MockService_FetchRelationByKeys_Call) Return(relations relationutils.Relations, err error) *MockService_FetchRelationByKeys_Call {
_c.Call.Return(relations, err)
return _c
}
func (_c *MockService_FetchRelationByKeys_Call) RunAndReturn(run func(string, ...string) (relationutils.Relations, error)) *MockService_FetchRelationByKeys_Call {
_c.Call.Return(run)
return _c
}
// FetchRelationByLinks provides a mock function with given fields: spaceId, links
func (_m *MockService) FetchRelationByLinks(spaceId string, links pbtypes.RelationLinks) (relationutils.Relations, error) {
ret := _m.Called(spaceId, links)
var r0 relationutils.Relations
var r1 error
if rf, ok := ret.Get(0).(func(string, pbtypes.RelationLinks) (relationutils.Relations, error)); ok {
return rf(spaceId, links)
}
if rf, ok := ret.Get(0).(func(string, pbtypes.RelationLinks) relationutils.Relations); ok {
r0 = rf(spaceId, links)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(relationutils.Relations)
}
}
if rf, ok := ret.Get(1).(func(string, pbtypes.RelationLinks) error); ok {
r1 = rf(spaceId, links)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_FetchRelationByLinks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchRelationByLinks'
type MockService_FetchRelationByLinks_Call struct {
*mock.Call
}
// FetchRelationByLinks is a helper method to define mock.On call
// - spaceId string
// - links pbtypes.RelationLinks
func (_e *MockService_Expecter) FetchRelationByLinks(spaceId interface{}, links interface{}) *MockService_FetchRelationByLinks_Call {
return &MockService_FetchRelationByLinks_Call{Call: _e.mock.On("FetchRelationByLinks", spaceId, links)}
}
func (_c *MockService_FetchRelationByLinks_Call) Run(run func(spaceId string, links pbtypes.RelationLinks)) *MockService_FetchRelationByLinks_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string), args[1].(pbtypes.RelationLinks))
})
return _c
}
func (_c *MockService_FetchRelationByLinks_Call) Return(relations relationutils.Relations, err error) *MockService_FetchRelationByLinks_Call {
_c.Call.Return(relations, err)
return _c
}
func (_c *MockService_FetchRelationByLinks_Call) RunAndReturn(run func(string, pbtypes.RelationLinks) (relationutils.Relations, error)) *MockService_FetchRelationByLinks_Call {
_c.Call.Return(run)
return _c
}
// GetObjectByUniqueKey provides a mock function with given fields: spaceId, uniqueKey
func (_m *MockService) GetObjectByUniqueKey(spaceId string, uniqueKey domain.UniqueKey) (*model.ObjectDetails, error) {
ret := _m.Called(spaceId, uniqueKey)
var r0 *model.ObjectDetails
var r1 error
if rf, ok := ret.Get(0).(func(string, domain.UniqueKey) (*model.ObjectDetails, error)); ok {
return rf(spaceId, uniqueKey)
}
if rf, ok := ret.Get(0).(func(string, domain.UniqueKey) *model.ObjectDetails); ok {
r0 = rf(spaceId, uniqueKey)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ObjectDetails)
}
}
if rf, ok := ret.Get(1).(func(string, domain.UniqueKey) error); ok {
r1 = rf(spaceId, uniqueKey)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetObjectByUniqueKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectByUniqueKey'
type MockService_GetObjectByUniqueKey_Call struct {
*mock.Call
}
// GetObjectByUniqueKey is a helper method to define mock.On call
// - spaceId string
// - uniqueKey domain.UniqueKey
func (_e *MockService_Expecter) GetObjectByUniqueKey(spaceId interface{}, uniqueKey interface{}) *MockService_GetObjectByUniqueKey_Call {
return &MockService_GetObjectByUniqueKey_Call{Call: _e.mock.On("GetObjectByUniqueKey", spaceId, uniqueKey)}
}
func (_c *MockService_GetObjectByUniqueKey_Call) Run(run func(spaceId string, uniqueKey domain.UniqueKey)) *MockService_GetObjectByUniqueKey_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string), args[1].(domain.UniqueKey))
})
return _c
}
func (_c *MockService_GetObjectByUniqueKey_Call) Return(_a0 *model.ObjectDetails, _a1 error) *MockService_GetObjectByUniqueKey_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockService_GetObjectByUniqueKey_Call) RunAndReturn(run func(string, domain.UniqueKey) (*model.ObjectDetails, error)) *MockService_GetObjectByUniqueKey_Call {
_c.Call.Return(run)
return _c
}
// GetObjectType provides a mock function with given fields: url
func (_m *MockService) GetObjectType(url string) (*model.ObjectType, error) {
ret := _m.Called(url)
var r0 *model.ObjectType
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.ObjectType, error)); ok {
return rf(url)
}
if rf, ok := ret.Get(0).(func(string) *model.ObjectType); ok {
r0 = rf(url)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ObjectType)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(url)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetObjectType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectType'
type MockService_GetObjectType_Call struct {
*mock.Call
}
// GetObjectType is a helper method to define mock.On call
// - url string
func (_e *MockService_Expecter) GetObjectType(url interface{}) *MockService_GetObjectType_Call {
return &MockService_GetObjectType_Call{Call: _e.mock.On("GetObjectType", url)}
}
func (_c *MockService_GetObjectType_Call) Run(run func(url string)) *MockService_GetObjectType_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string))
})
return _c
}
func (_c *MockService_GetObjectType_Call) Return(_a0 *model.ObjectType, _a1 error) *MockService_GetObjectType_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockService_GetObjectType_Call) RunAndReturn(run func(string) (*model.ObjectType, error)) *MockService_GetObjectType_Call {
_c.Call.Return(run)
return _c
}
// GetObjectTypes provides a mock function with given fields: urls
func (_m *MockService) GetObjectTypes(urls []string) ([]*model.ObjectType, error) {
ret := _m.Called(urls)
var r0 []*model.ObjectType
var r1 error
if rf, ok := ret.Get(0).(func([]string) ([]*model.ObjectType, error)); ok {
return rf(urls)
}
if rf, ok := ret.Get(0).(func([]string) []*model.ObjectType); ok {
r0 = rf(urls)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ObjectType)
}
}
if rf, ok := ret.Get(1).(func([]string) error); ok {
r1 = rf(urls)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetObjectTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTypes'
type MockService_GetObjectTypes_Call struct {
*mock.Call
}
// GetObjectTypes is a helper method to define mock.On call
// - urls []string
func (_e *MockService_Expecter) GetObjectTypes(urls interface{}) *MockService_GetObjectTypes_Call {
return &MockService_GetObjectTypes_Call{Call: _e.mock.On("GetObjectTypes", urls)}
}
func (_c *MockService_GetObjectTypes_Call) Run(run func(urls []string)) *MockService_GetObjectTypes_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].([]string))
})
return _c
}
func (_c *MockService_GetObjectTypes_Call) Return(ots []*model.ObjectType, err error) *MockService_GetObjectTypes_Call {
_c.Call.Return(ots, err)
return _c
}
func (_c *MockService_GetObjectTypes_Call) RunAndReturn(run func([]string) ([]*model.ObjectType, error)) *MockService_GetObjectTypes_Call {
_c.Call.Return(run)
return _c
}
// GetRelationByID provides a mock function with given fields: id
func (_m *MockService) GetRelationByID(id string) (*model.Relation, error) {
ret := _m.Called(id)
var r0 *model.Relation
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.Relation, error)); ok {
return rf(id)
}
if rf, ok := ret.Get(0).(func(string) *model.Relation); ok {
r0 = rf(id)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Relation)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(id)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetRelationByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRelationByID'
type MockService_GetRelationByID_Call struct {
*mock.Call
}
// GetRelationByID is a helper method to define mock.On call
// - id string
func (_e *MockService_Expecter) GetRelationByID(id interface{}) *MockService_GetRelationByID_Call {
return &MockService_GetRelationByID_Call{Call: _e.mock.On("GetRelationByID", id)}
}
func (_c *MockService_GetRelationByID_Call) Run(run func(id string)) *MockService_GetRelationByID_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string))
})
return _c
}
func (_c *MockService_GetRelationByID_Call) Return(_a0 *model.Relation, err error) *MockService_GetRelationByID_Call {
_c.Call.Return(_a0, err)
return _c
}
func (_c *MockService_GetRelationByID_Call) RunAndReturn(run func(string) (*model.Relation, error)) *MockService_GetRelationByID_Call {
_c.Call.Return(run)
return _c
}
// GetRelationByKey provides a mock function with given fields: key
func (_m *MockService) GetRelationByKey(key string) (*model.Relation, error) {
ret := _m.Called(key)
var r0 *model.Relation
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.Relation, error)); ok {
return rf(key)
}
if rf, ok := ret.Get(0).(func(string) *model.Relation); ok {
r0 = rf(key)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Relation)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(key)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetRelationByKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRelationByKey'
type MockService_GetRelationByKey_Call struct {
*mock.Call
}
// GetRelationByKey is a helper method to define mock.On call
// - key string
func (_e *MockService_Expecter) GetRelationByKey(key interface{}) *MockService_GetRelationByKey_Call {
return &MockService_GetRelationByKey_Call{Call: _e.mock.On("GetRelationByKey", key)}
}
func (_c *MockService_GetRelationByKey_Call) Run(run func(key string)) *MockService_GetRelationByKey_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string))
})
return _c
}
func (_c *MockService_GetRelationByKey_Call) Return(_a0 *model.Relation, err error) *MockService_GetRelationByKey_Call {
_c.Call.Return(_a0, err)
return _c
}
func (_c *MockService_GetRelationByKey_Call) RunAndReturn(run func(string) (*model.Relation, error)) *MockService_GetRelationByKey_Call {
_c.Call.Return(run)
return _c
}
// GetRelationIdByKey provides a mock function with given fields: ctx, spaceId, key
func (_m *MockService) GetRelationIdByKey(ctx context.Context, spaceId string, key bundle.RelationKey) (string, error) {
ret := _m.Called(ctx, spaceId, key)
var r0 string
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, bundle.RelationKey) (string, error)); ok {
return rf(ctx, spaceId, key)
}
if rf, ok := ret.Get(0).(func(context.Context, string, bundle.RelationKey) string); ok {
r0 = rf(ctx, spaceId, key)
} else {
r0 = ret.Get(0).(string)
}
if rf, ok := ret.Get(1).(func(context.Context, string, bundle.RelationKey) error); ok {
r1 = rf(ctx, spaceId, key)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetRelationIdByKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRelationIdByKey'
type MockService_GetRelationIdByKey_Call struct {
*mock.Call
}
// GetRelationIdByKey is a helper method to define mock.On call
// - ctx context.Context
// - spaceId string
// - key bundle.RelationKey
func (_e *MockService_Expecter) GetRelationIdByKey(ctx interface{}, spaceId interface{}, key interface{}) *MockService_GetRelationIdByKey_Call {
return &MockService_GetRelationIdByKey_Call{Call: _e.mock.On("GetRelationIdByKey", ctx, spaceId, key)}
}
func (_c *MockService_GetRelationIdByKey_Call) Run(run func(ctx context.Context, spaceId string, key bundle.RelationKey)) *MockService_GetRelationIdByKey_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(bundle.RelationKey))
})
return _c
}
func (_c *MockService_GetRelationIdByKey_Call) Return(id string, err error) *MockService_GetRelationIdByKey_Call {
_c.Call.Return(id, err)
return _c
}
func (_c *MockService_GetRelationIdByKey_Call) RunAndReturn(run func(context.Context, string, bundle.RelationKey) (string, error)) *MockService_GetRelationIdByKey_Call {
_c.Call.Return(run)
return _c
}
// GetTypeIdByKey provides a mock function with given fields: ctx, spaceId, key
func (_m *MockService) GetTypeIdByKey(ctx context.Context, spaceId string, key bundle.TypeKey) (string, error) {
ret := _m.Called(ctx, spaceId, key)
var r0 string
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, bundle.TypeKey) (string, error)); ok {
return rf(ctx, spaceId, key)
}
if rf, ok := ret.Get(0).(func(context.Context, string, bundle.TypeKey) string); ok {
r0 = rf(ctx, spaceId, key)
} else {
r0 = ret.Get(0).(string)
}
if rf, ok := ret.Get(1).(func(context.Context, string, bundle.TypeKey) error); ok {
r1 = rf(ctx, spaceId, key)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_GetTypeIdByKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTypeIdByKey'
type MockService_GetTypeIdByKey_Call struct {
*mock.Call
}
// GetTypeIdByKey is a helper method to define mock.On call
// - ctx context.Context
// - spaceId string
// - key bundle.TypeKey
func (_e *MockService_Expecter) GetTypeIdByKey(ctx interface{}, spaceId interface{}, key interface{}) *MockService_GetTypeIdByKey_Call {
return &MockService_GetTypeIdByKey_Call{Call: _e.mock.On("GetTypeIdByKey", ctx, spaceId, key)}
}
func (_c *MockService_GetTypeIdByKey_Call) Run(run func(ctx context.Context, spaceId string, key bundle.TypeKey)) *MockService_GetTypeIdByKey_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(bundle.TypeKey))
})
return _c
}
func (_c *MockService_GetTypeIdByKey_Call) Return(id string, err error) *MockService_GetTypeIdByKey_Call {
_c.Call.Return(id, err)
return _c
}
func (_c *MockService_GetTypeIdByKey_Call) RunAndReturn(run func(context.Context, string, bundle.TypeKey) (string, error)) *MockService_GetTypeIdByKey_Call {
_c.Call.Return(run)
return _c
}
// HasObjectType provides a mock function with given fields: id
func (_m *MockService) HasObjectType(id string) (bool, error) {
ret := _m.Called(id)
var r0 bool
var r1 error
if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
return rf(id)
}
if rf, ok := ret.Get(0).(func(string) bool); ok {
r0 = rf(id)
} else {
r0 = ret.Get(0).(bool)
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(id)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_HasObjectType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasObjectType'
type MockService_HasObjectType_Call struct {
*mock.Call
}
// HasObjectType is a helper method to define mock.On call
// - id string
func (_e *MockService_Expecter) HasObjectType(id interface{}) *MockService_HasObjectType_Call {
return &MockService_HasObjectType_Call{Call: _e.mock.On("HasObjectType", id)}
}
func (_c *MockService_HasObjectType_Call) Run(run func(id string)) *MockService_HasObjectType_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string))
})
return _c
}
func (_c *MockService_HasObjectType_Call) Return(_a0 bool, _a1 error) *MockService_HasObjectType_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockService_HasObjectType_Call) RunAndReturn(run func(string) (bool, error)) *MockService_HasObjectType_Call {
_c.Call.Return(run)
return _c
}
// Init provides a mock function with given fields: a
func (_m *MockService) Init(a *app.App) error {
ret := _m.Called(a)
var r0 error
if rf, ok := ret.Get(0).(func(*app.App) error); ok {
r0 = rf(a)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockService_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
type MockService_Init_Call struct {
*mock.Call
}
// Init is a helper method to define mock.On call
// - a *app.App
func (_e *MockService_Expecter) Init(a interface{}) *MockService_Init_Call {
return &MockService_Init_Call{Call: _e.mock.On("Init", a)}
}
func (_c *MockService_Init_Call) Run(run func(a *app.App)) *MockService_Init_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(*app.App))
})
return _c
}
func (_c *MockService_Init_Call) Return(err error) *MockService_Init_Call {
_c.Call.Return(err)
return _c
}
func (_c *MockService_Init_Call) RunAndReturn(run func(*app.App) error) *MockService_Init_Call {
_c.Call.Return(run)
return _c
}
// ListAllRelations provides a mock function with given fields: spaceId
func (_m *MockService) ListAllRelations(spaceId string) (relationutils.Relations, error) {
ret := _m.Called(spaceId)
var r0 relationutils.Relations
var r1 error
if rf, ok := ret.Get(0).(func(string) (relationutils.Relations, error)); ok {
return rf(spaceId)
}
if rf, ok := ret.Get(0).(func(string) relationutils.Relations); ok {
r0 = rf(spaceId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(relationutils.Relations)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(spaceId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockService_ListAllRelations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAllRelations'
type MockService_ListAllRelations_Call struct {
*mock.Call
}
// ListAllRelations is a helper method to define mock.On call
// - spaceId string
func (_e *MockService_Expecter) ListAllRelations(spaceId interface{}) *MockService_ListAllRelations_Call {
return &MockService_ListAllRelations_Call{Call: _e.mock.On("ListAllRelations", spaceId)}
}
func (_c *MockService_ListAllRelations_Call) Run(run func(spaceId string)) *MockService_ListAllRelations_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string))
})
return _c
}
func (_c *MockService_ListAllRelations_Call) Return(relations relationutils.Relations, err error) *MockService_ListAllRelations_Call {
_c.Call.Return(relations, err)
return _c
}
func (_c *MockService_ListAllRelations_Call) RunAndReturn(run func(string) (relationutils.Relations, error)) *MockService_ListAllRelations_Call {
_c.Call.Return(run)
return _c
}
// Name provides a mock function with given fields:
func (_m *MockService) Name() string {
ret := _m.Called()
var r0 string
if rf, ok := ret.Get(0).(func() string); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(string)
}
return r0
}
// MockService_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'
type MockService_Name_Call struct {
*mock.Call
}
// Name is a helper method to define mock.On call
func (_e *MockService_Expecter) Name() *MockService_Name_Call {
return &MockService_Name_Call{Call: _e.mock.On("Name")}
}
func (_c *MockService_Name_Call) Run(run func()) *MockService_Name_Call {
_c.Call.Run(func(args mock.Arguments) {
run()
})
return _c
}
func (_c *MockService_Name_Call) Return(name string) *MockService_Name_Call {
_c.Call.Return(name)
return _c
}
func (_c *MockService_Name_Call) RunAndReturn(run func() string) *MockService_Name_Call {
_c.Call.Return(run)
return _c
}
type mockConstructorTestingTNewMockService interface {
mock.TestingT
Cleanup(func())
}
// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewMockService(t mockConstructorTestingTNewMockService) *MockService {
mock := &MockService{}
mock.Mock.Test(t)
t.Cleanup(func() { mock.AssertExpectations(t) })
return mock
}

16
core/relations.go
View file

@ -10,7 +10,7 @@ import (
"github.com/gogo/protobuf/types"
"github.com/anyproto/anytype-heart/core/block"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/addr"
@ -32,8 +32,8 @@ func (mw *Middleware) ObjectTypeRelationList(cctx context.Context, req *pb.RpcOb
return response(pb.RpcObjectTypeRelationListResponseError_BAD_INPUT, nil, fmt.Errorf("account must be started"))
}
relationService := app.MustComponent[relation.Service](mw.applicationService.GetApp())
objType, err := relationService.GetObjectType(req.ObjectTypeUrl)
systemObjectService := app.MustComponent[system_object.Service](mw.applicationService.GetApp())
objType, err := systemObjectService.GetObjectType(req.ObjectTypeUrl)
if err != nil {
if err == block.ErrUnknownObjectType {
return response(pb.RpcObjectTypeRelationListResponseError_UNKNOWN_OBJECT_TYPE_URL, nil, err)
@ -55,10 +55,8 @@ func (mw *Middleware) ObjectTypeRelationAdd(cctx context.Context, req *pb.RpcObj
return m
}
rs, err := mw.getRelationService()
if err != nil {
return response(pb.RpcObjectTypeRelationAddResponseError_UNKNOWN_ERROR, err)
}
systemObjectService := getService[system_object.Service](mw)
at := mw.GetAnytype()
if at == nil {
return response(pb.RpcObjectTypeRelationAddResponseError_BAD_INPUT, fmt.Errorf("account must be started"))
@ -68,7 +66,7 @@ func (mw *Middleware) ObjectTypeRelationAdd(cctx context.Context, req *pb.RpcObj
return response(pb.RpcObjectTypeRelationAddResponseError_READONLY_OBJECT_TYPE, fmt.Errorf("can't modify bundled object type"))
}
err = mw.doBlockService(func(bs *block.Service) (err error) {
err := mw.doBlockService(func(bs *block.Service) (err error) {
spaceId, err := bs.ResolveSpaceID(req.ObjectTypeUrl)
if err != nil {
return err
@ -78,7 +76,7 @@ func (mw *Middleware) ObjectTypeRelationAdd(cctx context.Context, req *pb.RpcObj
list := pbtypes.GetStringList(current, bundle.RelationKeyRecommendedRelations.String())
for _, relKey := range req.RelationKeys {
relId, err := rs.GetRelationIdByKey(cctx, spaceId, bundle.RelationKey(relKey))
relId, err := systemObjectService.GetRelationIdByKey(cctx, spaceId, bundle.RelationKey(relKey))
if err != nil {
return nil, err
}

2
core/subscription/dep.go
View file

@ -113,7 +113,7 @@ func (ds *dependencyService) isRelationObject(key string) bool {
if isObj, ok := ds.isRelationObjMap[key]; ok {
return isObj
}
rel, err := ds.s.relationService.GetRelationByKey(key)
rel, err := ds.s.systemObjectService.GetRelationByKey(key)
if err != nil {
log.Errorf("can't get relation %s: %v", key, err)
return false

56
core/subscription/fixture_test.go
View file

@ -15,7 +15,7 @@ import (
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/event/mock_event"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
"github.com/anyproto/anytype-heart/space/typeprovider/mock_typeprovider"
@ -36,12 +36,12 @@ func (c *collectionServiceMock) UnsubscribeFromCollection(collectionID string, s
type fixture struct {
Service
a *app.App
ctrl *gomock.Controller
store *testMock.MockObjectStore
relationService *mock_relation.MockService
sender *mock_event.MockSender
events []*pb.Event
a *app.App
ctrl *gomock.Controller
store *testMock.MockObjectStore
systemObjectService *mock_system_object.MockService
sender *mock_event.MockSender
events []*pb.Event
}
func newFixture(t *testing.T) *fixture {
@ -55,14 +55,14 @@ func newFixture(t *testing.T) *fixture {
sbtProvider.EXPECT().Init(mock.Anything).Return(nil)
a.Register(sbtProvider)
relationService := mock_relation.NewMockService(t)
a.Register(testutil.PrepareMock(a, relationService))
systemObjectService := mock_system_object.NewMockService(t)
a.Register(testutil.PrepareMock(a, systemObjectService))
fx := &fixture{
Service: New(),
a: a,
ctrl: ctrl,
store: a.MustComponent(objectstore.CName).(*testMock.MockObjectStore),
relationService: relationService,
Service: New(),
a: a,
ctrl: ctrl,
store: a.MustComponent(objectstore.CName).(*testMock.MockObjectStore),
systemObjectService: systemObjectService,
}
sender := mock_event.NewMockSender(t)
sender.EXPECT().Init(mock.Anything).Return(nil)
@ -81,13 +81,13 @@ func newFixture(t *testing.T) *fixture {
type fixtureRealStore struct {
Service
a *app.App
ctrl *gomock.Controller
store *objectstore.StoreFixture
sender *mock_event.MockSender
eventsLock sync.Mutex
events []pb.IsEventMessageValue
relationServiceMock *mock_relation.MockService
a *app.App
ctrl *gomock.Controller
store *objectstore.StoreFixture
sender *mock_event.MockSender
eventsLock sync.Mutex
events []pb.IsEventMessageValue
systemObjectServiceMock *mock_system_object.MockService
}
func newFixtureWithRealObjectStore(t *testing.T) *fixtureRealStore {
@ -101,14 +101,14 @@ func newFixtureWithRealObjectStore(t *testing.T) *fixtureRealStore {
sbtProvider.EXPECT().Name().Return("smartBlockTypeProvider")
sbtProvider.EXPECT().Init(mock.Anything).Return(nil)
a.Register(sbtProvider)
relationService := mock_relation.NewMockService(t)
a.Register(testutil.PrepareMock(a, relationService))
systemObjectService := mock_system_object.NewMockService(t)
a.Register(testutil.PrepareMock(a, systemObjectService))
fx := &fixtureRealStore{
Service: New(),
a: a,
ctrl: ctrl,
store: store,
relationServiceMock: relationService,
Service: New(),
a: a,
ctrl: ctrl,
store: store,
systemObjectServiceMock: systemObjectService,
}
sender := mock_event.NewMockSender(t)
sender.EXPECT().Init(mock.Anything).Return(nil)

16
core/subscription/service.go
View file

@ -14,8 +14,8 @@ import (
"github.com/anyproto/anytype-heart/core/event"
"github.com/anyproto/anytype-heart/core/kanban"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/session"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -70,12 +70,12 @@ type service struct {
subscriptions map[string]subscription
recBatch *mb.MB
objectStore objectstore.ObjectStore
relationService relation.Service
kanban kanban.Service
collectionService CollectionService
sbtProvider typeprovider.SmartBlockTypeProvider
eventSender event.Sender
objectStore objectstore.ObjectStore
systemObjectService system_object.Service
kanban kanban.Service
collectionService CollectionService
sbtProvider typeprovider.SmartBlockTypeProvider
eventSender event.Sender
m sync.Mutex
ctxBuf *opCtx
@ -91,7 +91,7 @@ func (s *service) Init(a *app.App) (err error) {
s.collectionService = app.MustComponent[CollectionService](a)
s.sbtProvider = app.MustComponent[typeprovider.SmartBlockTypeProvider](a)
s.eventSender = a.MustComponent(event.CName).(event.Sender)
s.relationService = app.MustComponent[relation.Service](a)
s.systemObjectService = app.MustComponent[system_object.Service](a)
s.ctxBuf = &opCtx{c: s.cache}
return
}

14
core/subscription/service_test.go
View file

@ -31,11 +31,11 @@ func TestService_Search(t *testing.T) {
},
nil,
)
fx.relationService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
fx.systemObjectService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
Key: bundle.RelationKeyName.String(),
Format: model.RelationFormat_shorttext,
}, nil).Maybe()
fx.relationService.EXPECT().GetRelationByKey(bundle.RelationKeyAuthor.String()).Return(&model.Relation{
fx.systemObjectService.EXPECT().GetRelationByKey(bundle.RelationKeyAuthor.String()).Return(&model.Relation{
Key: bundle.RelationKeyAuthor.String(),
Format: model.RelationFormat_object,
}, nil).Maybe()
@ -134,11 +134,11 @@ func TestService_Search(t *testing.T) {
},
nil,
)
fx.relationService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
fx.systemObjectService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
Key: bundle.RelationKeyName.String(),
Format: model.RelationFormat_shorttext,
}, nil).Maybe()
fx.relationService.EXPECT().GetRelationByKey(bundle.RelationKeyAuthor.String()).Return(&model.Relation{
fx.systemObjectService.EXPECT().GetRelationByKey(bundle.RelationKeyAuthor.String()).Return(&model.Relation{
Key: bundle.RelationKeyAuthor.String(),
Format: model.RelationFormat_object,
}, nil).Maybe()
@ -193,7 +193,7 @@ func TestService_Search(t *testing.T) {
},
nil,
)
fx.relationService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
fx.systemObjectService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
Key: bundle.RelationKeyName.String(),
Format: model.RelationFormat_shorttext,
}, nil).Maybe()
@ -260,7 +260,7 @@ func TestService_Search(t *testing.T) {
},
nil,
)
fx.relationService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
fx.systemObjectService.EXPECT().GetRelationByKey(bundle.RelationKeyName.String()).Return(&model.Relation{
Key: bundle.RelationKeyName.String(),
Format: model.RelationFormat_shorttext,
}, nil).Maybe()
@ -361,7 +361,7 @@ func (c *collectionServiceMock) Init(a *app.App) error { return nil }
func testCreateSubscriptionWithNestedFilter(t *testing.T) *fixtureRealStore {
fx := newFixtureWithRealObjectStore(t)
fx.relationServiceMock.EXPECT().GetRelationByKey(mock.Anything).Return(&model.Relation{}, nil)
fx.systemObjectServiceMock.EXPECT().GetRelationByKey(mock.Anything).Return(&model.Relation{}, nil)
resp, err := fx.Search(pb.RpcObjectSearchSubscribeRequest{
SubId: "test",
Filters: []*model.BlockContentDataviewFilter{

4
core/relation/object_types.go → core/system_object/object_types.go
View file

@ -1,4 +1,4 @@
package relation
package system_object
import (
"fmt"
@ -7,7 +7,7 @@ import (
"github.com/gogo/protobuf/types"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/addr"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"

4
core/relation/relations.go → core/system_object/relations.go
View file

@ -1,11 +1,11 @@
package relation
package system_object
import (
"fmt"
ds "github.com/ipfs/go-datastore"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/database"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"

0
core/relation/relationutils/objecttype.go → core/system_object/relationutils/objecttype.go
View file

0
core/relation/relationutils/option.go → core/system_object/relationutils/option.go
View file

0
core/relation/relationutils/relation.go → core/system_object/relationutils/relation.go
View file

4
core/relation/service.go → core/system_object/service.go
View file

@ -1,4 +1,4 @@
package relation
package system_object
import (
"context"
@ -8,7 +8,7 @@ import (
"github.com/anyproto/any-sync/app"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"

4
core/relation/service_test.go → core/system_object/service_test.go
View file

@ -1,4 +1,4 @@
package relation
package system_object
import (
"testing"
@ -8,7 +8,7 @@ import (
"github.com/stretchr/testify/require"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/mock_core"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"

2
pkg/lib/database/database.go
View file

@ -9,7 +9,7 @@ import (
"github.com/ipfs/go-datastore/query"
"github.com/samber/lo"
"github.com/anyproto/anytype-heart/core/relation/relationutils"
"github.com/anyproto/anytype-heart/core/system_object/relationutils"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/logging"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"

18
util/builtinobjects/builtinobjects.go
View file

@ -15,7 +15,7 @@ import (
"github.com/anyproto/anytype-heart/core/block"
importer "github.com/anyproto/anytype-heart/core/block/import"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/relation"
"github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
@ -71,12 +71,12 @@ type BuiltinObjects interface {
}
type builtinObjects struct {
service *block.Service
coreService core.Service
importer importer.Importer
store objectstore.ObjectStore
tempDirService core.TempDirProvider
relationService relation.Service
service *block.Service
coreService core.Service
importer importer.Importer
store objectstore.ObjectStore
tempDirService core.TempDirProvider
systemObjectService system_object.Service
}
func New() BuiltinObjects {
@ -89,7 +89,7 @@ func (b *builtinObjects) Init(a *app.App) (err error) {
b.importer = a.MustComponent(importer.CName).(importer.Importer)
b.store = app.MustComponent[objectstore.ObjectStore](a)
b.tempDirService = app.MustComponent[core.TempDirProvider](a)
b.relationService = app.MustComponent[relation.Service](a)
b.systemObjectService = app.MustComponent[system_object.Service](a)
return
}
@ -321,7 +321,7 @@ func (b *builtinObjects) createNotesAndTaskTrackerWidgets(ctx context.Context, s
}
func (b *builtinObjects) getSetIDByObjectTypeKey(spaceID string, objectTypeKey bundle.TypeKey) (string, error) {
objectTypeID, err := b.relationService.GetTypeIdByKey(context.Background(), spaceID, objectTypeKey)
objectTypeID, err := b.systemObjectService.GetTypeIdByKey(context.Background(), spaceID, objectTypeKey)
if err != nil {
return "", fmt.Errorf("get type id by key '%s': %s", objectTypeKey, err)
}

14
util/builtintemplate/builtintemplate.go
View file

@ -18,7 +18,7 @@ import (
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/block/simple/relation"
"github.com/anyproto/anytype-heart/core/block/source"
relation_service "github.com/anyproto/anytype-heart/core/relation"
relation_service "github.com/anyproto/anytype-heart/core/system_object"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
@ -44,16 +44,16 @@ type BuiltinTemplate interface {
}
type builtinTemplate struct {
source source.Service
objectStore objectstore.ObjectStore
relationService relation_service.Service
generatedHash string
source source.Service
objectStore objectstore.ObjectStore
systemObjectService relation_service.Service
generatedHash string
}
func (b *builtinTemplate) Init(a *app.App) (err error) {
b.source = app.MustComponent[source.Service](a)
b.objectStore = app.MustComponent[objectstore.ObjectStore](a)
b.relationService = app.MustComponent[relation_service.Service](a)
b.systemObjectService = app.MustComponent[relation_service.Service](a)
b.makeGenHash(4)
return
@ -150,7 +150,7 @@ func (b *builtinTemplate) setObjectTypes(st *state.State) error {
// todo: remove this hack after fixing bundled templates
targetObjectTypeKey = bundle.TypeKey(strings.TrimPrefix(targetObjectTypeID, addr.BundledObjectTypeURLPrefix))
} else {
targetObjectType, err := b.relationService.GetObjectType(targetObjectTypeID)
targetObjectType, err := b.systemObjectService.GetObjectType(targetObjectTypeID)
if err != nil {
return fmt.Errorf("get object type %s: %w", targetObjectTypeID, err)
}

6
util/builtintemplate/builtintemplate_test.go
View file

@ -9,7 +9,7 @@ import (
"go.uber.org/mock/gomock"
"github.com/anyproto/anytype-heart/core/anytype/config"
"github.com/anyproto/anytype-heart/core/relation/mock_relation"
"github.com/anyproto/anytype-heart/core/system_object/mock_system_object"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore/mock_objectstore"
"github.com/anyproto/anytype-heart/tests/testutil"
"github.com/anyproto/anytype-heart/util/testMock/mockSource"
@ -24,7 +24,7 @@ func Test_registerBuiltin(t *testing.T) {
sourceService.EXPECT().RegisterStaticSource(gomock.Any(), gomock.Any()).AnyTimes()
objectStore := mock_objectstore.NewMockObjectStore(t)
relationService := mock_relation.NewMockService(t)
systemObjectService := mock_system_object.NewMockService(t)
builtInTemplates := New()
@ -33,7 +33,7 @@ func Test_registerBuiltin(t *testing.T) {
a.Register(builtInTemplates)
a.Register(config.New())
a.Register(testutil.PrepareMock(a, objectStore))
a.Register(testutil.PrepareMock(a, relationService))
a.Register(testutil.PrepareMock(a, systemObjectService))
err := builtInTemplates.Init(a)
assert.NoError(t, err)