GO-3800: tag as object

core/block/editor/converter/layout.go

@@ -97,6 +97,10 @@ func (c *layoutConverter) Convert(space smartblock.Space, st *state.State, fromL
 
 	// TODO We need more granular cases (not catch-all)
 
+	if toLayout == model.ObjectType_tag {
+		return c.fromAnyToTag(st)
+	}
+
 	return c.fromAnyToAny(st)
 }
 
@@ -327,3 +331,12 @@ func (c *layoutConverter) appendTypesFilter(types []string, filters []*model.Blo
 	}
 	return filters
 }
+
+func (c *layoutConverter) fromAnyToTag(st *state.State) error {
+	template.InitTemplate(st,
+		template.WithTitle,
+		template.WithNoDescription,
+		template.WithRandomRelationOptionColor,
+	)
+	return nil
+}

core/block/editor/migrator/migrator.go

@@ -0,0 +1,12 @@
+package migrator
+
+import (
+	"github.com/anyproto/anytype-heart/core/block/editor/state"
+	"github.com/anyproto/anytype-heart/pkg/lib/logging"
+)
+
+var log = logging.Logger("migrator")
+
+type Migrator interface {
+	Migrate(state *state.State)
+}

core/block/editor/migrator/options.go

@@ -0,0 +1,27 @@
+package migrator
+
+import (
+	"github.com/anyproto/anytype-heart/core/block/editor/state"
+	"github.com/anyproto/anytype-heart/pkg/lib/bundle"
+	"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
+	"github.com/anyproto/anytype-heart/util/pbtypes"
+)
+
+type MigrationTags struct{}
+
+func NewMigrationTags() Migrator {
+	return &MigrationTags{}
+}
+
+func (m *MigrationTags) Migrate(s *state.State) {
+	if layout, _ := s.Layout(); layout == model.ObjectType_relationOption {
+		relationKey := pbtypes.GetString(s.CombinedDetails(), bundle.RelationKeyRelationKey.String())
+		if relationKey != bundle.RelationKeyTag.String() {
+			return
+		}
+		s.SetObjectTypeKey(bundle.TypeKeyTag)
+		s.RemoveRelation(bundle.RelationKeyRelationKey.String())
+		s.RemoveRelation(bundle.RelationKeyUniqueKey.String())
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_tag)))
+	}
+}

core/block/editor/migrator/options_test.go

@@ -0,0 +1,57 @@
+package migrator
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/anyproto/anytype-heart/core/block/editor/state"
+	"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 TestMigrationTags_Migrate(t *testing.T) {
+	t.Run("not relation option", func(t *testing.T) {
+		// given
+		migrator := NewMigrationTags()
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_basic)))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.ObjectType_basic), pbtypes.GetInt64(s.Details(), bundle.RelationKeyLayout.String()))
+	})
+	t.Run("not tag relation option", func(t *testing.T) {
+		// given
+		migrator := NewMigrationTags()
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_relationOption)))
+		s.SetDetail(bundle.RelationKeyRelationKey.String(), pbtypes.String("key"))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.ObjectType_relationOption), pbtypes.GetInt64(s.Details(), bundle.RelationKeyLayout.String()))
+		assert.Equal(t, "key", pbtypes.GetString(s.Details(), bundle.RelationKeyRelationKey.String()))
+	})
+	t.Run("migrate relation option", func(t *testing.T) {
+		// given
+		migrator := NewMigrationTags()
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_relationOption)))
+		s.SetDetail(bundle.RelationKeyRelationKey.String(), pbtypes.String(bundle.RelationKeyTag.String()))
+		s.SetDetail(bundle.RelationKeyUniqueKey.String(), pbtypes.String("key"))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.ObjectType_tag), pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyLayout.String()))
+		assert.Empty(t, pbtypes.GetString(s.CombinedDetails(), bundle.RelationKeyUniqueKey.String()))
+		assert.Empty(t, pbtypes.GetString(s.CombinedDetails(), bundle.RelationKeyRelationKey.String()))
+	})
+}

core/block/editor/migrator/ralations.go

