crud

package main

import (
	"context"
	"fmt"
	"iter"
	"log/slog"
	"net/http"
	"strings"
	"uuid"

	"codeberg.org/kema/kmicro/pkg/client/database/dbpostgresql"
	"codeberg.org/kema/kmicro/pkg/crud"
	"codeberg.org/kema/kmicro/pkg/crudpg"
	"codeberg.org/kema/kmicro/pkg/http/router"
	"github.com/jackc/pgx/v5/pgxpool"
)

// User represents the user entity.
type User struct {
	crud.EntityBase
	Email string `db:"email" json:"email"` // Email represents the user's email
}

// UserHandler handles operations for users.
type UserHandler struct {
	*crud.BaseHandler[User]
}

// UserRepository implements [crud.Repository] for [User].
type UserRepository struct {
	db *pgxpool.Pool
}

// NewUserRepository returns a new [UserRepository] instance from db. For demo purposes, it also initializes (and resets) database extension, table and indexes,
// but you must run things like this in database's CRD & migration scripts in real projects.
func NewUserRepository(ctx context.Context, db *pgxpool.Pool) crud.Repository[User] {
	_, err := db.Exec(ctx, `
DROP TABLE IF EXISTS "users";
DROP INDEX IF EXISTS "idx_users_active";

CREATE TABLE users (
	id         uuid        PRIMARY KEY DEFAULT uuidv7(),
	email      text        NOT NULL UNIQUE,
	created_at timestamptz NOT NULL DEFAULT now(),
	updated_at timestamptz NOT NULL DEFAULT now(),
	deleted_at timestamptz
);

CREATE INDEX idx_users_active ON users (id)
WHERE deleted_at IS NULL;

CREATE INDEX idx_users_soft_deleted ON users (id)
WHERE deleted_at IS NOT NULL;
`)
	if err != nil {
		panic("initializing user demo hack: " + err.Error())
	}

	return UserRepository{db: db}
}

// NewUserHandler returns a new [UserHandler] instance from repo.
func NewUserHandler(ctx context.Context, db *pgxpool.Pool) UserHandler {
	repo := NewUserRepository(ctx, db)

	return UserHandler{
		BaseHandler: crud.NewBaseHandler(repo),
	}
}

// Create implements [crud.Repository].
func (r UserRepository) Create(ctx context.Context, entity User) (User, error) {
	q := `INSERT INTO users (email) VALUES ($1) RETURNING *`

	return crudpg.QueryOne[User](ctx, r.db, q, entity.Email)
}

// Get implements [crud.Repository].
func (r UserRepository) Get(ctx context.Context, id uuid.UUID) (User, error) {
	q := `SELECT * FROM users WHERE id = $1 AND deleted_at IS NULL`

	return crudpg.QueryOne[User](ctx, r.db, q, id)
}

// Update implements [crud.Repository].
func (r UserRepository) Update(ctx context.Context, id uuid.UUID, entity User) (User, error) {
	q := `UPDATE users
SET email = $1, updated_at = now()
WHERE id = $2 AND deleted_at IS NULL
RETURNING *`

	return crudpg.QueryOne[User](ctx, r.db, q, entity.Email, id)
}

// Delete implements [crud.Repository].
func (r UserRepository) Delete(ctx context.Context, id uuid.UUID) error {
	q := `DELETE FROM users WHERE id = $1`

	return crudpg.Exec(ctx, r.db, q, id)
}

// SoftDelete implements [crud.Repository].
func (r UserRepository) SoftDelete(ctx context.Context, id uuid.UUID) error {
	q := `UPDATE users SET deleted_at = now() WHERE id = $1 AND deleted_at IS NULL`

	return crudpg.Exec(ctx, r.db, q, id)
}

