Add SearchAlbum endpoint

internal/provider/musicbrainz/provider.go

@@ -91,6 +91,49 @@ func (p *Provider) GetAlbum(ctx context.Context, id string) (*domain.Album, erro
 	return mapAlbum(mb, release), nil
 }
 
+func (p *Provider) SearchAlbums(ctx context.Context, query string, artist string, limit, offset int) (*domain.SearchResult[domain.Album], error) {
+	if limit <= 0 || limit > 100 {
+		limit = 25
+	}
+
+	var luceneQuery string
+	if artist != "" && query != "" {
+		luceneQuery = fmt.Sprintf("releasegroup:%s AND artist:%s", escapeQuery(query), escapeQuery(artist))
+	} else if artist != "" {
+		luceneQuery = fmt.Sprintf("artist:%s", escapeQuery(artist))
+	} else {
+		luceneQuery = fmt.Sprintf("releasegroup:%s", escapeQuery(query))
+	}
+
+	data, err := p.client.search(ctx, "release-group", luceneQuery, limit, offset)
+	if err != nil {
+		return nil, fmt.Errorf("search albums: %w", err)
+	}
+
+	var resp struct {
+		Count         int               `json:"count"`
+		Offset        int               `json:"offset"`
+		ReleaseGroups []*mbReleaseGroup `json:"release-groups"`
+	}
+	if err := decodeInto(data, &resp); err != nil {
+		return nil, err
+	}
+
+	result := &domain.SearchResult[domain.Album]{
+		Total:  resp.Count,
+		Limit:  limit,
+		Offset: offset,
+	}
+
+	for _, mb := range resp.ReleaseGroups {
+		if album := mapAlbum(mb, nil); album != nil {
+			result.Items = append(result.Items, *album)
+		}
+	}
+
+	return result, nil
+}
+
 func (p *Provider) GetArtistAlbums(ctx context.Context, artistID string, limit, offset int) (*domain.SearchResult[domain.Album], error) {
 	if limit <= 0 || limit > 100 {
 		limit = 25

internal/provider/provider.go

@@ -13,6 +13,7 @@ type Provider interface {
 	SearchArtists(ctx context.Context, query string, limit, offset int) (*domain.SearchResult[domain.Artist], error)
 
 	GetAlbum(ctx context.Context, id string) (*domain.Album, error)
+	SearchAlbums(ctx context.Context, query string, artist string, limit, offset int) (*domain.SearchResult[domain.Album], error)
 	GetArtistAlbums(ctx context.Context, artistID string, limit, offset int) (*domain.SearchResult[domain.Album], error)
 
 	GetTrack(ctx context.Context, id string) (*domain.Track, error)

internal/server/server.go

@@ -86,6 +86,33 @@ func (s *MetadataServer) SearchArtists(ctx context.Context, req *metadatav1.Sear
 	return resp, nil
 }
 
+func (s *MetadataServer) SearchAlbums(ctx context.Context, req *metadatav1.SearchAlbumsRequest) (*metadatav1.SearchAlbumsResponse, error) {
+	svc, err := s.getService(req.Provider)
+	if err != nil {
+		return nil, err
+	}
+
+	limit := int(req.Limit)
+	if limit <= 0 {
+		limit = 25
+	}
+
+	result, err := svc.SearchAlbums(ctx, req.Query, req.Artist, limit, int(req.Offset))
+	if err != nil {
+		return nil, toGRPCError(err)
+	}
+
+	resp := &metadatav1.SearchAlbumsResponse{
+		Total: int32(result.Total),
+	}
+
+	for _, a := range result.Items {
+		resp.Albums = append(resp.Albums, toProtoAlbum(&a))
+	}
+
+	return resp, nil
+}
+
 func (s *MetadataServer) GetAlbum(ctx context.Context, req *metadatav1.GetAlbumRequest) (*metadatav1.Album, error) {
 	svc, err := s.getService(req.Provider)
 	if err != nil {

internal/service/metadata.go

@@ -60,6 +60,10 @@ func (s *MetadataService) SearchArtists(ctx context.Context, query string, limit
 	return s.provider.SearchArtists(ctx, query, limit, offset)
 }
 
+func (s *MetadataService) SearchAlbums(ctx context.Context, query string, artist string, limit, offset int) (*domain.SearchResult[domain.Album], error) {
+	return s.provider.SearchAlbums(ctx, query, artist, limit, offset)
+}
+
 func (s *MetadataService) GetAlbum(ctx context.Context, id string) (*domain.Album, error) {
 	album, err := s.albums.GetByExternalID(ctx, s.provider.Name(), id)
 	if err == nil {