@@ -0,0 +1,42 @@
+package migrator
+
+import (
+	"context"
+
+	"github.com/anyproto/anytype-heart/core/block/editor/smartblock"
+	"github.com/anyproto/anytype-heart/core/block/editor/state"
+	"github.com/anyproto/anytype-heart/core/domain"
+	"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/pb/model"
+	"github.com/anyproto/anytype-heart/util/pbtypes"
+)
+
+type MigrationRelations struct {
+	space smartblock.Space
+}
+
+func NewMigrationRelations(space smartblock.Space) Migrator {
+	return &MigrationRelations{space: space}
+}
+
+func (m *MigrationRelations) Migrate(s *state.State) {
+	if layout, _ := s.Layout(); layout == model.ObjectType_relation {
+		relationKey := pbtypes.GetString(s.CombinedDetails(), bundle.RelationKeyUniqueKey.String())
+		relationFormat := pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyRelationFormat.String())
+		if relationKey == bundle.RelationKeyTag.URL() && relationFormat == int64(model.RelationFormat_tag) {
+			m.migrateTag(s)
+		}
+	}
+}
+
+func (m *MigrationRelations) migrateTag(s *state.State) {
+	uniqueKey := domain.MustUniqueKey(coresb.SmartBlockTypeObjectType, bundle.TypeKeyTag.String())
+	tagTypeId, err := m.space.DeriveObjectID(context.Background(), uniqueKey)
+	if err != nil {
+		log.Errorf("failed to migrate state: %v", err)
+	} else {
+		s.SetDetail(bundle.RelationKeyRelationFormatObjectTypes.String(), pbtypes.StringList([]string{tagTypeId}))
+	}
+	s.SetDetail(bundle.RelationKeyRelationFormat.String(), pbtypes.Int64(int64(model.RelationFormat_object)))
+}

core/block/editor/migrator/relations_test.go

@@ -0,0 +1,98 @@
+package migrator
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/anyproto/anytype-heart/core/block/editor/state"
+	"github.com/anyproto/anytype-heart/core/domain"
+	"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/pb/model"
+	"github.com/anyproto/anytype-heart/space/clientspace/mock_clientspace"
+	"github.com/anyproto/anytype-heart/util/pbtypes"
+)
+
+func Test_migrateRelation(t *testing.T) {
+	t.Run("not relation", func(t *testing.T) {
+		// given
+		migrator := NewMigrationRelations(nil)
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_basic)))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.ObjectType_basic), pbtypes.GetInt64(s.Details(), bundle.RelationKeyLayout.String()))
+	})
+	t.Run("not tag relation", func(t *testing.T) {
+		// given
+		migrator := NewMigrationRelations(nil)
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_relation)))
+		s.SetDetail(bundle.RelationKeyUniqueKey.String(), pbtypes.String("key"))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.ObjectType_relation), pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyLayout.String()))
+		assert.Equal(t, "key", pbtypes.GetString(s.CombinedDetails(), bundle.RelationKeyUniqueKey.String()))
+	})
+	t.Run("not tag format relation", func(t *testing.T) {
+		// given
+		migrator := NewMigrationRelations(nil)
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_relation)))
+		s.SetDetail(bundle.RelationKeyUniqueKey.String(), pbtypes.String(bundle.RelationKeyTag.URL()))
+		s.SetDetail(bundle.RelationKeyRelationFormat.String(), pbtypes.Int64(int64(model.RelationFormat_object)))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.ObjectType_relation), pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyLayout.String()))
+		assert.Equal(t, bundle.RelationKeyTag.URL(), pbtypes.GetString(s.CombinedDetails(), bundle.RelationKeyUniqueKey.String()))
+		assert.Equal(t, int64(model.RelationFormat_object), pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyRelationFormat.String()))
+	})
+	t.Run("migrate relation", func(t *testing.T) {
+		// given
+		space := mock_clientspace.NewMockSpace(t)
+		space.EXPECT().DeriveObjectID(context.Background(), domain.MustUniqueKey(coresb.SmartBlockTypeObjectType, bundle.TypeKeyTag.String())).Return("id", nil)
+		migrator := NewMigrationRelations(space)
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_relation)))
+		s.SetDetail(bundle.RelationKeyUniqueKey.String(), pbtypes.String(bundle.RelationKeyTag.URL()))
+		s.SetDetail(bundle.RelationKeyRelationFormat.String(), pbtypes.Int64(int64(model.RelationFormat_tag)))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.RelationFormat_object), pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyRelationFormat.String()))
+		assert.Equal(t, []string{"id"}, pbtypes.GetStringList(s.CombinedDetails(), bundle.RelationKeyRelationFormatObjectTypes.String()))
+	})
+	t.Run("type tage not exist", func(t *testing.T) {
+		// given
+		space := mock_clientspace.NewMockSpace(t)
+		space.EXPECT().DeriveObjectID(context.Background(), domain.MustUniqueKey(coresb.SmartBlockTypeObjectType, bundle.TypeKeyTag.String())).Return("", fmt.Errorf("error"))
+
+		migrator := NewMigrationRelations(space)
+
+		s := &state.State{}
+		s.SetDetail(bundle.RelationKeyLayout.String(), pbtypes.Int64(int64(model.ObjectType_relation)))
+		s.SetDetail(bundle.RelationKeyUniqueKey.String(), pbtypes.String(bundle.RelationKeyTag.URL()))
+		s.SetDetail(bundle.RelationKeyRelationFormat.String(), pbtypes.Int64(int64(model.RelationFormat_tag)))
+
+		// when
+		migrator.Migrate(s)
+
+		// then
+		assert.Equal(t, int64(model.RelationFormat_object), pbtypes.GetInt64(s.CombinedDetails(), bundle.RelationKeyRelationFormat.String()))
+		assert.Len(t, pbtypes.GetStringList(s.CombinedDetails(), bundle.RelationKeyRelationFormatObjectTypes.String()), 0)
+	})
+}

