AlbumApp Service (recerdo-album)¶

// Domain Entity: Album (Aggregate Root)
type Album struct {
    ID              string    // ULID
    EventID         *string   // nullable - null if standalone album
    OrgID           string
    Title           AlbumTitle
    Description     string
    CoverMediaID    *string   // nullable - must be a media_id in this album
    CreatedBy       string    // user_id
    CreatedAt       time.Time
    UpdatedAt       time.Time
    DeletedAt       *time.Time // soft delete
    Status          AlbumStatus
}

// Domain Value Object: AlbumTitle
type AlbumTitle struct {
    Value string
}

func NewAlbumTitle(value string) (AlbumTitle, error) {
    if len(value) < 1 || len(value) > 200 {
        return AlbumTitle{}, fmt.Errorf("album title must be 1-200 characters")
    }
    return AlbumTitle{Value: value}, nil
}

// Domain Entity: AlbumMedia
type AlbumMedia struct {
    ID        string     // ULID
    AlbumID   string
    MediaID   string     // reference to Storage Service
    UploadedBy string    // user_id
    Caption   string     // 0-1000 chars, optional
    Position  int        // ordering within album
    AddedAt   time.Time
    DeletedAt *time.Time // soft delete
}

// Domain Entity: AlbumComment
type AlbumComment struct {
    ID        string
    AlbumID   string
    MediaID   *string    // nullable - null if comment on album, set if comment on media
    UserID    string
    Body      string     // 1-5000 chars, required
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt *time.Time // soft delete
}

// Domain Entity: HighlightVideo
type HighlightVideo struct {
    ID           string
    AlbumID      string
    VideoMediaID string            // reference to Storage Service
    DurationSecs int
    Status       HighlightVideoStatus
    GeneratedAt  time.Time
    MetadataJSON string            // JSON: {selected_media_count, track_title, etc.}
}

// Domain Value Object: HighlightVideoStatus
type HighlightVideoStatus string

const (
    HighlightVideoPending HighlightVideoStatus = "PENDING"
    HighlightVideoReady   HighlightVideoStatus = "READY"
    HighlightVideoFailed  HighlightVideoStatus = "FAILED"
)

// Domain Value Object: AlbumAccessControl
type AlbumAccessControl struct {
    ID        string
    AlbumID   string
    UserID    string
    Role      Role
    GrantedAt time.Time
}

type Role string

const (
    RoleViewer      Role = "viewer"
    RoleContributor Role = "contributor"
    RoleOwner       Role = "owner"
)

// Domain Event
type AlbumCreatedEvent struct {
    AlbumID   string
    OrgID     string
    EventID   *string
    CreatedBy string
    CreatedAt time.Time
    Title     string
}

type MediaAddedEvent struct {
    AlbumID    string
    MediaID    string
    UploadedBy string
    Position   int
    AddedAt    time.Time
    Caption    string
}

type GetEventAlbumInput struct {
    OrgID   string
    EventID string
    UserID  string  // 要求ユーザーID
}

type AlbumOutput struct {
    ID               string
    EventID          *string
    OrgID            string
    Title            string
    Description      string
    CoverMediaID     *string
    CreatedBy        string
    CreatedAt        time.Time
    UpdatedAt        time.Time
    Status           string
    MediaCount       int
    Media            []AlbumMediaOutput  // position順
    HighlightVideo   *HighlightVideoOutput
    CurrentUserRole  string              // "viewer" / "contributor" / "owner"
}

type AlbumMediaOutput struct {
    ID        string
    MediaID   string
    Caption   string
    Position  int
    UploadedBy string
    AddedAt   time.Time
}

type HighlightVideoOutput struct {
    ID           string
    VideoMediaID string
    DurationSecs int
    Status       string
    GeneratedAt  time.Time
}

// === Repository Ports ===

