156 lines
3.5 KiB
Go
156 lines
3.5 KiB
Go
package db
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
var ErrUserNotFound = errors.New("user not found")
|
|
var ErrUserExists = errors.New("username already exists")
|
|
|
|
// User represents a local account stored in SQLite.
|
|
type User struct {
|
|
ID int64
|
|
Username string
|
|
PassHash string
|
|
Role string
|
|
CreatedAt time.Time
|
|
}
|
|
|
|
// DB wraps the SQLite connection.
|
|
type DB struct {
|
|
sql *sql.DB
|
|
}
|
|
|
|
// New opens (or creates) the SQLite database at path and runs migrations.
|
|
func New(path string) (*DB, error) {
|
|
sqldb, err := sql.Open("sqlite", path+"?_journal=WAL&_timeout=5000")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
d := &DB{sql: sqldb}
|
|
if err := d.init(); err != nil {
|
|
sqldb.Close()
|
|
return nil, err
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
func (d *DB) Close() error {
|
|
return d.sql.Close()
|
|
}
|
|
|
|
func (d *DB) init() error {
|
|
_, err := d.sql.Exec(`
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
username TEXT NOT NULL UNIQUE,
|
|
pass_hash TEXT NOT NULL,
|
|
role TEXT NOT NULL DEFAULT 'user',
|
|
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
)
|
|
`)
|
|
return err
|
|
}
|
|
|
|
// HasUsers returns true if at least one user account exists.
|
|
func (d *DB) HasUsers() bool {
|
|
var n int
|
|
d.sql.QueryRow(`SELECT COUNT(*) FROM users`).Scan(&n)
|
|
return n > 0
|
|
}
|
|
|
|
// CreateUser inserts a new user. Returns ErrUserExists if the username is taken.
|
|
func (d *DB) CreateUser(username, passHash, role string) error {
|
|
_, err := d.sql.Exec(
|
|
`INSERT INTO users (username, pass_hash, role) VALUES (?, ?, ?)`,
|
|
username, passHash, role,
|
|
)
|
|
if err != nil && strings.Contains(err.Error(), "UNIQUE constraint failed") {
|
|
return ErrUserExists
|
|
}
|
|
return err
|
|
}
|
|
|
|
// GetUser fetches a single user by username.
|
|
func (d *DB) GetUser(username string) (*User, error) {
|
|
row := d.sql.QueryRow(
|
|
`SELECT id, username, pass_hash, role, created_at FROM users WHERE username = ?`,
|
|
username,
|
|
)
|
|
u := &User{}
|
|
var createdAt string
|
|
err := row.Scan(&u.ID, &u.Username, &u.PassHash, &u.Role, &createdAt)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrUserNotFound
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
u.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
|
|
return u, nil
|
|
}
|
|
|
|
// ListUsers returns all users ordered by id.
|
|
func (d *DB) ListUsers() ([]*User, error) {
|
|
rows, err := d.sql.Query(
|
|
`SELECT id, username, role, created_at FROM users ORDER BY id`,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var users []*User
|
|
for rows.Next() {
|
|
u := &User{}
|
|
var createdAt string
|
|
if err := rows.Scan(&u.ID, &u.Username, &u.Role, &createdAt); err != nil {
|
|
return nil, err
|
|
}
|
|
u.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
|
|
users = append(users, u)
|
|
}
|
|
return users, rows.Err()
|
|
}
|
|
|
|
// DeleteUser removes a user. Returns ErrUserNotFound if they don't exist.
|
|
func (d *DB) DeleteUser(username string) error {
|
|
res, err := d.sql.Exec(`DELETE FROM users WHERE username = ?`, username)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
n, _ := res.RowsAffected()
|
|
if n == 0 {
|
|
return ErrUserNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UpdatePassword replaces the stored hash for a user.
|
|
func (d *DB) UpdatePassword(username, passHash string) error {
|
|
res, err := d.sql.Exec(
|
|
`UPDATE users SET pass_hash = ? WHERE username = ?`,
|
|
passHash, username,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
n, _ := res.RowsAffected()
|
|
if n == 0 {
|
|
return ErrUserNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UserCount returns the total number of local accounts.
|
|
func (d *DB) UserCount() (int, error) {
|
|
var n int
|
|
err := d.sql.QueryRow(`SELECT COUNT(*) FROM users`).Scan(&n)
|
|
return n, err
|
|
}
|