feat: allow tag filtering and count retrieval via api v1 (#1079)

* fix: frontend url to retrieve bookmark count

* chore: unneeded type in generic

* feat: allow tag filtering and count retrieval

* fix: make styles

* fix: make swagger

* fix: make swag

* tests: refactored gettags tests

* fix: initialise tags empty slice

Author: fmartingr

docs/swagger/docs.go

@@ -417,6 +417,20 @@ const docTemplate = `{
                     "Tags"
                 ],
                 "summary": "List tags",
+                "parameters": [
+                    {
+                        "type": "boolean",
+                        "description": "Include bookmark count for each tag",
+                        "name": "with_bookmark_count",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "description": "Filter tags by bookmark ID",
+                        "name": "bookmark_id",
+                        "in": "query"
+                    }
+                ],
                 "responses": {
                     "200": {
                         "description": "OK",

docs/swagger/swagger.json

@@ -406,6 +406,20 @@
                     "Tags"
                 ],
                 "summary": "List tags",
+                "parameters": [
+                    {
+                        "type": "boolean",
+                        "description": "Include bookmark count for each tag",
+                        "name": "with_bookmark_count",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "description": "Filter tags by bookmark ID",
+                        "name": "bookmark_id",
+                        "in": "query"
+                    }
+                ],
                 "responses": {
                     "200": {
                         "description": "OK",

docs/swagger/swagger.yaml

@@ -441,6 +441,15 @@ paths:
   /api/v1/tags:
     get:
       description: List all tags
+      parameters:
+      - description: Include bookmark count for each tag
+        in: query
+        name: with_bookmark_count
+        type: boolean
+      - description: Filter tags by bookmark ID
+        in: query
+        name: bookmark_id
+        type: integer
       produces:
       - application/json
       responses:

internal/cmd/root.go

@@ -124,7 +124,7 @@ func initShiori(ctx context.Context, cmd *cobra.Command) (*config.Config, *depen
 		account := model.AccountDTO{
 			Username: "shiori",
 			Password: "gopher",
-			Owner:    model.Ptr[bool](true),
+			Owner:    model.Ptr(true),
 		}
 
 		if _, err := dependencies.Domains().Accounts().CreateAccount(cmd.Context(), account); err != nil {

internal/database/database.go

@@ -2,12 +2,14 @@ package database
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"log"
 	"net/url"
 	"strings"
 
 	"github.com/go-shiori/shiori/internal/model"
+	"github.com/huandu/go-sqlbuilder"
 	"github.com/jmoiron/sqlx"
 	"github.com/pkg/errors"
 )
@@ -39,11 +41,25 @@ func Connect(ctx context.Context, dbURL string) (model.DB, error) {
 }
 
 type dbbase struct {
-	*sqlx.DB
+	flavor sqlbuilder.Flavor
+	reader *sqlx.DB
+	writer *sqlx.DB
+}
+
+func (db *dbbase) Flavor() sqlbuilder.Flavor {
+	return db.flavor
+}
+
+func (db *dbbase) ReaderDB() *sqlx.DB {
+	return db.reader
+}
+
+func (db *dbbase) WriterDB() *sqlx.DB {
+	return db.writer
 }
 
 func (db *dbbase) withTx(ctx context.Context, fn func(tx *sqlx.Tx) error) error {
-	tx, err := db.BeginTxx(ctx, nil)
+	tx, err := db.writer.BeginTxx(ctx, nil)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -64,3 +80,32 @@ func (db *dbbase) withTx(ctx context.Context, fn func(tx *sqlx.Tx) error) error
 
 	return err
 }
+
+func (db *dbbase) GetContext(ctx context.Context, dest any, query string, args ...any) error {
+	return db.reader.GetContext(ctx, dest, query, args...)
+}
+
+// Deprecated: Use SelectContext instead.
+func (db *dbbase) Select(dest any, query string, args ...any) error {
+	return db.reader.Select(dest, query, args...)
+}
+
+func (db *dbbase) SelectContext(ctx context.Context, dest any, query string, args ...any) error {
+	return db.reader.SelectContext(ctx, dest, query, args...)
+}
+
+func (db *dbbase) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
+	return db.writer.ExecContext(ctx, query, args...)
+}
+
+func (db *dbbase) MustBegin() *sqlx.Tx {
+	return db.writer.MustBegin()
+}
+
+func NewDBBase(reader, writer *sqlx.DB, flavor sqlbuilder.Flavor) dbbase {
+	return dbbase{
+		reader: reader,
+		writer: writer,
+		flavor: flavor,
+	}
+}

internal/database/database_tags.go

@@ -0,0 +1,69 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"log/slog"
+
+	"github.com/go-shiori/shiori/internal/model"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+// GetTags returns a list of tags from the database.
+// If opts.WithBookmarkCount is true, the result will include the number of bookmarks for each tag.
+// If opts.BookmarkID is not 0, the result will include only the tags for the specified bookmark.
+// If opts.OrderBy is set, the result will be ordered by the specified column.
+func (db *dbbase) GetTags(ctx context.Context, opts model.DBListTagsOptions) ([]model.TagDTO, error) {
+	sb := db.Flavor().NewSelectBuilder()
+
+	sb.Select("t.id", "t.name")
+	sb.From("tag t")
+
+	// Treat the case where we want the bookmark count and filter by bookmark ID as a special case:
+	// If we only want one of them, we can use a JOIN and GROUP BY.
+	// If we want both, we need to use a subquery to get the count of bookmarks for each tag filtered
+	// by bookmark ID.
+	if opts.WithBookmarkCount && opts.BookmarkID == 0 {
+		// Join with bookmark_tag and group by tag ID to get the count of bookmarks for each tag
+		sb.JoinWithOption(sqlbuilder.LeftJoin, "bookmark_tag bt", "bt.tag_id = t.id")
+		sb.SelectMore("COUNT(bt.tag_id) AS bookmark_count")
+		sb.GroupBy("t.id")
+	} else if opts.BookmarkID > 0 {
+		// If we want the bookmark count, we need to use a subquery to get the count of bookmarks for each tag
+		if opts.WithBookmarkCount {
+			sb.SelectMore(
+				sb.BuilderAs(
+					db.Flavor().NewSelectBuilder().Select("COUNT(bt2.tag_id)").From("bookmark_tag bt2").Where("bt2.tag_id = t.id"),
+					"bookmark_count",
+				),
+			)
+		}
+
+		// Join with bookmark_tag and filter by bookmark ID to get the tags for a specific bookmark
+		sb.JoinWithOption(sqlbuilder.RightJoin, "bookmark_tag bt",
+			sb.And(
+				"bt.tag_id = t.id",
+				sb.Equal("bt.bookmark_id", opts.BookmarkID),
+			),
+		)
+		sb.Where(sb.IsNotNull("t.id"))
+	}
+
+	if opts.OrderBy == model.DBTagOrderByTagName {
+		sb.OrderBy("t.name")
+	}
+
+	query, args := sb.Build()
+	query = db.ReaderDB().Rebind(query)
+
+	slog.Info("GetTags query", "query", query, "args", args)
+
+	tags := []model.TagDTO{}
+	err := db.ReaderDB().SelectContext(ctx, &tags, query, args...)
+	if err != nil && err != sql.ErrNoRows {
+		return nil, fmt.Errorf("failed to get tags: %w", err)
+	}
+
+	return tags, nil
+}