type AlbumRepository interface {
    Save(ctx context.Context, album *Album) error
    GetByID(ctx context.Context, albumID string) (*Album, error)
    GetByEventID(ctx context.Context, orgID, eventID string) (*Album, error)
    ListByOrgID(ctx context.Context, orgID string, page, limit int) ([]*Album, error)
    Delete(ctx context.Context, albumID string) error // soft delete
    Update(ctx context.Context, album *Album) error
}

type AlbumMediaRepository interface {
    Save(ctx context.Context, media *AlbumMedia) error
    GetByID(ctx context.Context, mediaID string) (*AlbumMedia, error)
    ListByAlbumID(ctx context.Context, albumID string) ([]*AlbumMedia, error)
    Delete(ctx context.Context, mediaID string) error // soft delete
    Update(ctx context.Context, media *AlbumMedia) error
    ReorderByAlbumID(ctx context.Context, albumID string, reorder map[string]int) error
}

type AlbumCommentRepository interface {
    Save(ctx context.Context, comment *AlbumComment) error
    GetByID(ctx context.Context, commentID string) (*AlbumComment, error)
    ListByAlbumID(ctx context.Context, albumID string, page, limit int) ([]*AlbumComment, error)
    ListByMediaID(ctx context.Context, mediaID string, page, limit int) ([]*AlbumComment, error)
    Delete(ctx context.Context, commentID string) error // soft delete
}

type HighlightVideoRepository interface {
    Save(ctx context.Context, hv *HighlightVideo) error
    GetByAlbumID(ctx context.Context, albumID string) (*HighlightVideo, error)
    Delete(ctx context.Context, highlightVideoID string) error
    Update(ctx context.Context, hv *HighlightVideo) error
}

// === Service Ports ===

type PermissionService interface {
    CheckAccess(ctx context.Context, userID, albumID string, requiredRoles []Role) (Role, error)
    GetUserRole(ctx context.Context, userID, albumID string) (Role, error)
    GrantAccess(ctx context.Context, albumID, userID string, role Role) error
    RevokeAccess(ctx context.Context, albumID, userID string) error
    ListAccessByAlbumID(ctx context.Context, albumID string) ([]*AlbumAccessControl, error)
}

type EventService interface {
    GetEvent(ctx context.Context, orgID, eventID string) (*EventData, error)
    VerifyEventExists(ctx context.Context, orgID, eventID string) error
}

type StorageService interface {
    GetMediaMetadata(ctx context.Context, mediaID string) (*MediaMetadata, error)
    VerifyMediaExists(ctx context.Context, mediaID string) error
    GetMediaURL(ctx context.Context, mediaID string) (string, error)
}

type EventPublisher interface {
    PublishAlbumCreated(ctx context.Context, event *AlbumCreatedEvent) error
    PublishMediaAdded(ctx context.Context, event *MediaAddedEvent) error
    PublishMediaRemoved(ctx context.Context, event *MediaRemovedEvent) error
    PublishCommentCreated(ctx context.Context, event *AlbumCommentCreatedEvent) error
    PublishAlbumAccessUpdated(ctx context.Context, event *AlbumAccessUpdatedEvent) error
}

type CacheService interface {
    Get(ctx context.Context, key string) (string, error)
    Set(ctx context.Context, key string, value string, ttl time.Duration) error
    Delete(ctx context.Context, key string) error
    DeletePattern(ctx context.Context, pattern string) error // delete all keys matching pattern
}

type HighlightVideoJobQueue interface {
    EnqueueGenerateHighlightVideo(ctx context.Context, albumID string, mediaIDs []string) error
    GetJobStatus(ctx context.Context, jobID string) (string, error)
}

type HTTPPermissionServiceAdapter struct {
    httpClient *http.Client
    baseURL    string
    timeout    time.Duration
}

