first working login and editing of file. bugg is för rendering with tiptap

backend/internal/db/db.go

@@ -0,0 +1,148 @@
+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
+}
+
+// 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
+}

backend/internal/graph/server.go

@@ -285,21 +285,27 @@ func (s *Server) handleServerDirectories(w http.ResponseWriter, req gqlRequest,
 // ── Session helpers ───────────────────────────────────────────────────────────
 
 func (s *Server) sessionFromRequest(r *http.Request) *auth.Session {
-	raw := r.Header.Get("Authorization")
-	if !strings.HasPrefix(raw, "Bearer ") {
-		return nil
-	}
-	token := strings.TrimPrefix(raw, "Bearer ")
+        raw := r.Header.Get("Authorization")
+        if !strings.HasPrefix(raw, "Bearer ") {
+                log.Printf("[auth] No Bearer token found in header")
+                return nil
+        }
+        token := strings.TrimPrefix(raw, "Bearer ")
 
-	s.mu.RLock()
-	mgr := s.authMgr
-	s.mu.RUnlock()
+        s.mu.RLock()
+        mgr := s.authMgr
+        s.mu.RUnlock()
 
-	if mgr == nil {
-		return nil
-	}
-	sess, _ := mgr.Validate(token)
-	return sess
+        if mgr == nil {
+                log.Printf("[auth] authmgr is nil")
+                return nil
+        }
+        sess, err := mgr.Validate(token)
+        if err != nil {
+                log.Printf("[auth] Token validation failed: %v", err)
+                return nil
+        }
+        return sess
 }
 
 // ── Document handlers ─────────────────────────────────────────────────────────
@@ -514,16 +520,12 @@ func (s *Server) handleLogin(w http.ResponseWriter, req gqlRequest) {
 		return
 	}
 
-	log.Printf("[auth] login: %s (%s)", username, role)
-	writeJSONObj(w, map[string]interface{}{
-		"data": map[string]interface{}{
-			"login": map[string]interface{}{
-				"token":    token,
-				"username": username,
-				"role":     role,
-			},
-		},
-	})
+	        log.Printf("[auth] login: %s (%s)", username, role)
+        writeJSONObj(w, map[string]interface{}{
+                "data": map[string]interface{}{
+                        "login": token,
+                },
+        })
 }
 
 func (s *Server) handleLogout(w http.ResponseWriter, sess *auth.Session) {
@@ -1213,3 +1215,5 @@ func (s *Server) handleDocumentAtCommit(w http.ResponseWriter, req gqlRequest, s
 }
 
 
+
+