style(backend): improve error handling

refactor(backend/domain): start switching from pgx types

backend/db/db.go

@@ -1,79 +0,0 @@
-package db
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgconn"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var connPool *pgxpool.Pool
-
-func InitDB(connString string) error {
-	poolConfig, err := pgxpool.ParseConfig(connString)
-	if err != nil {
-		return fmt.Errorf("error while parsing connection string: %w", err)
-	}
-
-	poolConfig.MaxConns = 100
-	poolConfig.MinConns = 0
-	poolConfig.MaxConnLifetime = time.Hour
-	poolConfig.HealthCheckPeriod = 30 * time.Second
-
-	connPool, err = pgxpool.NewWithConfig(context.Background(), poolConfig)
-	if err != nil {
-		return fmt.Errorf("error while initializing DB connections pool: %w", err)
-	}
-	return nil
-}
-
-func transaction(handler func(context.Context, pgx.Tx) (statusCode int, err error)) (statusCode int, err error) {
-	ctx := context.Background()
-	tx, err := connPool.Begin(ctx)
-	if err != nil {
-		statusCode = http.StatusInternalServerError
-		return
-	}
-	statusCode, err = handler(ctx, tx)
-	if err != nil {
-		tx.Rollback(ctx)
-		return
-	}
-	err = tx.Commit(ctx)
-	if err != nil {
-		statusCode = http.StatusInternalServerError
-	}
-	return
-}
-
-// Handle database error
-func handleDBError(errIn error) (statusCode int, err error) {
-	if errIn == nil {
-		statusCode = http.StatusOK
-		return
-	}
-	if errors.Is(errIn, pgx.ErrNoRows) {
-		err = fmt.Errorf("not found")
-		statusCode = http.StatusNotFound
-		return
-	}
-	var pgErr *pgconn.PgError
-	if errors.As(errIn, &pgErr) {
-		switch pgErr.Code {
-		case "22P02", "22007": // Invalid data format
-			err = fmt.Errorf("%s", pgErr.Message)
-			statusCode = http.StatusBadRequest
-			return
-		case "23505": // Unique constraint violation
-			err = fmt.Errorf("already exists")
-			statusCode = http.StatusConflict
-			return
-		}
-	}
-	return http.StatusInternalServerError, errIn
-}

backend/internal/domain/entity.go