func (a *HTTPPermissionServiceAdapter) CheckAccess(
    ctx context.Context,
    userID, albumID string,
    requiredRoles []Role,
) (Role, error) {
    req, _ := http.NewRequestWithContext(ctx,
        "POST",
        fmt.Sprintf("%s/api/check-access", a.baseURL),
        bytes.NewReader([]byte(fmt.Sprintf(
            `{"user_id":"%s","resource_id":"%s","required_roles":["%s"]}`,
            userID, albumID, strings.Join(rolesAsStrings(requiredRoles), `","`),
        ))))
    req.Header.Set("Content-Type", "application/json")

    resp, err := a.httpClient.Do(req)
    if err != nil {
        return "", fmt.Errorf("permission check failed: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode == 403 {
        return "", ErrAccessDenied
    }
    if resp.StatusCode != 200 {
        return "", fmt.Errorf("permission service returned %d", resp.StatusCode)
    }

    var result struct {
        Role string `json:"role"`
    }
    json.NewDecoder(resp.Body).Decode(&result)
    return Role(result.Role), nil
}

// uber-go/fx を使用した DI パターン

package main

import (
    "go.uber.org/fx"
    "recuerdo/album-svc/internal/domain"
    "recuerdo/album-svc/internal/application"
    "recuerdo/album-svc/internal/adapter"
    "recuerdo/album-svc/internal/infra"
)

func main() {
    app := fx.New(
        // Infrastructure Providers
        fx.Provide(infra.NewMySQLDB),
        fx.Provide(infra.NewRedisClient),
        fx.Provide(infra.NewQueueClient),       // Beta: Redis+BullMQ / asynq、本番: OCI Queue
        fx.Provide(infra.NewQueuePublisher),

        // Repository Providers
        fx.Provide(adapter.NewMySQLAlbumRepository),
        fx.Provide(adapter.NewMySQLAlbumMediaRepository),
        fx.Provide(adapter.NewMySQLCommentRepository),
        fx.Provide(adapter.NewMySQLHighlightVideoRepository),
        fx.Provide(adapter.NewRedisCache),

        // External Service Adapters
        fx.Provide(adapter.NewHTTPPermissionServiceAdapter),
        fx.Provide(adapter.NewHTTPEventServiceAdapter),
        fx.Provide(adapter.NewHTTPStorageServiceAdapter),
        fx.Provide(adapter.NewQueueEventPublisher),   // QueuePort: recuerdo.album.*
        fx.Provide(adapter.NewQueueJobAdapter),       // Beta: Asynq、本番: OCI Queue

        // Use Case Services
        fx.Provide(application.NewCreateAlbumUseCase),
        fx.Provide(application.NewGetEventAlbumUseCase),
        fx.Provide(application.NewAddMediaUseCase),
        fx.Provide(application.NewGetAlbumCommentsUseCase),
        // ... other use cases

        // HTTP Handlers / Controllers
        fx.Provide(adapter.NewAlbumController),
        fx.Provide(adapter.NewMediaController),
        fx.Provide(adapter.NewCommentController),

        // HTTP Router
        fx.Provide(adapter.NewGinRouter),

        // Server
        fx.Provide(infra.NewServer),

        // Invoke: Start server
        fx.Invoke(startServer),
    )

    app.Run()
}

func startServer(server *http.Server) error {
    return server.ListenAndServe()
}

// test/unit/domain/album_test.go
package domain_test

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "recuerdo/album-svc/internal/domain"
)

func TestNewAlbumTitle_ValidInput(t *testing.T) {
    title, err := domain.NewAlbumTitle("My Album")
    assert.NoError(t, err)
    assert.Equal(t, "My Album", title.Value)
}

func TestNewAlbumTitle_TooShort(t *testing.T) {
    _, err := domain.NewAlbumTitle("")
    assert.Error(t, err)
    assert.Contains(t, err.Error(), "must be 1-200 characters")
}

func TestNewAlbumTitle_TooLong(t *testing.T) {
    longTitle := strings.Repeat("a", 201)
    _, err := domain.NewAlbumTitle(longTitle)
    assert.Error(t, err)
}

// test/unit/application/add_media_test.go
package application_test