// List implements [crud.Repository].
func (r UserRepository) List(ctx context.Context, opts crud.QueryOptions) (iter.Seq2[User, error], error) {
	allowedColumns := map[string]struct{}{
		"id":         {},
		"email":      {},
		"created_at": {},
		"updated_at": {},
		"deleted_at": {},
	}

	var b strings.Builder

	args := make([]any, 0, 2)
	idx := 1

	b.WriteString(`SELECT * FROM users`)

	hasWhere := false
	where := func(clause string) {
		if !hasWhere {
			b.WriteString(` WHERE `)

			hasWhere = true
		} else {
			b.WriteString(` AND `)
		}

		b.WriteString(clause)
	}

	if !opts.IncludeSoftDeleted {
		where(`deleted_at IS NULL`)
	}

	if opts.Cursor != nil {
		where(fmt.Sprintf(`id > $%d`, idx))

		args = append(args, opts.Cursor)
		idx++
	}

	for col, val := range opts.Filter {
		if _, ok := allowedColumns[col]; !ok {
			return nil, fmt.Errorf("list users: unknown filter column %q: %w: %w", col, crud.ErrInvalidQuery, crud.ErrIsCallerSide)
		}

		where(fmt.Sprintf(`%s = $%d`, col, idx))

		args = append(args, val)
		idx++
	}

	if len(opts.Sort) > 0 {
		b.WriteString(` ORDER BY `)

		for i, s := range opts.Sort {
			if i > 0 {
				b.WriteString(`, `)
			}

			col, dir, err := parseSortField(s)
			if err != nil {
				return nil, fmt.Errorf("preparing query: %w", err)
			}

			if _, ok := allowedColumns[col]; !ok {
				return nil, fmt.Errorf("preparing query: unknown sort column %q: %w: %w", col, crud.ErrInvalidQuery, crud.ErrIsCallerSide)
			}

			fmt.Fprintf(&b, `%s %s`, col, dir)
		}
	}

	if opts.Limit > 0 {
		fmt.Fprintf(&b, ` LIMIT $%d`, idx)

		args = append(args, opts.Limit)
	}

	return crudpg.QueryIter[User](ctx, r.db, b.String(), args...)
}

func parseSortField(s string) (string, string, error) {
	if len(s) < 2 {
		return "", "", fmt.Errorf("invalid sort field %q: must be prefixed with + or -: %w: %w", s, crud.ErrInvalidQuery, crud.ErrIsCallerSide)
	}

	switch s[0] {
	case '+':
		return s[1:], "ASC", nil
	case '-':
		return s[1:], "DESC", nil
	default:
		return "", "", fmt.Errorf("invalid sort field %q: must be prefixed with + or -: %w: %w", s, crud.ErrInvalidQuery, crud.ErrIsCallerSide)
	}
}

func main() {
	ctx := context.Background()

	db, shutdown, err := dbpostgresql.New(ctx,
		dbpostgresql.WithHost("localhost"),
		dbpostgresql.WithUser("hello"),
		dbpostgresql.WithPasswordFilePath("/mnt/world"),
		dbpostgresql.WithDatabase("example"),
	)
	if err != nil {
		slog.Error("creating postgresql database client", slog.String("error.message", err.Error()))

		return
	}
	defer shutdown(context.Background())

	r := router.New()

	u := NewUserHandler(ctx, db)

	// curl -X POST localhost:8080/users --data '{"email":"hello@world.net"}'
	r.HandleFunc("POST /users", u.CreateFromHTTP)

	// curl localhost:8080/users/00000000-0000-0000-0000-000000000000
	r.HandleFunc("GET /users/{id}", u.GetFromHTTP)

	// curl localhost:8080/users/
	r.HandleFunc("GET /users", u.ListFromHTTP)

	// curl -X PATCH localhost:8080/users/00000000-0000-0000-0000-000000000000 --data '{"email":"hello@world.com"}'
	r.HandleFunc("PATCH /users/{id}", u.UpdateFromHTTP)

	// curl -X DELETE localhost:8080/users/00000000-0000-0000-0000-000000000000
	r.HandleFunc("DELETE /users/{id}", u.DeleteFromHTTP)

	_ = http.ListenAndServe("[::]:8080", r.Compile())
}

Output: