- PUT/DELETE /wishlist/{artist} and GET /wishlist: the artists I want.
- POST/DELETE /discover/{artist}/dismiss and GET /discover/dismissed: the
artists I am not interested in. An artist is wished or dismissed, never both,
and both lists are mine alone.
- Discover never suggests a dismissed artist, does not use one as a seed taken
from my listening, and marks the wished ones it shows (wishlisted).
- New artist_feedback table (migration 0012, SQLite and PostgreSQL), removed
with the account.
- An artist I marked is not cleaned up when the list that named it is replaced,
and goes when its last mark is taken off and nobody names it. Taking a
provider's data back still removes what only it named, marks included.
- Spec, contract test and README updated.
Closes #35
219 lines
7.8 KiB
Go
219 lines
7.8 KiB
Go
// Package httpapi is the first-party REST API (/api/v1).
|
|
//
|
|
// Handlers stay thin: they validate and serialize, then call services.
|
|
package httpapi
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"go.uber.org/zap"
|
|
|
|
"codeberg.org/squidd/sonda/internal/auth"
|
|
"codeberg.org/squidd/sonda/internal/catalog"
|
|
"codeberg.org/squidd/sonda/internal/discover"
|
|
"codeberg.org/squidd/sonda/internal/discovery"
|
|
"codeberg.org/squidd/sonda/internal/feedback"
|
|
"codeberg.org/squidd/sonda/internal/library"
|
|
"codeberg.org/squidd/sonda/internal/listening"
|
|
"codeberg.org/squidd/sonda/internal/providers"
|
|
"codeberg.org/squidd/sonda/internal/streaming"
|
|
"codeberg.org/squidd/sonda/internal/taste"
|
|
"codeberg.org/squidd/sonda/internal/usersettings"
|
|
)
|
|
|
|
// maxBodyBytes bounds every request body.
|
|
const maxBodyBytes = 64 << 10
|
|
|
|
type authService interface {
|
|
Register(ctx context.Context, username, password string) (auth.User, error)
|
|
Login(ctx context.Context, username, password string) (auth.Session, error)
|
|
Refresh(ctx context.Context, refreshToken string) (auth.Session, error)
|
|
Logout(ctx context.Context, refreshToken string) error
|
|
User(ctx context.Context, id int64) (auth.User, error)
|
|
ChangePassword(ctx context.Context, userID int64, current, next string) error
|
|
ListUsers(ctx context.Context) ([]auth.User, error)
|
|
CreateUser(ctx context.Context, username, password string, isAdmin bool) (auth.User, error)
|
|
SetAdmin(ctx context.Context, id int64, isAdmin bool) (auth.User, error)
|
|
ResetPassword(ctx context.Context, id int64, password string) error
|
|
DeleteUser(ctx context.Context, id int64) error
|
|
}
|
|
|
|
type tokenParser interface {
|
|
Parse(token string) (auth.Claims, error)
|
|
}
|
|
|
|
type listenService interface {
|
|
Record(ctx context.Context, e listening.Event) (listening.Result, error)
|
|
List(ctx context.Context, userID int64, f listening.Filter) (listening.Page, error)
|
|
}
|
|
|
|
type streamService interface {
|
|
Open(ctx context.Context, trackID int64) (*streaming.Stream, error)
|
|
}
|
|
|
|
type scanService interface {
|
|
Start(full bool) error
|
|
StartLibrary(id int64, full bool) error
|
|
Status() library.Status
|
|
}
|
|
|
|
type providerService interface {
|
|
List(ctx context.Context) ([]providers.Info, error)
|
|
Update(ctx context.Context, name string, p providers.Patch) (providers.Info, error)
|
|
Test(ctx context.Context, name string) (providers.TestResult, error)
|
|
Purge(ctx context.Context, name string) (providers.Purged, error)
|
|
}
|
|
|
|
type tagService interface {
|
|
Tags(ctx context.Context, artistID int64) (discovery.TagResult, error)
|
|
}
|
|
|
|
type discoveryService interface {
|
|
Similar(ctx context.Context, artistID int64, limit int) (discovery.Result, error)
|
|
}
|
|
|
|
type discoverService interface {
|
|
Discover(ctx context.Context, userID int64, q discover.Query) (discover.Result, error)
|
|
}
|
|
|
|
type feedbackService interface {
|
|
Add(ctx context.Context, userID, artistID int64, kind feedback.Kind) error
|
|
Remove(ctx context.Context, userID, artistID int64, kind feedback.Kind) error
|
|
List(ctx context.Context, userID int64, kind feedback.Kind, p feedback.Page) (feedback.Listing, error)
|
|
}
|
|
|
|
type tasteService interface {
|
|
Taste(ctx context.Context, userID int64, limit int) (taste.Profile, error)
|
|
}
|
|
|
|
type userSettingsService interface {
|
|
Get(ctx context.Context, userID int64) (usersettings.Settings, error)
|
|
Update(ctx context.Context, userID int64, p usersettings.Patch) (usersettings.Settings, error)
|
|
}
|
|
|
|
type catalogService interface {
|
|
Artists(ctx context.Context, f catalog.Filter) (catalog.Page[catalog.Artist], error)
|
|
Albums(ctx context.Context, f catalog.Filter) (catalog.Page[catalog.Album], error)
|
|
Tracks(ctx context.Context, f catalog.Filter) (catalog.Page[catalog.Track], error)
|
|
Artist(ctx context.Context, id int64) (catalog.Artist, error)
|
|
Album(ctx context.Context, id int64) (catalog.Album, error)
|
|
Track(ctx context.Context, id int64) (catalog.Track, error)
|
|
}
|
|
|
|
type libraryService interface {
|
|
List(ctx context.Context) ([]library.Library, error)
|
|
Create(ctx context.Context, name, path string) (library.Library, error)
|
|
Update(ctx context.Context, id int64, name, path *string) (library.Library, error)
|
|
Delete(ctx context.Context, id int64) error
|
|
}
|
|
|
|
// Deps are the services the API needs.
|
|
type Deps struct {
|
|
Logger *zap.Logger
|
|
Auth authService
|
|
Tokens tokenParser
|
|
Listening listenService
|
|
Scan scanService
|
|
Libraries libraryService
|
|
Catalog catalogService
|
|
Providers providerService
|
|
Discovery discoveryService
|
|
Tags tagService
|
|
Taste tasteService
|
|
Discover discoverService
|
|
Feedback feedbackService
|
|
Settings userSettingsService
|
|
Streams streamService
|
|
}
|
|
|
|
// NewRouter builds the gin engine with all routes.
|
|
func NewRouter(d Deps) *gin.Engine {
|
|
r := gin.New()
|
|
_ = r.SetTrustedProxies(nil) // use the socket address; no forwarded-header trust yet
|
|
r.Use(gin.Recovery(), limitBody(maxBodyBytes), requestLog(d.Logger))
|
|
r.NoRoute(func(c *gin.Context) { writeError(c, http.StatusNotFound, "not_found", "no such route") })
|
|
|
|
v1 := r.Group("/api/v1")
|
|
v1.GET("/health", health)
|
|
registerDocs(r, v1)
|
|
|
|
a := &authHandlers{svc: d.Auth}
|
|
v1.POST("/auth/register", a.register)
|
|
v1.POST("/auth/login", a.login)
|
|
v1.POST("/auth/refresh", a.refresh)
|
|
v1.POST("/auth/logout", a.logout)
|
|
|
|
// Any signed-in user.
|
|
protected := v1.Group("", requireAuth(d.Tokens, d.Auth, false))
|
|
protected.GET("/auth/me", a.me)
|
|
protected.POST("/auth/password", a.changePassword)
|
|
l := &listenHandlers{svc: d.Listening}
|
|
protected.POST("/listens", l.record)
|
|
protected.GET("/listens", l.list)
|
|
|
|
ts := &tasteHandlers{svc: d.Taste}
|
|
protected.GET("/me/taste", ts.taste)
|
|
dc := &discoverHandlers{svc: d.Discover}
|
|
protected.GET("/discover", dc.discover)
|
|
fb := &feedbackHandlers{svc: d.Feedback}
|
|
protected.GET("/discover/dismissed", fb.list(feedback.Dismissed))
|
|
protected.POST("/discover/:id/dismiss", fb.add(feedback.Dismissed))
|
|
protected.DELETE("/discover/:id/dismiss", fb.remove(feedback.Dismissed))
|
|
protected.GET("/wishlist", fb.list(feedback.Wishlist))
|
|
protected.PUT("/wishlist/:id", fb.add(feedback.Wishlist))
|
|
protected.DELETE("/wishlist/:id", fb.remove(feedback.Wishlist))
|
|
us := &userSettingsHandlers{svc: d.Settings}
|
|
protected.GET("/me/settings", us.get)
|
|
protected.PATCH("/me/settings", us.update)
|
|
|
|
lib := &libraryHandlers{scan: d.Scan}
|
|
protected.GET("/library/scan", lib.scanStatus)
|
|
|
|
cat := &catalogHandlers{svc: d.Catalog}
|
|
protected.GET("/artists", cat.listArtists)
|
|
protected.GET("/artists/:id", cat.getArtist)
|
|
disc := &discoveryHandlers{svc: d.Discovery}
|
|
protected.GET("/artists/:id/similar", disc.similar)
|
|
tg := &tagsHandlers{svc: d.Tags}
|
|
protected.GET("/artists/:id/tags", tg.tags)
|
|
protected.GET("/albums", cat.listAlbums)
|
|
protected.GET("/albums/:id", cat.getAlbum)
|
|
protected.GET("/tracks", cat.listTracks)
|
|
protected.GET("/tracks/:id", cat.getTrack)
|
|
|
|
// Audio loaded by an <audio> element cannot send headers, so this route also
|
|
// takes the access token as a query parameter. It never records a listen.
|
|
st := &streamHandlers{svc: d.Streams}
|
|
audio := v1.Group("", requireAuth(d.Tokens, d.Auth, true))
|
|
audio.GET("/tracks/:id/stream", st.stream)
|
|
audio.HEAD("/tracks/:id/stream", st.stream)
|
|
|
|
// Admins only.
|
|
admin := protected.Group("", requireAdmin(d.Auth))
|
|
admin.POST("/library/scan", lib.startScan)
|
|
libs := &librariesHandlers{svc: d.Libraries}
|
|
admin.GET("/libraries", libs.list)
|
|
admin.POST("/libraries", libs.create)
|
|
admin.PATCH("/libraries/:id", libs.update)
|
|
admin.DELETE("/libraries/:id", libs.remove)
|
|
admin.POST("/libraries/:id/scan", lib.startLibraryScan)
|
|
prov := &providersHandlers{svc: d.Providers}
|
|
admin.GET("/providers", prov.list)
|
|
admin.PUT("/providers/:name", prov.update)
|
|
admin.POST("/providers/:name/test", prov.test)
|
|
admin.DELETE("/providers/:name/data", prov.purge)
|
|
u := &usersHandlers{svc: d.Auth}
|
|
admin.GET("/users", u.list)
|
|
admin.POST("/users", u.create)
|
|
admin.PATCH("/users/:id", u.update)
|
|
admin.PUT("/users/:id/password", u.resetPassword)
|
|
admin.DELETE("/users/:id", u.remove)
|
|
|
|
return r
|
|
}
|
|
|
|
func health(c *gin.Context) {
|
|
c.JSON(http.StatusOK, gin.H{"status": "ok"})
|
|
}
|