import (
    "context"
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "recuerdo/album-svc/internal/application"
    "recuerdo/album-svc/internal/domain"
)

type MockAlbumRepository struct {
    mock.Mock
}

func (m *MockAlbumRepository) GetByID(ctx context.Context, albumID string) (*domain.Album, error) {
    args := m.Called(ctx, albumID)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*domain.Album), args.Error(1)
}

type MockPermissionService struct {
    mock.Mock
}

func (m *MockPermissionService) CheckAccess(ctx context.Context, userID, albumID string, requiredRoles []domain.Role) (domain.Role, error) {
    args := m.Called(ctx, userID, albumID, requiredRoles)
    return domain.Role(args.String(0)), args.Error(1)
}

func TestAddMedia_Success(t *testing.T) {
    // Setup
    mockAlbumRepo := new(MockAlbumRepository)
    mockPermissionSvc := new(MockPermissionService)
    mockMediaRepo := new(MockAlbumMediaRepository)
    mockEventPub := new(MockEventPublisher)
    mockJobQueue := new(MockJobQueue)

    album := &domain.Album{
        ID:    "album-1",
        OrgID: "org-1",
    }

    mockAlbumRepo.On("GetByID", mock.Anything, "album-1").Return(album, nil)
    mockPermissionSvc.On("CheckAccess", mock.Anything, "user-1", "album-1", 
        []domain.Role{domain.RoleContributor, domain.RoleOwner}).Return(domain.RoleContributor, nil)
    mockMediaRepo.On("Save", mock.Anything, mock.Anything).Return(nil)
    mockEventPub.On("PublishMediaAdded", mock.Anything, mock.Anything).Return(nil)
    mockJobQueue.On("EnqueueGenerateHighlightVideo", mock.Anything, "album-1", mock.Anything).Return(nil)

    // Execute
    usecase := application.NewAddMediaUseCase(
        mockAlbumRepo,
        mockMediaRepo,
        mockPermissionSvc,
        mockEventPub,
        mockJobQueue,
    )

    input := &application.AddMediaInput{
        AlbumID:   "album-1",
        MediaID:   "media-1",
        UploadedBy: "user-1",
        Caption:   "Summer memories",
    }

    output, err := usecase.Execute(context.Background(), input)

    // Assert
    assert.NoError(t, err)
    assert.NotNil(t, output)
    assert.Equal(t, "media-1", output.MediaID)
    mockAlbumRepo.AssertExpectations(t)
    mockPermissionSvc.AssertExpectations(t)
}

func TestAddMedia_AccessDenied(t *testing.T) {
    mockAlbumRepo := new(MockAlbumRepository)
    mockPermissionSvc := new(MockPermissionService)

    album := &domain.Album{ID: "album-1"}
    mockAlbumRepo.On("GetByID", mock.Anything, "album-1").Return(album, nil)
    mockPermissionSvc.On("CheckAccess", mock.Anything, "user-1", "album-1", mock.Anything).
        Return(domain.RoleViewer, domain.ErrAccessDenied)

    usecase := application.NewAddMediaUseCase(mockAlbumRepo, nil, mockPermissionSvc, nil, nil)

    input := &application.AddMediaInput{
        AlbumID:   "album-1",
        UploadedBy: "user-1",
    }

    _, err := usecase.Execute(context.Background(), input)
    assert.Error(t, err)
    assert.Equal(t, domain.ErrAccessDenied, err)
}

// test/unit/adapter/http/album_controller_test.go
package http_test

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
    "github.com/gin-gonic/gin"
    "github.com/stretchr/testify/assert"
    "recuerdo/album-svc/internal/adapter/http"
)