@@ -1,10 +1,8 @@
-package models
+package domain
 
 import (
 	"encoding/json"
 	"time"
-
-	"github.com/jackc/pgx/v5/pgtype"
 )
 
 type User struct {
@@ -20,9 +18,9 @@ type MIME struct {
 
 type (
 	CategoryCore struct {
-		ID    string      `json:"id"`
-		Name  string      `json:"name"`
-		Color pgtype.Text `json:"color"`
+		ID    *string `json:"id"`
+		Name  *string `json:"name"`
+		Color *string `json:"color"`
 	}
 	CategoryItem struct {
 		CategoryCore
@@ -31,14 +29,14 @@ type (
 		CategoryCore
 		CreatedAt time.Time `json:"createdAt"`
 		Creator   User      `json:"creator"`
-		Notes     pgtype.Text `json:"notes"`
+		Notes     *string   `json:"notes"`
 	}
 )
 
 type (
 	FileCore struct {
 		ID   string  `json:"id"`
-		Name pgtype.Text `json:"name"`
+		Name *string `json:"name"`
 		MIME MIME    `json:"mime"`
 	}
 	FileItem struct {
@@ -50,9 +48,8 @@ type (
 		FileCore
 		CreatedAt time.Time       `json:"createdAt"`
 		Creator   User            `json:"creator"`
-		Notes     pgtype.Text     `json:"notes"`
+		Notes     *string         `json:"notes"`
 		Metadata  json.RawMessage `json:"metadata"`
-		Tags      []TagCore       `json:"tags"`
 		Viewed    int             `json:"viewed"`
 	}
 )
@@ -61,7 +58,7 @@ type (
 	TagCore struct {
 		ID    string  `json:"id"`
 		Name  string  `json:"name"`
-		Color pgtype.Text `json:"color"`
+		Color *string `json:"color"`
 	}
 	TagItem struct {
 		TagCore
@@ -72,7 +69,7 @@ type (
 		Category  CategoryCore `json:"category"`
 		CreatedAt time.Time    `json:"createdAt"`
 		Creator   User         `json:"creator"`
-		Notes     pgtype.Text  `json:"notes"`
+		Notes     *string      `json:"notes"`
 		UsedIncl  int          `json:"usedIncl"`
 		UsedExcl  int          `json:"usedExcl"`
 	}
@@ -96,7 +93,7 @@ type (
 		PoolCore
 		CreatedAt time.Time `json:"createdAt"`
 		Creator   User      `json:"creator"`
-		Notes     pgtype.Text `json:"notes"`
+		Notes     *string   `json:"notes"`
 		Viewed    int       `json:"viewed"`
 	}
 )

backend/internal/domain/errors.go

@@ -0,0 +1,65 @@
+package domain
+
+import "fmt"
+
+type ErrorCode string
+
+const (
+	// File errors
+	ErrCodeFileNotFound     ErrorCode = "FILE_NOT_FOUND"
+	ErrCodeMIMENotSupported ErrorCode = "MIME_NOT_SUPPORTED"
+
+	// Tag errors
+	ErrCodeTagNotFound ErrorCode = "TAG_NOT_FOUND"
+
+	// General errors
+	ErrCodeBadRequest ErrorCode = "BAD_REQUEST"
+	ErrCodeInternal   ErrorCode = "INTERNAL_SERVER_ERROR"
+)
+
+type DomainError struct {
+	Err     error     `json:"-"`
+	Code    ErrorCode `json:"code"`
+	Message string    `json:"message"`
+	Details []any     `json:"-"`
+}
+
+func (e *DomainError) Wrap(err error) *DomainError {
+	e.Err = err
+	return e
+}
+
+func NewErrorFileNotFound(file_id string) *DomainError {
+	return &DomainError{
+		Code:    ErrCodeFileNotFound,
+		Message: fmt.Sprintf("File not found: %q", file_id),
+	}
+}
+
+func NewErrorMIMENotSupported(mime string) *DomainError {
+	return &DomainError{
+		Code:    ErrCodeMIMENotSupported,
+		Message: fmt.Sprintf("MIME not supported: %q", mime),
+	}
+}
+
+func NewErrorTagNotFound(tag_id string) *DomainError {
+	return &DomainError{
+		Code:    ErrCodeTagNotFound,
+		Message: fmt.Sprintf("Tag not found: %q", tag_id),
+	}
+}
+
+func NewErrorBadRequest(message string) *DomainError {
+	return &DomainError{
+		Code:    ErrCodeBadRequest,
+		Message: message,
+	}
+}
+
+func NewErrorUnexpected() *DomainError {
+	return &DomainError{
+		Code:    ErrCodeInternal,
+		Message: "An unexpected error occured",
+	}
+}

backend/internal/domain/repositories.go

@@ -0,0 +1,17 @@
+package domain
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+)
+
+type FileRepository interface {
+	GetAccess(ctx context.Context, user_id int, file_id string) (canView, canEdit bool, domainErr *DomainError)
+	GetSlice(ctx context.Context, user_id int, filter, sort string, limit, offset int) (files Slice[FileItem], domainErr *DomainError)
+	Get(ctx context.Context, user_id int, file_id string) (file FileFull, domainErr *DomainError)
+	Add(ctx context.Context, user_id int, name, mime string, datetime time.Time, notes string, metadata json.RawMessage) (file FileCore, domainErr *DomainError)
+	Update(ctx context.Context, file_id string, updates map[string]interface{}) (domainErr *DomainError)
+	Delete(ctx context.Context, file_id string) (domainErr *DomainError)
+	GetTags(ctx context.Context, user_id int, file_id string) (tags []TagItem, domainErr *DomainError)
+}

backend/internal/infrastructure/persistence/postgres/db.go

@@ -0,0 +1,54 @@
+package postgres
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"tanabata/internal/domain"
+)
+
+// Initialize PostgreSQL database driver
+func New(dbURL string) (*pgxpool.Pool, error) {
+	poolConfig, err := pgxpool.ParseConfig(dbURL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse connection string: %w", err)
+	}
+
+	poolConfig.MaxConns = 100
+	poolConfig.MinConns = 0
+	poolConfig.MaxConnLifetime = time.Hour
+	poolConfig.HealthCheckPeriod = 30 * time.Second
+
+	ctx := context.Background()
+	db, err := pgxpool.NewWithConfig(ctx, poolConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize DB connections pool: %w", err)
+	}
+	if err = db.Ping(ctx); err != nil {
+		return nil, fmt.Errorf("failed to ping database: %w", err)
+	}
+	return db, nil
+}
+
+// Transaction wrapper
+func transaction(ctx context.Context, db *pgxpool.Pool, handler func(context.Context, pgx.Tx) *domain.DomainError) (domainErr *domain.DomainError) {
+	tx, err := db.Begin(ctx)
+	if err != nil {
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	domainErr = handler(ctx, tx)
+	if domainErr != nil {
+		tx.Rollback(ctx)
+		return
+	}
+	err = tx.Commit(ctx)
+	if err != nil {
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+	}
+	return
+}

backend/internal/infrastructure/persistence/postgres/file_repository.go

@@ -0,0 +1,331 @@
+package postgres
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"tanabata/internal/domain"
+)
+
+type FileRepository struct {
+	db *pgxpool.Pool
+}
+
+func NewFileRepository(db *pgxpool.Pool) *FileRepository {
+	return &FileRepository{db: db}
+}
+
+// Get user permissions on file
+func (s *FileRepository) GetAccess(ctx context.Context, user_id int, file_id string) (canView, canEdit bool, domainErr *domain.DomainError) {
+	row := s.db.QueryRow(ctx, `
+		SELECT 
+			COALESCE(a.view, FALSE) OR f.creator_id=$1 OR COALESCE(u.is_admin, FALSE),
+			COALESCE(a.edit, FALSE) OR f.creator_id=$1 OR COALESCE(u.is_admin, FALSE)
+		FROM data.files f
+		LEFT JOIN acl.files a ON a.file_id=f.id AND a.user_id=$1
+		LEFT JOIN system.users u ON u.id=$1
+		WHERE f.id=$2
+		`, user_id, file_id)
+	err := row.Scan(&canView, &canEdit)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			domainErr = domain.NewErrorFileNotFound(file_id).Wrap(err)
+			return
+		}
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			switch pgErr.Code {
+			case "22P02":
+				domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid file id: %q", file_id)).Wrap(err)
+				return
+			}
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+	}
+	return
+}
+
+// Get a set of files
+func (s *FileRepository) GetSlice(ctx context.Context, user_id int, filter, sort string, limit, offset int) (files domain.Slice[domain.FileItem], domainErr *domain.DomainError) {
+	filterCond, err := filterToSQL(filter)
+	if err != nil {
+		domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid filter string: %q", filter)).Wrap(err)
+		return
+	}
+	sortExpr, err := sortToSQL(sort)
+	if err != nil {
+		domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid sorting parameter: %q", sort)).Wrap(err)
+		return
+	}
+	// prepare query
+	query := `
+		SELECT
+			f.id,
+			f.name,
+			m.name,
+			m.extension,
+			uuid_extract_timestamp(f.id),
+			u.name,
+			u.is_admin
+		FROM data.files f
+		JOIN system.mime m ON m.id=f.mime_id
+		JOIN system.users u ON u.id=f.creator_id
+		WHERE f.is_deleted IS FALSE AND (f.creator_id=$1 OR (SELECT view FROM acl.files WHERE file_id=f.id AND user_id=$1) OR (SELECT is_admin FROM system.users WHERE id=$1)) AND
+	`
+	query += filterCond
+	queryCount := query
+	query += sortExpr
+	if limit >= 0 {
+		query += fmt.Sprintf(" LIMIT %d", limit)
+	}
+	if offset > 0 {
+		query += fmt.Sprintf(" OFFSET %d", offset)
+	}
+	// execute query
+	domainErr = transaction(ctx, s.db, func(ctx context.Context, tx pgx.Tx) (domainErr *domain.DomainError) {
+		rows, err := tx.Query(ctx, query, user_id)
+		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+			var pgErr *pgconn.PgError
+			if errors.As(err, &pgErr) {
+				switch pgErr.Code {
+				case "42P10":
+					domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid sorting field: %q", sort[1:])).Wrap(err)
+					return
+				}
+			}
+			domainErr = domain.NewErrorUnexpected().Wrap(err)
+			return
+		}
+		defer rows.Close()
+		count := 0
+		for rows.Next() {
+			var file domain.FileItem
+			err = rows.Scan(&file.ID, &file.Name, &file.MIME.Name, &file.MIME.Extension, &file.CreatedAt, &file.Creator.Name, &file.Creator.IsAdmin)
+			if err != nil {
+				domainErr = domain.NewErrorUnexpected().Wrap(err)
+				return
+			}
+			files.Data = append(files.Data, file)
+			count++
+		}
+		err = rows.Err()
+		if err != nil {
+			domainErr = domain.NewErrorUnexpected().Wrap(err)
+			return
+		}
+		files.Pagination.Limit = limit
+		files.Pagination.Offset = offset
+		files.Pagination.Count = count
+		row := tx.QueryRow(ctx, fmt.Sprintf("SELECT COUNT(*) FROM (%s) tmp", queryCount), user_id)
+		err = row.Scan(&files.Pagination.Total)
+		if err != nil {
+			domainErr = domain.NewErrorUnexpected().Wrap(err)
+		}
+		return
+	})
+	return
+}
+
+// Get file
+func (s *FileRepository) Get(ctx context.Context, user_id int, file_id string) (file domain.FileFull, domainErr *domain.DomainError) {
+	row := s.db.QueryRow(ctx, `
+		SELECT
+			f.id,
+			f.name,
+			m.name,
+			m.extension,
+			uuid_extract_timestamp(f.id),
+			u.name,
+			u.is_admin,
+			f.notes,
+			f.metadata,
+			(SELECT COUNT(*) FROM activity.file_views fv WHERE fv.file_id=$2 AND fv.user_id=$1)
+		FROM data.files f
+		JOIN system.mime m ON m.id=f.mime_id
+		JOIN system.users u ON u.id=f.creator_id
+		WHERE f.is_deleted IS FALSE
+		`, user_id, file_id)
+	err := row.Scan(&file.ID, &file.Name, &file.MIME.Name, &file.MIME.Extension, &file.CreatedAt, &file.Creator.Name, &file.Creator.IsAdmin, &file.Notes, &file.Metadata, &file.Viewed)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			domainErr = domain.NewErrorFileNotFound(file_id).Wrap(err)
+			return
+		}
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			switch pgErr.Code {
+			case "22P02":
+				domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid file id: %q", file_id)).Wrap(err)
+				return
+			}
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	return
+}
+
+// Add file
+func (s *FileRepository) Add(ctx context.Context, user_id int, name, mime string, datetime time.Time, notes string, metadata json.RawMessage) (file domain.FileCore, domainErr *domain.DomainError) {
+	var mime_id int
+	var extension string
+	row := s.db.QueryRow(ctx, "SELECT id, extension FROM system.mime WHERE name=$1", mime)
+	err := row.Scan(&mime_id, &extension)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			domainErr = domain.NewErrorMIMENotSupported(mime).Wrap(err)
+			return
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	row = s.db.QueryRow(ctx, `
+		INSERT INTO data.files (name, mime_id, datetime, creator_id, notes, metadata)
+		VALUES (NULLIF($1, ''), $2, $3, $4, NULLIF($5 ,''), $6)
+		RETURNING id
+		`, name, mime_id, datetime, user_id, notes, metadata)
+	err = row.Scan(&file.ID)
+	if err != nil {
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			switch pgErr.Code {
+			case "22007":
+				domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid datetime: %q", datetime)).Wrap(err)
+				return
+			case "23502":
+				domainErr = domain.NewErrorBadRequest("Unable to set NULL to some fields").Wrap(err)
+				return
+			}
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	file.Name = &name
+	file.MIME.Name = mime
+	file.MIME.Extension = extension
+	return
+}
+
+// Update file
+func (s *FileRepository) Update(ctx context.Context, file_id string, updates map[string]interface{}) (domainErr *domain.DomainError) {
+	if len(updates) == 0 {
+		// domainErr = domain.NewErrorBadRequest(nil, "No fields provided for update")
+		return
+	}
+	query := "UPDATE data.files SET"
+	newValues := []interface{}{file_id}
+	count := 2
+	for field, value := range updates {
+		switch field {
+		case "name", "notes":
+			query += fmt.Sprintf(" %s=NULLIF($%d, '')", field, count)
+		case "datetime":
+			query += fmt.Sprintf(" %s=NULLIF($%d, '')::timestamptz", field, count)
+		case "metadata":
+			query += fmt.Sprintf(" %s=NULLIF($%d, '')::jsonb", field, count)
+		default:
+			domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Unknown field: %q", field))
+			return
+		}
+		newValues = append(newValues, value)
+		count++
+	}
+	query += fmt.Sprintf(" WHERE id=$1 AND is_deleted IS FALSE")
+	commandTag, err := s.db.Exec(ctx, query, newValues...)
+	if err != nil {
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			switch pgErr.Code {
+			case "22P02":
+				domainErr = domain.NewErrorBadRequest("Invalid format of some values").Wrap(err)
+				return
+			case "22007":
+				domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid datetime: %q", updates["datetime"])).Wrap(err)
+				return
+			case "23502":
+				domainErr = domain.NewErrorBadRequest("Some fields cannot be empty").Wrap(err)
+				return
+			}
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	if commandTag.RowsAffected() == 0 {
+		domainErr = domain.NewErrorFileNotFound(file_id).Wrap(err)
+		return
+	}
+	return
+}
+
+// Delete file
+func (s *FileRepository) Delete(ctx context.Context, file_id string) (domainErr *domain.DomainError) {
+	commandTag, err := s.db.Exec(ctx,
+		"UPDATE data.files SET is_deleted=true WHERE id=$1 AND is_deleted IS FALSE",
+		file_id)
+	if err != nil {
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			switch pgErr.Code {
+			case "22P02":
+				domainErr = domain.NewErrorBadRequest(fmt.Sprintf("Invalid file id: %q", file_id)).Wrap(err)
+				return
+			}
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	if commandTag.RowsAffected() == 0 {
+		domainErr = domain.NewErrorFileNotFound(file_id).Wrap(err)
+		return
+	}
+	return
+}
+
+// Get list of tags of file
+func (s *FileRepository) GetTags(ctx context.Context, user_id int, file_id string) (tags []domain.TagItem, domainErr *domain.DomainError) {
+	rows, err := s.db.Query(ctx, `
+		SELECT
+			t.id,
+			t.name,
+			t.color,
+			c.id,
+			c.name,
+			c.color
+		FROM data.tags t
+		LEFT JOIN data.categories c ON c.id=t.category_id
+		JOIN data.file_tag ft ON ft.tag_id=t.id AND ft.file_id=$2
+		JOIN data.files f ON f.id=$2
+		WHERE NOT f.is_deleted AND (f.creator_id=$1 OR (SELECT view FROM acl.files WHERE file_id=$2 AND user_id=$1) OR (SELECT is_admin FROM system.users WHERE id=$1))
+		`, user_id, file_id)
+	if err != nil {
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) && (pgErr.Code == "22P02" || pgErr.Code == "22007") {
+			domainErr = domain.NewErrorBadRequest(pgErr.Message).Wrap(err)
+			return
+		}
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var tag domain.TagItem
+		err = rows.Scan(&tag.ID, &tag.Name, &tag.Color, &tag.Category.ID, &tag.Category.Name, &tag.Category.Color)
+		if err != nil {
+			domainErr = domain.NewErrorUnexpected().Wrap(err)
+			return
+		}
+		tags = append(tags, tag)
+	}
+	err = rows.Err()
+	if err != nil {
+		domainErr = domain.NewErrorUnexpected().Wrap(err)
+	}
+	return
+}

backend/internal/infrastructure/persistence/postgres/utils.go

@@ -1,21 +1,52 @@
-package db
+package postgres
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
 	"strings"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
 )
 
+// Handle database error
+func handleDBError(errIn error) (statusCode int, err error) {
+	if errIn == nil {
+		statusCode = http.StatusOK
+		return
+	}
+	if errors.Is(errIn, pgx.ErrNoRows) {
+		err = fmt.Errorf("not found")
+		statusCode = http.StatusNotFound
+		return
+	}
+	var pgErr *pgconn.PgError
+	if errors.As(errIn, &pgErr) {
+		switch pgErr.Code {
+		case "22P02", "22007": // Invalid data format
+			err = fmt.Errorf("%s", pgErr.Message)
+			statusCode = http.StatusBadRequest
+			return
+		case "23505": // Unique constraint violation
+			err = fmt.Errorf("already exists")
+			statusCode = http.StatusConflict
+			return
+		}
+	}
+	return http.StatusInternalServerError, errIn
+}
+
 // Convert "filter" URL param to SQL "WHERE" condition
-func filterToSQL(filter string) (sql string, statusCode int, err error) {
+func filterToSQL(filter string) (sql string, err error) {
 	// filterTokens := strings.Split(string(filter), ";")
 	sql = "(true)"
 	return
 }
 
 // Convert "sort" URL param to SQL "ORDER BY"
-func sortToSQL(sort string) (sql string, statusCode int, err error) {
+func sortToSQL(sort string) (sql string, err error) {
 	if sort == "" {
 		return
 	}
@@ -32,7 +63,6 @@ func sortToSQL(sort string) (sql string, statusCode int, err error) {
 			sortOrder = "DESC"
 		default:
 			err = fmt.Errorf("invalid sorting order mark: %q", sortOrder)
-			statusCode = http.StatusBadRequest
 			return
 		}
 		// validate sorting column
@@ -40,7 +70,6 @@ func sortToSQL(sort string) (sql string, statusCode int, err error) {
 		n, err = strconv.Atoi(sortColumn)
 		if err != nil || n < 0 {
 			err = fmt.Errorf("invalid sorting column: %q", sortColumn)
-			statusCode = http.StatusBadRequest
 			return
 		}
 		// add sorting option to query

backend/internal/interfaces/rest/handlers/error_handler.go

@@ -0,0 +1,43 @@
+package rest
+
+import (
+	"net/http"
+
+	"tanabata/internal/domain"
+)
+
+type ErrorResponse struct {
+	Error   string `json:"error"`
+	Code    string `json:"code,omitempty"`
+	Message string `json:"message,omitempty"`
+}
+
+type ErrorMapper struct{}
+
+func (m *ErrorMapper) MapError(err domain.DomainError) (int, ErrorResponse) {
+	switch err.Code {
+	case domain.ErrCodeFileNotFound:
+		return http.StatusNotFound, ErrorResponse{
+			Error:   "Not Found",
+			Code:    string(err.Code),
+			Message: err.Message,
+		}
+	case domain.ErrCodeMIMENotSupported:
+		return http.StatusNotFound, ErrorResponse{
+			Error:   "MIME not supported",
+			Code:    string(err.Code),
+			Message: err.Message,
+		}
+	case domain.ErrCodeBadRequest:
+		return http.StatusNotFound, ErrorResponse{
+			Error:   "Bad Request",
+			Code:    string(err.Code),
+			Message: err.Message,
+		}
+	}
+	return http.StatusInternalServerError, ErrorResponse{
+		Error:   "Internal Server Error",
+		Code:    string(err.Code),
+		Message: err.Message,
+	}
+}

database/create-schema.sql

@@ -80,6 +80,35 @@ CREATE EXTENSION IF NOT EXISTS "uuid-ossp" WITH SCHEMA public;
 COMMENT ON EXTENSION "uuid-ossp" IS 'generate universally unique identifiers (UUIDs)';
 
 
+--
+-- Name: add_file_to_tag_recursive(uuid, uuid); Type: FUNCTION; Schema: data; Owner: -
+--
+
+CREATE FUNCTION data.add_file_to_tag_recursive(f_id uuid, t_id uuid) RETURNS SETOF uuid
+    LANGUAGE plpgsql
+    AS $$
+DECLARE
+	tmp uuid;
+	tt_id uuid;
+	ttt_id uuid;
+BEGIN
+	INSERT INTO data.file_tag VALUES (f_id, t_id) ON CONFLICT DO NOTHING RETURNING tag_id INTO tmp;
+	IF tmp IS NULL THEN
+		RETURN;
+	END IF;
+	RETURN NEXT t_id;
+	FOR tt_id IN
+		SELECT a.add_tag_id FROM data.autotags a WHERE a.trigger_tag_id=t_id AND a.is_active
+	LOOP
+		FOR ttt_id IN SELECT data.add_file_to_tag_recursive(f_id, tt_id)
+		LOOP
+			RETURN NEXT ttt_id;
+		END LOOP;
+	END LOOP;
+END;
+$$;
+
+
 --
 -- Name: uuid_extract_timestamp(uuid); Type: FUNCTION; Schema: public; Owner: -
 --
@@ -267,7 +296,7 @@ CREATE TABLE data.autotags (
 CREATE TABLE data.categories (
     id uuid DEFAULT public.uuid_v7() NOT NULL,
     name character varying(256) NOT NULL,
-    notes text,
+    notes text DEFAULT ''::text NOT NULL,
     color character(6),
     creator_id smallint NOT NULL
 );

docs/erd.puml

@@ -11,6 +11,7 @@ entity "system.users" as usr {
     * name : varchar(32)
     * password : text
     * is_admin : boolean
+    * can_create : boolean
 }
 
 entity "system.mime" as mime {