Fix creating a playlist with description

The description was completely ignored by accident.

Author: ironsmile

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## v1.6.1 - 2025-08-10
+
+Fixes a bug where the description was ignored when set in the API request for creating a brand new playlist.
+
 ## v1.6.0 - 2025-06-07
 
 This one of the biggest improvements of Euterpe so far. As always, it retains API backwards compatibility with older Euterpe versions.

src/playlists/manager.go

@@ -201,20 +201,19 @@ func (m *manager) List(ctx context.Context, args ListArgs) ([]Playlist, error) {
 // Create implements Playlister.
 func (m *manager) Create(
 	ctx context.Context,
-	name string,
-	tracks []int64,
+	args CreateArgs,
 ) (int64, error) {
-	if name == "" {
+	if args.Name == "" {
 		return 0, fmt.Errorf("name cannot be empty")
 	}
 
 	var lastInsertID int64
 
 	insertPlaylistQuery := `
 		INSERT INTO
-			playlists (name, public, created_at, updated_at)
+			playlists (name, description, public, created_at, updated_at)
 		VALUES
-			(@name, 1, @current_time, @current_time)
+			(@name, @description, 1, @current_time, @current_time)
 	`
 
 	insertSongsQuery := `
@@ -238,9 +237,15 @@ func (m *manager) Create(
 			}
 		}()
 
+		descVal := sql.Named("description", nil)
+		if args.Description != "" {
+			descVal = sql.Named("description", args.Description)
+		}
+
 		res, err := tx.ExecContext(ctx, insertPlaylistQuery,
-			sql.Named("name", name),
+			sql.Named("name", args.Name),
 			sql.Named("current_time", time.Now().Unix()),
+			descVal,
 		)
 		if err != nil {
 			return fmt.Errorf("failed to insert playlist: %w", err)
@@ -252,18 +257,18 @@ func (m *manager) Create(
 		}
 
 		lastInsertID = id
-		if len(tracks) == 0 {
+		if len(args.Tracks) == 0 {
 			return nil
 		}
 
 		insertSongsQuery += strings.TrimSuffix(strings.Repeat(
-			"(@playlist_id, ?, ?),", len(tracks),
+			"(@playlist_id, ?, ?),", len(args.Tracks),
 		), ",")
 
 		queryVals := []any{
 			sql.Named("playlist_id", lastInsertID),
 		}
-		for index, trackID := range tracks {
+		for index, trackID := range args.Tracks {
 			queryVals = append(queryVals, trackID, index)
 		}
 

src/playlists/playlists.go

@@ -23,11 +23,10 @@ type Playlister interface {
 	// Count returns the count of all playlists available.
 	Count(ctx context.Context) (int64, error)
 
-	// Create creates a new playlist with the given name. `songs` is an list
-	// of track IDs to be added in the playlist.
+	// Create creates a new playlist with the given create arguments.
 	//
 	// Returns the unique ID of the newly created playlist.
-	Create(ctx context.Context, name string, tracks []int64) (int64, error)
+	Create(ctx context.Context, args CreateArgs) (int64, error)
 
 	// Update updates the playlist with ID `id` with the values
 	// given in `args`. Note that everything in args is optional
@@ -59,6 +58,18 @@ type Playlist struct {
 	Tracks []library.TrackInfo
 }
 
+// CreateArgs are the arguments needed for creating a playlist.
+type CreateArgs struct {
+	Name string // Name is the short name of the playlist. Required.
+
+	// Description is an optional short text which explains more about the playlist.
+	Description string
+
+	// Tracks is an list of track IDs to be added in the playlist. May be left
+	// empty.
+	Tracks []int64
+}
+
 // UpdateArgs is all the possible arguments which could be updated
 // for a given playlist.
 type UpdateArgs struct {

src/playlists/playlists_test.go

@@ -40,7 +40,7 @@ func TestPlaylistsManagerCRUD(t *testing.T) {
 	const playlistName = "empty playlist"
 
 	now := time.Now()
-	id, err := manager.Create(ctx, playlistName, []int64{})
+	id, err := manager.Create(ctx, playlists.CreateArgs{Name: playlistName})
 	assert.NilErr(t, err, "creating empty playlist")
 
 	expected := playlists.Playlist{
@@ -98,6 +98,27 @@ func TestPlaylistsManagerCRUD(t *testing.T) {
 
 	_, err = manager.Get(ctx, playlist.ID)
 	assert.NotNilErr(t, err, "expected 'not found' error for deleted playlist")
+
+	const listDescription = "some playlist description"
+	now = time.Now()
+	id, err = manager.Create(ctx, playlists.CreateArgs{
+		Name:        playlistName,
+		Description: listDescription,
+	})
+	assert.NilErr(t, err, "creating empty playlist with description")
+
+	expected = playlists.Playlist{
+		Name:      playlistName,
+		Desc:      listDescription,
+		ID:        id,
+		Public:    true,
+		CreatedAt: time.Unix(now.Unix(), 0), // seconds precision in the db
+		UpdatedAt: time.Unix(now.Unix(), 0), // seconds precision in the db
+	}
+
+	playlist, err = manager.Get(ctx, id)
+	assert.NilErr(t, err, "getting a single playlist with description")
+	assertPlaylist(t, expected, playlist)
 }
 
 // TestPlaylistsManagerNotFoundErrors makes sure that the playlists manager returns
@@ -165,7 +186,8 @@ func TestPlaylistsManagerSongOperations(t *testing.T) {
 		t.Fatalf("not enough tracks found in the library for working with playlists")
 	}
 
-	playlistID, err := manager.Create(ctx, "Testing Playlist", trackIDs)
+	createArgs := playlists.CreateArgs{Name: "Testing Playlist", Tracks: trackIDs}
+	playlistID, err := manager.Create(ctx, createArgs)
 	assert.NilErr(t, err, "failed while creating a playlist with all tracks")
 
 	playlist, err := manager.Get(ctx, playlistID)
@@ -268,7 +290,7 @@ func TestPlaylistsManagerErrors(t *testing.T) {
 	}()
 	manager := playlists.NewManager(lib.ExecuteDBJobAndWait)
 
-	_, err := manager.Create(ctx, "", []int64{})
+	_, err := manager.Create(ctx, playlists.CreateArgs{})
 	assert.NotNilErr(t, err,
 		"creating a playlist with empty name should have been an error",
 	)

src/playlists/playlistsfakes/fake_playlister.go

@@ -38,9 +38,9 @@ func (plh playlistsHandler) ServeHTTP(w http.ResponseWriter, req *http.Request)
 }
 
 func (plh playlistsHandler) create(w http.ResponseWriter, req *http.Request) {
-	listReq := playlistRequest{}
+	createReq := playlistRequest{}
 	dec := json.NewDecoder(req.Body)
-	if err := dec.Decode(&listReq); err != nil {
+	if err := dec.Decode(&createReq); err != nil {
 		webutils.JSONError(
 			w,
 			fmt.Sprintf("Cannot decode playlist JSON: %s", err),
@@ -49,7 +49,11 @@ func (plh playlistsHandler) create(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	newID, err := plh.playlists.Create(req.Context(), listReq.Name, listReq.AddTracksByID)
+	newID, err := plh.playlists.Create(req.Context(), playlists.CreateArgs{
+		Name:        createReq.Name,
+		Description: createReq.Desc,
+		Tracks:      createReq.AddTracksByID,
+	})
 	if err != nil {
 		webutils.JSONError(
 			w,

src/webserver/handler_playlists.go

@@ -24,6 +24,7 @@ func TestPlaylistsCreation(t *testing.T) {
 	const (
 		expectedID   = 10
 		expectedName = "new playlist"
+		expectedDesc = "some description"
 	)
 	var expectedTracks = []int64{4, 8}
 
@@ -36,6 +37,7 @@ func TestPlaylistsCreation(t *testing.T) {
 
 	body := bytes.NewBufferString(`{
 		"name": "new playlist",
+		"description": "some description",
 		"add_tracks_by_id": [4, 8]
 	}`)
 	req := httptest.NewRequest(http.MethodPost, "/v1/playlists", body)
@@ -47,11 +49,12 @@ func TestPlaylistsCreation(t *testing.T) {
 	assertJSONContentType(t, result)
 
 	assert.Equal(t, 1, fakeplay.CreateCallCount(), "unexpected number of Create calls")
-	_, actualName, actualTracks := fakeplay.CreateArgsForCall(0)
-	assert.Equal(t, expectedName, actualName, "wrong name during creation")
-	assert.Equal(t, len(expectedTracks), len(actualTracks), "wrong number of tracks")
+	_, actualArgs := fakeplay.CreateArgsForCall(0)
+	assert.Equal(t, expectedName, actualArgs.Name, "wrong name during creation")
+	assert.Equal(t, expectedDesc, actualArgs.Description, "wrong description")
+	assert.Equal(t, len(expectedTracks), len(actualArgs.Tracks), "wrong number of tracks")
 	for ind, trackID := range expectedTracks {
-		assert.Equal(t, trackID, actualTracks[ind], "track at index %s mismatch", ind)
+		assert.Equal(t, trackID, actualArgs.Tracks[ind], "track at index %s mismatch", ind)
 	}
 
 	respJSON := struct {

src/webserver/handler_playlists_test.go

@@ -31,7 +31,11 @@ func (s *subsonic) createNewPlaylist(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	id, err := s.playlists.Create(req.Context(), name, trackIDs)
+	createArgs := playlists.CreateArgs{
+		Name:   name,
+		Tracks: trackIDs,
+	}
+	id, err := s.playlists.Create(req.Context(), createArgs)
 	if err != nil {
 		resp := responseError(
 			errCodeGeneric,