feat: automatic property migration from old schema to new schema

internal/adapter/gql/gqlmodel/convert_property.go

@@ -3,6 +3,7 @@ package gqlmodel
 import (
 	"strings"
 
+	"github.com/reearth/reearth-backend/pkg/dataset"
 	"github.com/reearth/reearth-backend/pkg/id"
 	"github.com/reearth/reearth-backend/pkg/property"
 	"github.com/reearth/reearth-backend/pkg/value"
@@ -122,7 +123,7 @@ func ToPropertyField(f *property.Field, parent *property.Property, gl *property.
 	var links []*PropertyFieldLink
 	if flinks := f.Links(); flinks != nil {
 		links = make([]*PropertyFieldLink, 0, flinks.Len())
-		for _, l := range flinks.Links() {
+		for _, l := range flinks.Pointers() {
 			links = append(links, ToPropertyFieldLink(l))
 		}
 	}
@@ -138,24 +139,24 @@ func ToPropertyField(f *property.Field, parent *property.Property, gl *property.
 	}
 }
 
-func ToPropertyFieldLinks(flinks *property.Links) []*PropertyFieldLink {
+func ToPropertyFieldLinks(flinks *dataset.GraphPointer) []*PropertyFieldLink {
 	if flinks == nil {
 		return nil
 	}
 	var links []*PropertyFieldLink
 	links = make([]*PropertyFieldLink, 0, flinks.Len())
-	for _, l := range flinks.Links() {
+	for _, l := range flinks.Pointers() {
 		links = append(links, ToPropertyFieldLink(l))
 	}
 	return links
 }
 
-func FromPropertyFieldLink(datasetSchema, ds, fields []*id.ID) *property.Links {
+func FromPropertyFieldLink(datasetSchema, ds, fields []*id.ID) *dataset.GraphPointer {
 	if len(datasetSchema) != len(fields) || (ds != nil && len(ds) != len(fields) && len(ds) > 1) {
 		return nil
 	}
 
-	links := make([]*property.Link, 0, len(datasetSchema))
+	links := make([]*dataset.Pointer, 0, len(datasetSchema))
 	for i, dss := range datasetSchema {
 		f := fields[i]
 		if dss == nil || f == nil {
@@ -164,24 +165,24 @@ func FromPropertyFieldLink(datasetSchema, ds, fields []*id.ID) *property.Links {
 		dsid := id.DatasetSchemaID(*dss)
 		dsfid := id.DatasetSchemaFieldID(*f)
 		if len(ds) == 0 || (len(ds) == 1 && i > 0) {
-			links = append(links, property.NewLinkFieldOnly(dsid, dsfid))
+			links = append(links, dataset.PointAtField(dsid, dsfid))
 		} else {
 			d := ds[i]
 			if d == nil {
 				return nil
 			}
-			links = append(links, property.NewLink(id.DatasetID(*d), dsid, dsfid))
+			links = append(links, dataset.PointAt(id.DatasetID(*d), dsid, dsfid))
 		}
 	}
 
-	return property.NewLinks(links)
+	return dataset.NewGraphPointer(links)
 }
 
-func ToPropertyFieldLink(link *property.Link) *PropertyFieldLink {
+func ToPropertyFieldLink(link *dataset.Pointer) *PropertyFieldLink {
 	return &PropertyFieldLink{
 		DatasetID:            link.Dataset().IDRef(),
-		DatasetSchemaID:      link.DatasetSchema().ID(),
-		DatasetSchemaFieldID: link.DatasetSchemaField().ID(),
+		DatasetSchemaID:      link.Schema().ID(),
+		DatasetSchemaFieldID: link.Field().ID(),
 	}
 }
 
@@ -208,10 +209,10 @@ func ToPropertySchema(propertySchema *property.Schema) *PropertySchema {
 		return nil
 	}
 
-	pgroups := propertySchema.Groups()
+	pgroups := propertySchema.Groups().Groups()
 	groups := make([]*PropertySchemaGroup, 0, len(pgroups))
 	for _, g := range pgroups {
-		groups = append(groups, ToPropertySchemaGroup(g))
+		groups = append(groups, ToPropertySchemaGroup(g, propertySchema.ID()))
 	}
 
 	return &PropertySchema{
@@ -224,8 +225,8 @@ func ToPropertySchema(propertySchema *property.Schema) *PropertySchema {
 func ToPropertyLinkableFields(sid id.PropertySchemaID, l property.LinkableFields) *PropertyLinkableFields {
 	return &PropertyLinkableFields{
 		SchemaID: sid,
-		Latlng:   l.LatLng.FieldRef(),
-		URL:      l.URL.FieldRef(),
+		Latlng:   l.FieldByType(property.ValueTypeLatLng),
+		URL:      l.FieldByType(property.ValueTypeURL),
 	}
 }
 
@@ -364,7 +365,7 @@ func ToMergedPropertyField(f *property.MergedField, s id.PropertySchemaID) *Merg
 	}
 }
 
-func ToPropertySchemaGroup(g *property.SchemaGroup) *PropertySchemaGroup {
+func ToPropertySchemaGroup(g *property.SchemaGroup, p property.SchemaID) *PropertySchemaGroup {
 	if g == nil {
 		return nil
 	}
@@ -381,7 +382,7 @@ func ToPropertySchemaGroup(g *property.SchemaGroup) *PropertySchemaGroup {
 	}
 	return &PropertySchemaGroup{
 		SchemaGroupID:         g.ID(),
-		SchemaID:              g.Schema(),
+		SchemaID:              p,
 		IsList:                g.IsList(),
 		Title:                 g.Title().StringRef(),
 		Fields:                fields,
@@ -397,15 +398,15 @@ func ToPropertyGroup(g *property.Group, p *property.Property, gl *property.Group
 		return nil
 	}
 
-	gfields := g.Fields()
+	gfields := g.Fields(nil)
 	fields := make([]*PropertyField, 0, len(gfields))
 	for _, f := range gfields {
 		fields = append(fields, ToPropertyField(f, p, gl, g))
 	}
 
 	return &PropertyGroup{
 		ID:            g.ID().ID(),
-		SchemaID:      g.Schema(),
+		SchemaID:      p.Schema(),
 		SchemaGroupID: g.SchemaGroup(),
 		Fields:        fields,
 	}
@@ -424,7 +425,7 @@ func ToPropertyGroupList(g *property.GroupList, p *property.Property) *PropertyG
 
 	return &PropertyGroupList{
 		ID:            g.ID().ID(),
-		SchemaID:      g.Schema(),
+		SchemaID:      p.Schema(),
 		SchemaGroupID: g.SchemaGroup(),
 		Groups:        groups,
 	}

internal/adapter/gql/gqlmodel/convert_scene.go

@@ -55,7 +55,7 @@ func ToScene(scene *scene.Scene) *Scene {
 		clusters = append(clusters, ToCluster(c))
 	}
 
-	scenePlugins := scene.PluginSystem().Plugins()
+	scenePlugins := scene.Plugins().Plugins()
 	plugins := make([]*ScenePlugin, 0, len(scenePlugins))
 	for _, sp := range scenePlugins {
 		plugins = append(plugins, ToScenePlugin(sp))

internal/adapter/gql/resolver_mutation_scene.go

@@ -153,7 +153,7 @@ func (r *mutationResolver) UploadPlugin(ctx context.Context, input gqlmodel.Uplo
 	return &gqlmodel.UploadPluginPayload{
 		Plugin:      gqlmodel.ToPlugin(p),
 		Scene:       gqlmodel.ToScene(s),
-		ScenePlugin: gqlmodel.ToScenePlugin(s.PluginSystem().Plugin(p.ID())),
+		ScenePlugin: gqlmodel.ToScenePlugin(s.Plugins().Plugin(p.ID())),
 	}, nil
 }
 
@@ -192,7 +192,7 @@ func (r *mutationResolver) UpgradePlugin(ctx context.Context, input gqlmodel.Upg
 
 	return &gqlmodel.UpgradePluginPayload{
 		Scene:       gqlmodel.ToScene(s),
-		ScenePlugin: gqlmodel.ToScenePlugin(s.PluginSystem().Plugin(input.ToPluginID)),
+		ScenePlugin: gqlmodel.ToScenePlugin(s.Plugins().Plugin(input.ToPluginID)),
 	}, nil
 }
 

internal/infrastructure/github/plugin_registry_test.go

@@ -2,7 +2,6 @@ package github
 
 import (
 	"context"
-	"errors"
 	"testing"
 	"time"
 
@@ -19,8 +18,16 @@ func TestNewPluginRegistry(t *testing.T) {
 func TestPluginRegistry_FetchMetadata(t *testing.T) {
 	httpmock.Activate()
 	defer httpmock.DeactivateAndReset()
-	httpmock.RegisterResponder("GET", "https://raw.githubusercontent.com/reearth/plugins/main/plugins.json",
-		httpmock.NewStringResponder(200, `[{"name": "reearth","description": "Official Plugin", "author": "reearth", "thumbnailUrl": "", "createdAt": "2021-03-16T04:19:57.592Z"}]`))
+
+	httpmock.RegisterResponder(
+		"GET",
+		"https://raw.githubusercontent.com/reearth/plugins/main/plugins.json",
+		httpmock.NewStringResponder(
+			200,
+			`[{"name": "reearth","description": "Official Plugin", "author": "reearth", "thumbnailUrl": "", "createdAt": "2021-03-16T04:19:57.592Z"}]`,
+		),
+	)
+
 	d := NewPluginRegistry()
 	res, err := d.FetchMetadata(context.Background())
 	tm, _ := time.Parse(time.RFC3339, "2021-03-16T04:19:57.592Z")
@@ -37,15 +44,20 @@ func TestPluginRegistry_FetchMetadata(t *testing.T) {
 	assert.NoError(t, err)
 
 	// fail: bad request
-	httpmock.RegisterResponder("GET", "https://raw.githubusercontent.com/reearth/plugins/main/plugins.json",
-		httpmock.NewStringResponder(400, `mock bad request`))
+	httpmock.RegisterResponder(
+		"GET",
+		"https://raw.githubusercontent.com/reearth/plugins/main/plugins.json",
+		httpmock.NewStringResponder(400, `mock bad request`),
+	)
 	_, err = d.FetchMetadata(context.Background())
-	assert.True(t, errors.As(errors.New("StatusCode=400"), &err))
+	assert.EqualError(t, err, "StatusCode=400")
 
 	// fail: unable to marshal
-	httpmock.RegisterResponder("GET", "https://raw.githubusercontent.com/reearth/plugins/main/plugins.json",
-		httpmock.NewStringResponder(200, `{"hoge": "test"}`))
+	httpmock.RegisterResponder(
+		"GET",
+		"https://raw.githubusercontent.com/reearth/plugins/main/plugins.json",
+		httpmock.NewStringResponder(200, `{"hoge": "test"}`),
+	)
 	_, err = d.FetchMetadata(context.Background())
-	assert.True(t, errors.As(errors.New("cannot unmarshal object into Go value of type []*plugin.Metadata"), &err))
-
+	assert.Error(t, err)
 }

internal/infrastructure/memory/layer.go

@@ -137,6 +137,50 @@ func (r *Layer) FindGroupBySceneAndLinkedDatasetSchema(ctx context.Context, s id
 	return result, nil
 }
 
+func (r *Layer) FindParentsByIDs(_ context.Context, ids []id.LayerID, scenes []id.SceneID) (layer.GroupList, error) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+
+	res := layer.GroupList{}
+	for _, l := range r.data {
+		if !isSceneIncludes(l.Scene(), scenes) {
+			continue
+		}
+		gl, ok := l.(*layer.Group)
+		if !ok {
+			continue
+		}
+		for _, cl := range gl.Layers().Layers() {
+			if cl.Contains(ids) {
+				res = append(res, gl)
+			}
+		}
+	}
+
+	return res, nil
+}
+
+func (r *Layer) FindByPluginAndExtension(_ context.Context, pid id.PluginID, eid *id.PluginExtensionID, scenes []id.SceneID) (layer.List, error) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+
+	res := layer.List{}
+	for _, l := range r.data {
+		if !isSceneIncludes(l.Scene(), scenes) {
+			continue
+		}
+
+		if l.Plugin().Equal(pid) {
+			e := l.Extension()
+			if eid == nil || e != nil && *e == *eid {
+				res = append(res, &l)
+			}
+		}
+	}
+
+	return res, nil
+}
+
 func (r *Layer) FindByProperty(ctx context.Context, id id.PropertyID, f []id.SceneID) (layer.Layer, error) {
 	r.lock.Lock()
 	defer r.lock.Unlock()

internal/infrastructure/memory/property.go

@@ -2,6 +2,7 @@ package memory
 
 import (
 	"context"
+	"sort"
 	"sync"
 
 	"github.com/reearth/reearth-backend/pkg/id"
@@ -80,6 +81,29 @@ func (r *Property) FindLinkedAll(ctx context.Context, s id.SceneID) (property.Li
 	return result, nil
 }
 
+func (r *Property) FindBySchema(_ context.Context, schemas []id.PropertySchemaID, s id.SceneID) (property.List, error) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+
+	result := property.List{}
+	for _, p := range r.data {
+		if p.Scene() != s {
+			continue
+		}
+		for _, s := range schemas {
+			if p.Schema().Equal(s) {
+				p2 := p
+				result = append(result, &p2)
+				break
+			}
+		}
+	}
+	sort.Slice(result, func(i, j int) bool {
+		return result[i].ID().ID().Compare(result[j].ID().ID()) < 0
+	})
+	return result, nil
+}
+
 func (r *Property) Save(ctx context.Context, p *property.Property) error {
 	r.lock.Lock()
 	defer r.lock.Unlock()

internal/infrastructure/memory/property_test.go

@@ -0,0 +1,69 @@
+package memory
+
+import (
+	"context"
+	"testing"
+
+	"github.com/reearth/reearth-backend/pkg/id"
+	"github.com/reearth/reearth-backend/pkg/property"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestProperty_FindBySchema(t *testing.T) {
+	p1 := id.NewPropertyID()
+	p2 := id.NewPropertyID()
+	p3 := id.NewPropertyID()
+	p4 := id.NewPropertyID()
+	p5 := id.NewPropertyID()
+	ps1 := id.MustPropertySchemaID("a~1.0.0/a")
+	ps2 := id.MustPropertySchemaID("a~1.0.0/b")
+	s1 := id.NewSceneID()
+	s2 := id.NewSceneID()
+
+	type args struct {
+		in0     context.Context
+		schemas []id.PropertySchemaID
+		s       id.SceneID
+	}
+	tests := []struct {
+		name    string
+		target  *Property
+		args    args
+		want    property.List
+		wantErr error
+	}{
+		{
+			name: "found",
+			target: &Property{
+				data: map[id.PropertyID]property.Property{
+					p1: *property.New().ID(p1).Scene(s1).Schema(ps1).MustBuild(),
+					p2: *property.New().ID(p2).Scene(s1).Schema(ps2).MustBuild(),
+					p3: *property.New().ID(p3).Scene(s2).Schema(ps1).MustBuild(),
+					p4: *property.New().ID(p4).Scene(s2).Schema(ps2).MustBuild(),
+					p5: *property.New().ID(p5).Scene(s1).Schema(ps1).MustBuild(),
+				},
+			},
+			args: args{
+				in0:     nil,
+				schemas: []id.PropertySchemaID{ps1, ps2},
+				s:       s1,
+			},
+			want: property.List{
+				property.New().ID(p1).Scene(s1).Schema(ps1).MustBuild(),
+				property.New().ID(p2).Scene(s1).Schema(ps2).MustBuild(),
+				property.New().ID(p5).Scene(s1).Schema(ps1).MustBuild(),
+			},
+			wantErr: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got, err := tt.target.FindBySchema(tt.args.in0, tt.args.schemas, tt.args.s)
+			assert.Equal(t, tt.wantErr, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}