func TestGetEventAlbum_Success(t *testing.T) {
    gin.SetMode(gin.TestMode)
    router := gin.New()

    // Setup mock use case
    mockUseCase := new(MockGetEventAlbumUseCase)
    mockUseCase.On("Execute", mock.Anything, mock.Anything).Return(&application.AlbumOutput{
        ID:    "album-1",
        Title: "Summer Reunion 2026",
    }, nil)

    controller := http.NewAlbumController(mockUseCase)
    router.GET("/api/orgs/:org_id/events/:event_id/album", controller.GetEventAlbum)

    // Execute
    req := httptest.NewRequest(http.MethodGet, "/api/orgs/org-1/events/event-1/album", nil)
    req.Header.Set("X-User-ID", "user-1")
    w := httptest.NewRecorder()

    router.ServeHTTP(w, req)

    // Assert
    assert.Equal(t, http.StatusOK, w.Code)
    var resp struct {
        Data struct {
            ID    string `json:"id"`
            Title string `json:"title"`
        } `json:"data"`
    }
    json.NewDecoder(w.Body).Decode(&resp)
    assert.Equal(t, "album-1", resp.Data.ID)
}

// test/integration/repository/MySQL_album_test.go
package repository_test

import (
    "context"
    "testing"
    "github.com/stretchr/testify/assert"
    "recuerdo/album-svc/internal/adapter/repository"
    "recuerdo/album-svc/test/integration"
)

func TestMySQLAlbumRepository_Save(t *testing.T) {
    db := integration.SetupTestDB(t)
    defer db.Close()

    repo := repository.NewMySQLAlbumRepository(db)
    album := &domain.Album{
        ID:    "album-1",
        OrgID: "org-1",
        Title: domain.AlbumTitle{Value: "Test Album"},
        CreatedBy: "user-1",
    }

    err := repo.Save(context.Background(), album)
    assert.NoError(t, err)

    retrieved, err := repo.GetByID(context.Background(), "album-1")
    assert.NoError(t, err)
    assert.Equal(t, album.ID, retrieved.ID)
}

// internal/domain/errors.go

package domain

import "errors"

var (
    // Album errors
    ErrAlbumNotFound          = errors.New("album not found")
    ErrAlbumAlreadyExists     = errors.New("album already exists")
    ErrAlbumArchived          = errors.New("album is archived")
    ErrInvalidAlbumTitle      = errors.New("invalid album title")

    // Media errors
    ErrMediaNotFound          = errors.New("media not found")
    ErrMediaAlreadyInAlbum    = errors.New("media already in this album")
    ErrInvalidPosition        = errors.New("invalid position")
    ErrMediaCountInsufficient = errors.New("album must have at least 10 media items")

    // Comment errors
    ErrCommentNotFound        = errors.New("comment not found")
    ErrInvalidCommentBody     = errors.New("invalid comment body")

    // Access control errors
    ErrAccessDenied           = errors.New("access denied")
    ErrInvalidRole            = errors.New("invalid role")
    ErrNoOwner                = errors.New("album must have at least one owner")

    // Highlight video errors
    ErrHighlightVideoInProgress = errors.New("highlight video generation in progress")
    ErrHighlightVideoFailed     = errors.New("highlight video generation failed")

    // Event errors
    ErrEventNotFound          = errors.New("event not found")
    ErrEventAlbumAlreadyExists = errors.New("event already has an album")

    // Validation errors
    ErrInvalidInput           = errors.New("invalid input")
    ErrMissingField           = errors.New("missing required field")
)

// internal/adapter/http/error_handler.go

package http

import (
    "github.com/gin-gonic/gin"
    "recuerdo/album-svc/internal/domain"
)

func ErrorHandlerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()

        if len(c.Errors) > 0 {
            err := c.Errors[0].Err

            // Domain errors
            switch err {
            case domain.ErrAlbumNotFound:
                c.JSON(404, gin.H{"error": "Album not found"})
            case domain.ErrAccessDenied:
                c.JSON(403, gin.H{"error": "You do not have permission to access this album"})
            case domain.ErrInvalidAlbumTitle:
                c.JSON(400, gin.H{"error": "Album title must be 1-200 characters"})
            default:
                c.JSON(500, gin.H{"error": "Internal server error"})
            }
        }
    }
}