feat(audiobooks): POST /collections — ABS collection create
First handler of the collections surface. Body {name, description?,
isPublic?} returns the created collection in full-shape (empty
books[]). Backed by the new CollectionStore dependency (nil-safe:
handler returns 503 when unwired). Adds the in-memory test harness
(memCollectionStore + dispatchABSWithParams) that the rest of the
collections suite will reuse.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
RXWatcher
co-authored by
Claude Opus 4.7
Claude Opus 4.7
parent
d89f6197f5
commit
7bdff1141c
@@ -0,0 +1,118 @@
|
||||
package abs
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/oklog/ulid/v2"
|
||||
)
|
||||
|
||||
// collectionBody is the JSON body for POST and PATCH /collections[/{id}].
|
||||
// All fields are optional on PATCH; name is required on POST (checked
|
||||
// in the handler, not via tag-driven validation).
|
||||
type collectionBody struct {
|
||||
Name *string `json:"name"`
|
||||
Description *string `json:"description"`
|
||||
IsPublic *bool `json:"isPublic"`
|
||||
}
|
||||
|
||||
// handleCreateCollection — POST /collections.
|
||||
// Body: {name, description?, isPublic?}. Returns the created collection
|
||||
// in full-shape (with an empty books[] array).
|
||||
func (h *Handler) handleCreateCollection(w http.ResponseWriter, r *http.Request) {
|
||||
a, ok := absAuthFrom(r)
|
||||
if !ok || a.UserID == "" {
|
||||
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
if h.deps.CollectionStore == nil {
|
||||
http.Error(w, "collection store unavailable", http.StatusServiceUnavailable)
|
||||
return
|
||||
}
|
||||
|
||||
var body collectionBody
|
||||
if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
|
||||
http.Error(w, "invalid body", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if body.Name == nil || *body.Name == "" {
|
||||
http.Error(w, "name required", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
c := Collection{
|
||||
ID: ulid.Make().String(),
|
||||
UserID: a.UserID,
|
||||
ProfileID: a.ProfileID,
|
||||
Name: *body.Name,
|
||||
}
|
||||
if body.Description != nil {
|
||||
c.Description = *body.Description
|
||||
}
|
||||
if body.IsPublic != nil {
|
||||
c.IsPublic = *body.IsPublic
|
||||
}
|
||||
if err := h.deps.CollectionStore.CreateCollection(r.Context(), c); err != nil {
|
||||
slog.Error("abs collection create failed", "err", err, "user", a.UserID)
|
||||
http.Error(w, "collection persist failed", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
// Re-fetch to pick up server-set timestamps.
|
||||
persisted, err := h.deps.CollectionStore.GetCollection(r.Context(), c.ID)
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
persisted = c
|
||||
} else if err != nil {
|
||||
slog.Warn("abs collection get-after-create failed", "err", err, "id", c.ID)
|
||||
persisted = c
|
||||
}
|
||||
writeJSON(w, http.StatusOK, h.collectionFullShape(r, persisted))
|
||||
}
|
||||
|
||||
// collectionFullShape renders a Collection in full-shape, hydrating
|
||||
// books[] via MediaStore. Errors during hydration degrade to bare
|
||||
// {id, libraryId} entries so the response always reflects DB truth.
|
||||
func (h *Handler) collectionFullShape(r *http.Request, c Collection) map[string]any {
|
||||
books := h.collectionBooks(r, c.ID)
|
||||
return collectionToABS(c, books)
|
||||
}
|
||||
|
||||
// collectionBooks resolves the items in a collection to wire-shape book
|
||||
// entries, hydrating titles/authors via MediaStore. Returns a non-nil
|
||||
// slice (possibly empty) so collectionToABS emits the books key.
|
||||
func (h *Handler) collectionBooks(r *http.Request, collectionID string) []map[string]any {
|
||||
if h.deps.CollectionStore == nil {
|
||||
return []map[string]any{}
|
||||
}
|
||||
rows, err := h.deps.CollectionStore.ListCollectionItems(r.Context(), collectionID)
|
||||
if err != nil {
|
||||
slog.Warn("abs collection list-items failed", "err", err, "collection", collectionID)
|
||||
return []map[string]any{}
|
||||
}
|
||||
lib := h.resolveDefaultLibrary(r.Context())
|
||||
libID := audiobookLibraryID(lib)
|
||||
out := make([]map[string]any, 0, len(rows))
|
||||
for _, it := range rows {
|
||||
entry := map[string]any{
|
||||
"id": it.LibraryItemID,
|
||||
"libraryId": libID,
|
||||
}
|
||||
if item, err := h.deps.MediaStore.GetAudiobookByID(r.Context(), it.LibraryItemID); err == nil && item != nil {
|
||||
entry["media"] = map[string]any{
|
||||
"metadata": map[string]any{
|
||||
"title": item.Title,
|
||||
},
|
||||
}
|
||||
}
|
||||
out = append(out, entry)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// chiURLID is a tiny shim around chi.URLParam(r, "id") so handler call
|
||||
// sites read uniformly. Inlined where unambiguous.
|
||||
func chiURLID(r *http.Request) string { return chi.URLParam(r, "id") }
|
||||
@@ -0,0 +1,245 @@
|
||||
package abs
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"sort"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
|
||||
"github.com/Silo-Server/silo-server/internal/models"
|
||||
)
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// In-memory fakes
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// memCollectionStore is an in-memory CollectionStore for handler tests.
|
||||
// Owner identity is tracked alongside the row (production stores user_id
|
||||
// and profile_id; we mirror that so List can filter correctly).
|
||||
type memCollectionStore struct {
|
||||
mu sync.Mutex
|
||||
rows map[string]Collection // id -> row
|
||||
items map[string][]CollectionItem // collection_id -> items
|
||||
}
|
||||
|
||||
func newMemCollectionStore() *memCollectionStore {
|
||||
return &memCollectionStore{
|
||||
rows: map[string]Collection{},
|
||||
items: map[string][]CollectionItem{},
|
||||
}
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) ListUserCollections(_ context.Context, userID, profileID string) ([]Collection, error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
out := make([]Collection, 0)
|
||||
for _, c := range m.rows {
|
||||
if c.UserID == userID && c.ProfileID == profileID {
|
||||
out = append(out, c)
|
||||
}
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].CreatedAt.After(out[j].CreatedAt) })
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) GetCollection(_ context.Context, id string) (Collection, error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
c, ok := m.rows[id]
|
||||
if !ok {
|
||||
return Collection{}, ErrNotFound
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) CreateCollection(_ context.Context, c Collection) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.rows[c.ID] = c
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) UpdateCollection(_ context.Context, c Collection) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
existing, ok := m.rows[c.ID]
|
||||
if !ok {
|
||||
return ErrNotFound
|
||||
}
|
||||
existing.Name = c.Name
|
||||
existing.Description = c.Description
|
||||
existing.IsPublic = c.IsPublic
|
||||
existing.UpdatedAt = time.Now()
|
||||
m.rows[c.ID] = existing
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) DeleteCollection(_ context.Context, id string) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
delete(m.rows, id)
|
||||
delete(m.items, id) // cascade
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) ListCollectionItems(_ context.Context, collectionID string) ([]CollectionItem, error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
items := m.items[collectionID]
|
||||
out := make([]CollectionItem, len(items))
|
||||
copy(out, items)
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].AddedAt.Before(out[j].AddedAt) })
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) AddCollectionItem(_ context.Context, collectionID, libraryItemID string) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
for _, it := range m.items[collectionID] {
|
||||
if it.LibraryItemID == libraryItemID {
|
||||
return nil // ON CONFLICT DO NOTHING
|
||||
}
|
||||
}
|
||||
m.items[collectionID] = append(m.items[collectionID], CollectionItem{
|
||||
CollectionID: collectionID,
|
||||
LibraryItemID: libraryItemID,
|
||||
AddedAt: time.Now(),
|
||||
})
|
||||
if c, ok := m.rows[collectionID]; ok {
|
||||
c.UpdatedAt = time.Now()
|
||||
m.rows[collectionID] = c
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *memCollectionStore) RemoveCollectionItem(_ context.Context, collectionID, libraryItemID string) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
items := m.items[collectionID]
|
||||
out := items[:0]
|
||||
for _, it := range items {
|
||||
if it.LibraryItemID != libraryItemID {
|
||||
out = append(out, it)
|
||||
}
|
||||
}
|
||||
m.items[collectionID] = out
|
||||
if c, ok := m.rows[collectionID]; ok {
|
||||
c.UpdatedAt = time.Now()
|
||||
m.rows[collectionID] = c
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Test harness
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
type collectionsHarness struct {
|
||||
H *Handler
|
||||
Coll *memCollectionStore
|
||||
Pub *recordingPublisher
|
||||
}
|
||||
|
||||
func newCollectionsHarness(t *testing.T, knownItems ...string) *collectionsHarness {
|
||||
t.Helper()
|
||||
known := map[string]*models.MediaItem{}
|
||||
for _, id := range knownItems {
|
||||
known[id] = nil
|
||||
}
|
||||
pub := &recordingPublisher{}
|
||||
store := newMemCollectionStore()
|
||||
h := New(Dependencies{
|
||||
MediaStore: &stubMediaStore{known: known},
|
||||
CollectionStore: store,
|
||||
Publisher: pub,
|
||||
})
|
||||
return &collectionsHarness{H: h, Coll: store, Pub: pub}
|
||||
}
|
||||
|
||||
// dispatchABSWithParams drives a handler directly with arbitrary URL
|
||||
// params + injected ctxAuth, bypassing the bearerAuth middleware.
|
||||
// Generalised version of dispatchBookmark for surfaces with different
|
||||
// URL-param shapes (collections use {id}, {bookId}; playlists use
|
||||
// {id}, {libraryItemId}, {episodeId}).
|
||||
func dispatchABSWithParams(method, path string, params map[string]string, body []byte, userID, profileID string, fn http.HandlerFunc) *httptest.ResponseRecorder {
|
||||
var req *http.Request
|
||||
if body != nil {
|
||||
req = httptest.NewRequest(method, path, bytes.NewReader(body))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
} else {
|
||||
req = httptest.NewRequest(method, path, nil)
|
||||
}
|
||||
rctx := chi.NewRouteContext()
|
||||
for k, v := range params {
|
||||
rctx.URLParams.Add(k, v)
|
||||
}
|
||||
ctx := context.WithValue(req.Context(), chi.RouteCtxKey, rctx)
|
||||
ctx = context.WithValue(ctx, ctxKey{}, ctxAuth{UserID: userID, ProfileID: profileID})
|
||||
req = req.WithContext(ctx)
|
||||
rec := httptest.NewRecorder()
|
||||
fn(rec, req)
|
||||
return rec
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestCollection_Create_ReturnsFullShape(t *testing.T) {
|
||||
hb := newCollectionsHarness(t)
|
||||
body := []byte(`{"name":"Favorites","description":"My top picks"}`)
|
||||
rec := dispatchABSWithParams(http.MethodPost, "/api/collections", nil, body, "1", "", hb.H.handleCreateCollection)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want 200; body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var got map[string]any
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil {
|
||||
t.Fatalf("decode: %v; body=%s", err, rec.Body.String())
|
||||
}
|
||||
if got["name"] != "Favorites" {
|
||||
t.Errorf("name = %v, want Favorites", got["name"])
|
||||
}
|
||||
if got["description"] != "My top picks" {
|
||||
t.Errorf("description = %v, want 'My top picks'", got["description"])
|
||||
}
|
||||
if got["userId"] != "1" {
|
||||
t.Errorf("userId = %v, want 1", got["userId"])
|
||||
}
|
||||
if got["isPublic"] != false {
|
||||
t.Errorf("isPublic = %v, want false", got["isPublic"])
|
||||
}
|
||||
for _, k := range []string{"id", "lastUpdate", "createdAt"} {
|
||||
if _, ok := got[k]; !ok {
|
||||
t.Errorf("response missing %q", k)
|
||||
}
|
||||
}
|
||||
books, ok := got["books"].([]any)
|
||||
if !ok || len(books) != 0 {
|
||||
t.Errorf("books = %v (type %T), want empty array", got["books"], got["books"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollection_Create_NameRequired_400(t *testing.T) {
|
||||
hb := newCollectionsHarness(t)
|
||||
body := []byte(`{"description":"only"}`)
|
||||
rec := dispatchABSWithParams(http.MethodPost, "/api/collections", nil, body, "1", "", hb.H.handleCreateCollection)
|
||||
if rec.Code != http.StatusBadRequest {
|
||||
t.Errorf("status = %d, want 400; body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollection_Create_InvalidBody_400(t *testing.T) {
|
||||
hb := newCollectionsHarness(t)
|
||||
rec := dispatchABSWithParams(http.MethodPost, "/api/collections", nil, []byte(`{not json`), "1", "", hb.H.handleCreateCollection)
|
||||
if rec.Code != http.StatusBadRequest {
|
||||
t.Errorf("status = %d, want 400; body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -182,6 +182,9 @@ type Dependencies struct {
|
||||
// POST/PATCH/DELETE /me/item/{itemId}/bookmark endpoints. May be
|
||||
// nil; handlers respond 503 when unset.
|
||||
BookmarkStore BookmarkStore
|
||||
// CollectionStore persists ABS user-collection rows (migrations 149 + 150).
|
||||
// May be nil; handlers respond 503 when unset.
|
||||
CollectionStore CollectionStore
|
||||
// SocketIO is the Socket.io server mounted at /abs/socket.io/. May be nil;
|
||||
// the route is only registered when a non-nil value is supplied.
|
||||
SocketIO SocketIOServer
|
||||
|
||||
Reference in New Issue
Block a user