core/block/editor/page.go

@@ -6,6 +6,7 @@ import (
 	"github.com/anyproto/anytype-heart/core/block/editor/clipboard"
 	"github.com/anyproto/anytype-heart/core/block/editor/dataview"
 	"github.com/anyproto/anytype-heart/core/block/editor/file"
+	"github.com/anyproto/anytype-heart/core/block/editor/migrator"
 	"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/stext"
@@ -220,11 +221,12 @@ func (p *Page) CreationStateMigration(ctx *smartblock.InitContext) migration.Mig
 					template.WithTitle,
 					template.WithBlockChat,
 				)
-				// TODO case for relationOption?
 			case model.ObjectType_tag:
 				templates = append(templates,
 					template.WithTitle,
-					template.WithNoDescription)
+					template.WithNoDescription,
+					template.WithRandomRelationOptionColor,
+				)
 			default:
 				templates = append(templates,
 					template.WithTitle,
@@ -242,5 +244,17 @@ func (p *Page) StateMigrations() migration.Migrations {
 			Version: 2,
 			Proc:    template.WithAddedFeaturedRelation(bundle.RelationKeyBacklinks),
 		},
+		{
+			Version: 3,
+			Proc: func(s *state.State) {
+				p.runStateMigrations(s)
+			},
+		},
 	})
 }
+
+func (p *Page) runStateMigrations(s *state.State) {
+	for _, m := range []migrator.Migrator{migrator.NewMigrationTags(), migrator.NewMigrationRelations(p.Space())} {
+		m.Migrate(s)
+	}
+}

core/block/editor/template/template.go

@@ -1,6 +1,9 @@
 package template
 
 import (
+	"crypto/rand"
+	"math/big"
+
 	"github.com/gogo/protobuf/types"
 	"golang.org/x/exp/slices"
 
@@ -29,6 +32,8 @@ const (
 	ChatId              = "chat"
 )
 
+var relationOptionsColors = []string{"grey", "yellow", "orange", "red", "pink", "purple", "blue", "ice", "teal", "lime"}
+
 var log = logging.Logger("anytype-state-template")
 
 type StateTransformer func(s *state.State)
@@ -86,6 +91,15 @@ var WithRelations = func(rels []domain.RelationKey) StateTransformer {
 	}
 }
 
+var WithRandomRelationOptionColor = StateTransformer(func(s *state.State) {
+	randomIndex, err := rand.Int(rand.Reader, big.NewInt(int64(len(relationOptionsColors))))
+	if err != nil {
+		return
+	}
+	s.SetDetail(bundle.RelationKeyRelationOptionColor.String(), pbtypes.String(relationOptionsColors[randomIndex.Int64()]))
+	s.AddBundledRelationLinks([]domain.RelationKey{bundle.RelationKeyRelationOptionColor}...)
+})
+
 var WithRequiredRelations = func(s *state.State) {
 	WithRelations(bundle.RequiredInternalRelations)(s)
 }

core/block/import/common/collection.go

@@ -110,7 +110,7 @@ func (r *ImportCollection) addRelations(st *state.State) error {
 	for _, relation := range []*model.RelationLink{
 		{
 			Key:    bundle.RelationKeyTag.String(),
-			Format: model.RelationFormat_tag,
+			Format: model.RelationFormat_object,
 		},
 		{
 			Key:    bundle.RelationKeyCreatedDate.String(),