feat(asset): implement file system repository and zip decompressor

.gitignore

@@ -1,2 +1,3 @@
 .env
 .env.*
+.idea

asset/domain/builder/asset.go

@@ -0,0 +1,114 @@
+package builder
+
+import (
+	"time"
+
+	"github.com/reearth/reearthx/asset/domain"
+	"github.com/reearth/reearthx/asset/domain/entity"
+	"github.com/reearth/reearthx/asset/domain/id"
+)
+
+type AssetBuilder struct {
+	a *entity.Asset
+}
+
+func NewAssetBuilder() *AssetBuilder {
+	return &AssetBuilder{a: &entity.Asset{}}
+}
+
+func (b *AssetBuilder) Build() (*entity.Asset, error) {
+	if b.a.ID() == (id.ID{}) {
+		return nil, id.ErrInvalidID
+	}
+	if b.a.WorkspaceID() == (id.WorkspaceID{}) {
+		return nil, domain.ErrEmptyWorkspaceID
+	}
+	if b.a.URL() == "" {
+		return nil, domain.ErrEmptyURL
+	}
+	if b.a.Size() <= 0 {
+		return nil, domain.ErrEmptySize
+	}
+	if b.a.CreatedAt().IsZero() {
+		now := time.Now()
+		b.a.SetCreatedAt(now)
+		b.a.SetUpdatedAt(now)
+	}
+	if b.a.Status() == "" {
+		b.a.UpdateStatus(entity.StatusPending, b.a.Error())
+	}
+	return b.a, nil
+}
+
+func (b *AssetBuilder) MustBuild() *entity.Asset {
+	r, err := b.Build()
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+func (b *AssetBuilder) ID(id id.ID) *AssetBuilder {
+	b.a = entity.NewAsset(id, b.a.Name(), b.a.Size(), b.a.ContentType())
+	return b
+}
+
+func (b *AssetBuilder) NewID() *AssetBuilder {
+	return b.ID(id.NewID())
+}
+
+func (b *AssetBuilder) GroupID(groupID id.GroupID) *AssetBuilder {
+	b.a.MoveToGroup(groupID)
+	return b
+}
+
+func (b *AssetBuilder) ProjectID(projectID id.ProjectID) *AssetBuilder {
+	b.a.MoveToProject(projectID)
+	return b
+}
+
+func (b *AssetBuilder) WorkspaceID(workspaceID id.WorkspaceID) *AssetBuilder {
+	b.a.MoveToWorkspace(workspaceID)
+	return b
+}
+
+func (b *AssetBuilder) Name(name string) *AssetBuilder {
+	b.a.UpdateMetadata(name, b.a.URL(), b.a.ContentType())
+	return b
+}
+
+func (b *AssetBuilder) Size(size int64) *AssetBuilder {
+	b.a.SetSize(size)
+	return b
+}
+
+func (b *AssetBuilder) URL(url string) *AssetBuilder {
+	b.a.UpdateMetadata(b.a.Name(), url, b.a.ContentType())
+	return b
+}
+
+func (b *AssetBuilder) ContentType(contentType string) *AssetBuilder {
+	b.a.UpdateMetadata(b.a.Name(), b.a.URL(), contentType)
+	return b
+}
+
+func (b *AssetBuilder) Status(status entity.Status) *AssetBuilder {
+	b.a.UpdateStatus(status, b.a.Error())
+	return b
+}
+
+func (b *AssetBuilder) Error(err string) *AssetBuilder {
+	b.a.UpdateStatus(b.a.Status(), err)
+	return b
+}
+
+// CreatedAt sets the creation time of the asset
+func (b *AssetBuilder) CreatedAt(createdAt time.Time) *AssetBuilder {
+	b.a.SetCreatedAt(createdAt)
+	return b
+}
+
+func (b *AssetBuilder) UpdatedAt(updatedAt time.Time) *AssetBuilder {
+	b.a.SetUpdatedAt(updatedAt)
+	return b
+}

asset/domain/builder/group.go

@@ -0,0 +1,79 @@
+package builder
+
+import (
+	"time"
+
+	"github.com/reearth/reearthx/asset/domain"
+	"github.com/reearth/reearthx/asset/domain/entity"
+	"github.com/reearth/reearthx/asset/domain/id"
+)
+
+type GroupBuilder struct {
+	g *entity.Group
+}
+
+func NewGroupBuilder() *GroupBuilder {
+	return &GroupBuilder{g: &entity.Group{}}
+}
+
+func (b *GroupBuilder) Build() (*entity.Group, error) {
+	if b.g.ID() == (id.GroupID{}) {
+		return nil, id.ErrInvalidID
+	}
+	if b.g.Name() == "" {
+		return nil, domain.ErrEmptyGroupName
+	}
+	if b.g.CreatedAt().IsZero() {
+		now := time.Now()
+		b.CreatedAt(now)
+	}
+	return b.g, nil
+}
+
+func (b *GroupBuilder) MustBuild() *entity.Group {
+	r, err := b.Build()
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+func (b *GroupBuilder) ID(id id.GroupID) *GroupBuilder {
+	b.g = entity.NewGroup(id, b.g.Name())
+	return b
+}
+
+func (b *GroupBuilder) NewID() *GroupBuilder {
+	return b.ID(id.NewGroupID())
+}
+
+func (b *GroupBuilder) Name(name string) *GroupBuilder {
+	if err := b.g.UpdateName(name); err != nil {
+		return b
+	}
+	return b
+}
+
+func (b *GroupBuilder) Policy(policy string) *GroupBuilder {
+	if err := b.g.UpdatePolicy(policy); err != nil {
+		return b
+	}
+	return b
+}
+
+func (b *GroupBuilder) Description(description string) *GroupBuilder {
+	if err := b.g.UpdateDescription(description); err != nil {
+		return b
+	}
+	return b
+}
+
+// CreatedAt sets the creation time of the group
+func (b *GroupBuilder) CreatedAt(createdAt time.Time) *GroupBuilder {
+	b.g.SetCreatedAt(createdAt)
+	return b
+}
+
+func (b *GroupBuilder) UpdatedAt(updatedAt time.Time) *GroupBuilder {
+	return b
+}

asset/domain/builder/tests/asset_test.go

@@ -0,0 +1,190 @@
+package builder_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/reearth/reearthx/asset/domain"
+	"github.com/reearth/reearthx/asset/domain/builder"
+	"github.com/reearth/reearthx/asset/domain/entity"
+	"github.com/reearth/reearthx/asset/domain/id"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAssetBuilder_Build(t *testing.T) {
+	assetID := id.NewID()
+	workspaceID := id.NewWorkspaceID()
+
+	tests := []struct {
+		name    string
+		builder func() *builder.AssetBuilder
+		want    *entity.Asset
+		wantErr error
+	}{
+		{
+			name: "success",
+			builder: func() *builder.AssetBuilder {
+				return builder.NewAssetBuilder().
+					ID(assetID).
+					Name("test.jpg").
+					Size(1024).
+					ContentType("image/jpeg").
+					WorkspaceID(workspaceID).
+					URL("https://example.com/test.jpg")
+			},
+			want: func() *entity.Asset {
+				asset := entity.NewAsset(assetID, "test.jpg", 1024, "image/jpeg")
+				asset.MoveToWorkspace(workspaceID)
+				asset.UpdateMetadata("test.jpg", "https://example.com/test.jpg", "image/jpeg")
+				return asset
+			}(),
+			wantErr: nil,
+		},
+		{
+			name: "missing ID",
+			builder: func() *builder.AssetBuilder {
+				return builder.NewAssetBuilder().
+					Name("test.jpg").
+					Size(1024).
+					ContentType("image/jpeg").
+					WorkspaceID(workspaceID).
+					URL("https://example.com/test.jpg")
+			},
+			wantErr: id.ErrInvalidID,
+		},
+		{
+			name: "missing workspace ID",
+			builder: func() *builder.AssetBuilder {
+				return builder.NewAssetBuilder().
+					ID(assetID).
+					Name("test.jpg").
+					Size(1024).
+					ContentType("image/jpeg").
+					URL("https://example.com/test.jpg")
+			},
+			wantErr: domain.ErrEmptyWorkspaceID,
+		},
+		{
+			name: "missing URL",
+			builder: func() *builder.AssetBuilder {
+				return builder.NewAssetBuilder().
+					ID(assetID).
+					Name("test.jpg").
+					Size(1024).
+					ContentType("image/jpeg").
+					WorkspaceID(workspaceID)
+			},
+			wantErr: domain.ErrEmptyURL,
+		},
+		{
+			name: "invalid size",
+			builder: func() *builder.AssetBuilder {
+				return builder.NewAssetBuilder().
+					ID(assetID).
+					Name("test.jpg").
+					Size(0).
+					ContentType("image/jpeg").
+					WorkspaceID(workspaceID).
+					URL("https://example.com/test.jpg")
+			},
+			wantErr: domain.ErrEmptySize,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.builder().Build()
+			if tt.wantErr != nil {
+				assert.Equal(t, tt.wantErr, err)
+				assert.Nil(t, got)
+				return
+			}
+			assert.NoError(t, err)
+			assert.NotNil(t, got)
+			if tt.want != nil {
+				assert.Equal(t, tt.want.ID(), got.ID())
+				assert.Equal(t, tt.want.Name(), got.Name())
+				assert.Equal(t, tt.want.Size(), got.Size())
+				assert.Equal(t, tt.want.ContentType(), got.ContentType())
+				assert.Equal(t, tt.want.URL(), got.URL())
+				assert.Equal(t, tt.want.WorkspaceID(), got.WorkspaceID())
+			}
+		})
+	}
+}
+
+func TestAssetBuilder_MustBuild(t *testing.T) {
+	assetID := id.NewID()
+	workspaceID := id.NewWorkspaceID()
+
+	// Test successful build
+	assert.NotPanics(t, func() {
+		asset := builder.NewAssetBuilder().
+			ID(assetID).
+			Name("test.jpg").
+			Size(1024).
+			ContentType("image/jpeg").
+			WorkspaceID(workspaceID).
+			URL("https://example.com/test.jpg").
+			MustBuild()
+		assert.NotNil(t, asset)
+	})
+
+	// Test panic on invalid build
+	assert.Panics(t, func() {
+		_ = builder.NewAssetBuilder().MustBuild()
+	})
+}
+
+func TestAssetBuilder_Setters(t *testing.T) {
+	assetID := id.NewID()
+	workspaceID := id.NewWorkspaceID()
+	projectID := id.NewProjectID()
+	groupID := id.NewGroupID()
+	now := time.Now()
+
+	b := builder.NewAssetBuilder().
+		CreatedAt(now).
+		ID(assetID).
+		Name("test.jpg").
+		Size(1024).
+		ContentType("image/jpeg").
+		WorkspaceID(workspaceID).
+		ProjectID(projectID).
+		GroupID(groupID).
+		URL("https://example.com/test.jpg").
+		Status(entity.StatusActive).
+		Error("test error")
+
+	asset, err := b.Build()
+	assert.NoError(t, err)
+	assert.NotNil(t, asset)
+
+	assert.Equal(t, assetID, asset.ID())
+	assert.Equal(t, workspaceID, asset.WorkspaceID())
+	assert.Equal(t, projectID, asset.ProjectID())
+	assert.Equal(t, groupID, asset.GroupID())
+	assert.Equal(t, "test.jpg", asset.Name())
+	assert.Equal(t, int64(1024), asset.Size())
+	assert.Equal(t, "https://example.com/test.jpg", asset.URL())
+	assert.Equal(t, "image/jpeg", asset.ContentType())
+	assert.Equal(t, entity.StatusActive, asset.Status())
+	assert.Equal(t, "test error", asset.Error())
+	assert.Equal(t, now.Unix(), asset.CreatedAt().Unix())
+}
+
+func TestAssetBuilder_NewID(t *testing.T) {
+	b := builder.NewAssetBuilder().NewID()
+	// Add required fields to make the build succeed
+	b = b.
+		Name("test.jpg").
+		Size(1024).
+		ContentType("image/jpeg").
+		WorkspaceID(id.NewWorkspaceID()).
+		URL("https://example.com/test.jpg")
+
+	asset, err := b.Build()
+	assert.NoError(t, err)
+	assert.NotNil(t, asset)
+	assert.NotEqual(t, id.ID{}, asset.ID()) // ID should be set
+}