Fix assignee filter bug in List

2026-03-29 18:58:34 +02:00
parent 9e8c37564f
commit 13b4c4b651
22 changed files with 939 additions and 555 deletions
--- a/service/config.go
+++ b/service/config.go
@@ -0,0 +1,17 @@
+package service
+
+type Alias struct {
+	Name        string `json:"name"`
+	Command     string `json:"command"`
+	Description string `json:"description,omitempty"`
+}
+
+type Config interface {
+	GetUser() string
+	SetUser(username string) error
+	GetAlias(name string) (*Alias, error)
+	SetAlias(alias *Alias) error
+	DeleteAlias(name string) error
+	ListAliases() ([]*Alias, error)
+	Save() error
+}
--- a/service/fileconfig.go
+++ b/service/fileconfig.go
@@ -0,0 +1,165 @@
+package service
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"os/user"
+	"path/filepath"
+	"slices"
+	"strings"
+)
+
+type fileConfig struct {
+	path        string
+	User        string   `json:"user"`
+	UserAliases []*Alias `json:"aliases"`
+}
+
+var defaultAliases = []*Alias{
+	{Name: "mine", Command: "list --assignee $me --tag _status::open", Description: "Show open tasks assigned to you"},
+	{Name: "due", Command: "list --tag _status::open --tag _due", Description: "Show open tasks with due dates"},
+	{Name: "new", Command: "create $@", Description: "Create a new task"},
+}
+
+func LoadConfig() (Config, error) {
+	path, err := findConfigPath()
+	if err != nil {
+		return nil, err
+	}
+	return loadConfig(path)
+}
+
+func loadConfig(path string) (*fileConfig, error) {
+	fc := &fileConfig{path: path, UserAliases: []*Alias{}}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+	} else {
+		if err := json.Unmarshal(data, fc); err != nil {
+			return nil, err
+		}
+	}
+	return fc, nil
+}
+
+func findConfigPath() (string, error) {
+	dir, err := filepath.Abs(".")
+	if err != nil {
+		return "", err
+	}
+	for {
+		p := filepath.Join(dir, ".axconfig")
+		if _, err := os.Stat(p); err == nil {
+			return p, nil
+		}
+		if parent := filepath.Dir(dir); parent == dir {
+			break
+		} else {
+			dir = parent
+		}
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".config", "ax", "config.json"), nil
+}
+
+func (c *fileConfig) GetUser() string {
+	if c.User != "" {
+		return c.User
+	}
+	if u := os.Getenv("AX_USER"); u != "" {
+		return u
+	}
+	if u, err := user.Current(); err == nil {
+		return u.Username
+	}
+	return "unknown"
+}
+
+func (c *fileConfig) SetUser(username string) error {
+	c.User = username
+	return c.Save()
+}
+
+func (c *fileConfig) GetAlias(name string) (*Alias, error) {
+	for _, a := range c.UserAliases {
+		if a.Name == name {
+			return a, nil
+		}
+	}
+	for _, a := range defaultAliases {
+		if a.Name == name {
+			return a, nil
+		}
+	}
+	return nil, errors.New("alias not found")
+}
+
+func (c *fileConfig) SetAlias(alias *Alias) error {
+	for i, a := range c.UserAliases {
+		if a.Name == alias.Name {
+			c.UserAliases[i] = alias
+			return c.Save()
+		}
+	}
+	c.UserAliases = append(c.UserAliases, alias)
+	return c.Save()
+}
+
+func (c *fileConfig) DeleteAlias(name string) error {
+	for i, a := range c.UserAliases {
+		if a.Name == name {
+			c.UserAliases = slices.Delete(c.UserAliases, i, i+1)
+			return c.Save()
+		}
+	}
+	for _, a := range defaultAliases {
+		if a.Name == name {
+			return errors.New("cannot delete default alias")
+		}
+	}
+	return errors.New("alias not found")
+}
+
+func (c *fileConfig) ListAliases() ([]*Alias, error) {
+	seen := make(map[string]bool)
+	var result []*Alias
+	for _, a := range c.UserAliases {
+		result = append(result, a)
+		seen[a.Name] = true
+	}
+	for _, a := range defaultAliases {
+		if !seen[a.Name] {
+			result = append(result, a)
+		}
+	}
+	return result, nil
+}
+
+func (c *fileConfig) Save() error {
+	if err := os.MkdirAll(filepath.Dir(c.path), 0755); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(c, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(c.path, data, 0644)
+}
+
+func ExpandAlias(alias *Alias, args []string, currentUser string) []string {
+	cmd := alias.Command
+	cmd = strings.ReplaceAll(cmd, "$me", currentUser)
+	if len(args) > 0 {
+		cmd = strings.ReplaceAll(cmd, "$@", strings.Join(args, " "))
+	}
+	for i, arg := range args {
+		cmd = strings.ReplaceAll(cmd, "$"+string(rune('1'+i)), arg)
+	}
+	return strings.Fields(cmd)
+}
--- a/service/mentions.go
+++ b/service/mentions.go
@@ -0,0 +1,17 @@
+package service
+
+import (
+	"maps"
+	"regexp"
+	"slices"
+)
+
+var mentionRegex = regexp.MustCompile(`@([a-z0-9_]+)`)
+
+func mentions(t string) []string {
+	seen := make(map[string]bool)
+	for _, m := range mentionRegex.FindAllStringSubmatch(t, -1) {
+		seen[m[1]] = true
+	}
+	return slices.Collect(maps.Keys(seen))
+}
--- a/service/node_service.go
+++ b/service/node_service.go
@@ -0,0 +1,33 @@
+package service
+
+import "axolotl/models"
+
+type NodeService interface {
+	Create(title, content, dueDate string, tags []string, rels map[models.RelType][]string) (*models.Node, error)
+	Update(node *models.Node) error
+	Delete(id string) error
+	GetByID(id string) (*models.Node, error)
+	List(opts ...ListOption) ([]*models.Node, error)
+	Exists(id string) (bool, error)
+	CanClose(id string) (bool, []string, error)
+}
+
+type listFilter struct {
+	tagPrefixes  []string
+	assignee     string
+	mentionsUser string
+}
+
+type ListOption func(*listFilter)
+
+func WithTags(prefixes ...string) ListOption {
+	return func(f *listFilter) { f.tagPrefixes = prefixes }
+}
+
+func WithAssignee(userID string) ListOption {
+	return func(f *listFilter) { f.assignee = userID }
+}
+
+func WithMentions(userID string) ListOption {
+	return func(f *listFilter) { f.mentionsUser = userID }
+}
--- a/service/node_service_sqlite.go
+++ b/service/node_service_sqlite.go
@@ -0,0 +1,506 @@
+package service
+
+import (
+	"axolotl/models"
+	"database/sql"
+	"math/rand"
+	"slices"
+	"strings"
+	"time"
+)
+
+type sqliteNodeService struct {
+	db     *sql.DB
+	userID string
+}
+
+func NewSQLiteNodeService(db *sql.DB, userID string) NodeService {
+	return &sqliteNodeService{db: db, userID: userID}
+}
+
+func (s *sqliteNodeService) GetByID(id string) (*models.Node, error) {
+	n := &models.Node{Relations: make(map[string][]string)}
+	q := s.db.QueryRow("SELECT id, title, COALESCE(content, ''), COALESCE(due_date, ''), created_at, updated_at FROM nodes WHERE id = ?", id)
+	if err := q.Scan(&n.ID, &n.Title, &n.Content, &n.DueDate, &n.CreatedAt, &n.UpdatedAt); err != nil {
+		return nil, err
+	}
+
+	if rows, err := s.db.Query("SELECT tag FROM tags WHERE node_id = ?", id); err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var tag string
+			rows.Scan(&tag)
+			n.Tags = append(n.Tags, tag)
+		}
+	} else {
+		return nil, err
+	}
+
+	if rows, err := s.db.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id); err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var toID, relType string
+			rows.Scan(&toID, &relType)
+			n.Relations[relType] = append(n.Relations[relType], toID)
+		}
+	} else {
+		return nil, err
+	}
+	return n, nil
+}
+
+func (s *sqliteNodeService) Exists(id string) (bool, error) {
+	var e bool
+	err := s.db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&e)
+	return e, err
+}
+
+func (s *sqliteNodeService) Delete(id string) error {
+	_, err := s.db.Exec("DELETE FROM nodes WHERE id = ?", id)
+	return err
+}
+
+func (s *sqliteNodeService) CanClose(id string) (bool, []string, error) {
+	rows, err := s.db.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", id, models.RelBlocks)
+	if err != nil {
+		return false, nil, err
+	}
+	defer rows.Close()
+	var blocking []string
+	for rows.Next() {
+		var bID, tag string
+		if err := rows.Scan(&bID); err != nil {
+			return false, nil, err
+		}
+		if err := s.db.QueryRow("SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", bID).Scan(&tag); err == sql.ErrNoRows {
+			continue
+		} else if err != nil {
+			return false, nil, err
+		}
+		if strings.HasSuffix(tag, "::open") {
+			blocking = append(blocking, bID)
+		}
+	}
+	return len(blocking) == 0, blocking, nil
+}
+
+func genID() string {
+	b := make([]byte, 5)
+	for i := range b {
+		b[i] = "abcdefghijklmnopqrstuvwxyz"[rand.Intn(26)]
+	}
+	return string(b)
+}
+
+func (s *sqliteNodeService) generateUniqueID() string {
+	for {
+		id := genID()
+		if exists, _ := s.Exists(id); !exists {
+			return id
+		}
+	}
+}
+
+func (s *sqliteNodeService) Create(title, content, dueDate string, tags []string, rels map[models.RelType][]string) (*models.Node, error) {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	now, id := time.Now().UTC().Format(time.RFC3339), s.generateUniqueID()
+	if _, err := tx.Exec("INSERT INTO nodes (id, title, content, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+		id, title, content, dueDate, now, now); err != nil {
+		return nil, err
+	}
+
+	for _, m := range mentions(title + " " + content) {
+		userID, err := s.resolveUserRef(tx, m)
+		if err != nil {
+			return nil, err
+		}
+		if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, userID, models.RelMentions); err != nil {
+			return nil, err
+		}
+	}
+
+	for _, t := range tags {
+		if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, t); err != nil {
+			return nil, err
+		}
+	}
+
+	hasCreated := false
+	for rt, tgts := range rels {
+		for _, tgt := range tgts {
+			if rt == models.RelCreated {
+				hasCreated = true
+			}
+			if rt == models.RelAssignee || rt == models.RelCreated {
+				var err error
+				if tgt, err = s.resolveUserRef(tx, tgt); err != nil {
+					return nil, err
+				}
+			}
+			if rt == models.RelInNamespace {
+				var err error
+				if tgt, err = s.resolveNamespaceRef(tx, tgt); err != nil {
+					return nil, err
+				}
+			}
+			if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt); err != nil {
+				return nil, err
+			}
+		}
+	}
+	if !hasCreated {
+		userID, err := s.resolveUserRef(tx, s.userID)
+		if err != nil {
+			return nil, err
+		}
+		if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, userID, models.RelCreated); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+	return s.GetByID(id)
+}
+
+func (s *sqliteNodeService) Update(node *models.Node) error {
+	current, err := s.GetByID(node.ID)
+	if err != nil {
+		return err
+	}
+
+	tx, err := s.db.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	upd := func(col, val string) error {
+		_, err := tx.Exec("UPDATE nodes SET "+col+" = ? WHERE id = ?", val, node.ID)
+		return err
+	}
+
+	newTitle, newContent := current.Title, current.Content
+	if node.Title != current.Title {
+		if err := upd("title", node.Title); err != nil {
+			return err
+		}
+		newTitle = node.Title
+	}
+	if node.Content != current.Content {
+		if err := upd("content", node.Content); err != nil {
+			return err
+		}
+		newContent = node.Content
+	}
+	if node.DueDate != current.DueDate {
+		if node.DueDate == "" {
+			if _, err := tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", node.ID); err != nil {
+				return err
+			}
+		} else {
+			if err := upd("due_date", node.DueDate); err != nil {
+				return err
+			}
+		}
+	}
+
+	if node.Title != current.Title || node.Content != current.Content {
+		newMentions := mentions(newTitle + " " + newContent)
+		rows, err := tx.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", node.ID, models.RelMentions)
+		if err != nil {
+			return err
+		}
+		existingMentionIDs := make(map[string]bool)
+		for rows.Next() {
+			var uid string
+			if err := rows.Scan(&uid); err != nil {
+				rows.Close()
+				return err
+			}
+			existingMentionIDs[uid] = true
+		}
+		rows.Close()
+
+		mentionedUserIDs := make(map[string]bool)
+		for _, m := range newMentions {
+			userID, err := s.resolveUserRef(tx, m)
+			if err != nil {
+				return err
+			}
+			mentionedUserIDs[userID] = true
+			if !existingMentionIDs[userID] {
+				if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", node.ID, userID, models.RelMentions); err != nil {
+					return err
+				}
+			}
+		}
+
+		for uid := range existingMentionIDs {
+			if !mentionedUserIDs[uid] {
+				if _, err := tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", node.ID, uid, models.RelMentions); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	for _, t := range current.Tags {
+		if !slices.Contains(node.Tags, t) {
+			tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", node.ID, t)
+		}
+	}
+	for _, t := range node.Tags {
+		if !slices.Contains(current.Tags, t) {
+			tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", node.ID, t)
+		}
+	}
+
+	for rt, tgts := range current.Relations {
+		for _, tgt := range tgts {
+			if node.Relations[rt] == nil || !slices.Contains(node.Relations[rt], tgt) {
+				tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", node.ID, tgt, rt)
+			}
+		}
+	}
+	for rt, tgts := range node.Relations {
+		for _, tgt := range tgts {
+			if current.Relations[rt] == nil || !slices.Contains(current.Relations[rt], tgt) {
+				resolvedTgt := tgt
+				if models.RelType(rt) == models.RelAssignee || models.RelType(rt) == models.RelCreated {
+					var err error
+					if resolvedTgt, err = s.resolveUserRef(tx, tgt); err != nil {
+						return err
+					}
+				}
+				if models.RelType(rt) == models.RelInNamespace {
+					var err error
+					if resolvedTgt, err = s.resolveNamespaceRef(tx, tgt); err != nil {
+						return err
+					}
+				}
+				tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", node.ID, resolvedTgt, rt)
+			}
+		}
+	}
+
+	if _, err := tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", time.Now().UTC().Format(time.RFC3339), node.ID); err != nil {
+		return err
+	}
+	return tx.Commit()
+}
+
+func (s *sqliteNodeService) resolveUserIDByNameTx(tx *sql.Tx, username string) (string, error) {
+	var id string
+	var err error
+	if tx != nil {
+		err = tx.QueryRow(`
+			SELECT n.id FROM nodes n
+			JOIN tags t ON n.id = t.node_id
+			WHERE n.title = ? AND t.tag = '_type::user'
+			LIMIT 1
+		`, username).Scan(&id)
+	} else {
+		err = s.db.QueryRow(`
+			SELECT n.id FROM nodes n
+			JOIN tags t ON n.id = t.node_id
+			WHERE n.title = ? AND t.tag = '_type::user'
+			LIMIT 1
+		`, username).Scan(&id)
+	}
+	if err == sql.ErrNoRows {
+		return "", nil
+	}
+	if err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+func (s *sqliteNodeService) resolveUserIDByName(username string) (string, error) {
+	return s.resolveUserIDByNameTx(nil, username)
+}
+
+func (s *sqliteNodeService) resolveNamespaceIDByNameTx(tx *sql.Tx, name string) (string, error) {
+	var id string
+	var err error
+	if tx != nil {
+		err = tx.QueryRow(`
+			SELECT n.id FROM nodes n
+			JOIN tags t ON n.id = t.node_id
+			WHERE n.title = ? AND t.tag = '_type::namespace'
+			LIMIT 1
+		`, name).Scan(&id)
+	} else {
+		err = s.db.QueryRow(`
+			SELECT n.id FROM nodes n
+			JOIN tags t ON n.id = t.node_id
+			WHERE n.title = ? AND t.tag = '_type::namespace'
+			LIMIT 1
+		`, name).Scan(&id)
+	}
+	if err == sql.ErrNoRows {
+		return "", nil
+	}
+	if err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+func (s *sqliteNodeService) resolveNamespaceIDByName(name string) (string, error) {
+	return s.resolveNamespaceIDByNameTx(nil, name)
+}
+
+func (s *sqliteNodeService) List(opts ...ListOption) ([]*models.Node, error) {
+	f := &listFilter{}
+	for _, opt := range opts {
+		opt(f)
+	}
+
+	q, joins, whereConds, havingConds := "SELECT DISTINCT n.id FROM nodes n", []string{}, []string{}, []string{}
+	var whereArgs, havingArgs []any
+	if len(f.tagPrefixes) == 0 {
+		f.tagPrefixes = append(f.tagPrefixes, "")
+	}
+
+	joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
+	cond := ""
+	for _, t := range f.tagPrefixes {
+		cond += "t_tag.tag LIKE ? || '%' OR "
+		havingArgs = append(havingArgs, t)
+	}
+	havingConds = append(havingConds, "SUM(CASE WHEN "+cond[:len(cond)-4]+" THEN 1 ELSE 0 END) >= ?")
+	havingArgs = append(havingArgs, len(f.tagPrefixes))
+
+	if f.assignee != "" {
+		userID, err := s.resolveUserIDByName(f.assignee)
+		if err != nil {
+			return nil, err
+		}
+		if userID == "" {
+			return []*models.Node{}, nil
+		}
+		joins = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id")
+		whereConds = append(whereConds, "r_assign.to_id = ? AND r_assign.rel_type = ?")
+		whereArgs = append(whereArgs, userID, models.RelAssignee)
+	}
+	if f.mentionsUser != "" {
+		userID, err := s.resolveUserIDByName(f.mentionsUser)
+		if err != nil {
+			return nil, err
+		}
+		if userID == "" {
+			return []*models.Node{}, nil
+		}
+		joins = append(joins, "JOIN rels r_mentions ON n.id = r_mentions.from_id")
+		whereConds = append(whereConds, "r_mentions.to_id = ? AND r_mentions.rel_type = ?")
+		whereArgs = append(whereArgs, userID, models.RelMentions)
+	}
+
+	if len(joins) > 0 {
+		q += " " + strings.Join(joins, " ") + " "
+	}
+	if len(whereConds) > 0 {
+		q += " WHERE " + strings.Join(whereConds, " AND ")
+	}
+	q += " GROUP BY n.id"
+	if len(havingConds) > 0 {
+		q += " HAVING " + strings.Join(havingConds, " AND ")
+	}
+
+	args := append(whereArgs, havingArgs...)
+	rows, err := s.db.Query(q+" ORDER BY n.created_at DESC", args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var nodes []*models.Node
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		if n, err := s.GetByID(id); err == nil {
+			nodes = append(nodes, n)
+		} else {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (s *sqliteNodeService) resolveUserRef(tx *sql.Tx, ref string) (string, error) {
+	if exists, _ := s.Exists(ref); exists {
+		return ref, nil
+	}
+	return s.ensureUser(tx, ref)
+}
+
+func (s *sqliteNodeService) ensureUser(tx *sql.Tx, username string) (string, error) {
+	userID, err := s.resolveUserIDByNameTx(tx, username)
+	if err != nil {
+		return "", err
+	}
+	if userID != "" {
+		return userID, nil
+	}
+
+	id := s.generateUniqueID()
+	now := time.Now().UTC().Format(time.RFC3339)
+	if _, err := tx.Exec("INSERT INTO nodes (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
+		id, username, now, now); err != nil {
+		return "", err
+	}
+	if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, '_type::user')", id); err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+func (s *sqliteNodeService) resolveNamespaceRef(tx *sql.Tx, ref string) (string, error) {
+	if exists, _ := s.Exists(ref); exists {
+		return ref, nil
+	}
+	return s.ensureNamespace(tx, ref)
+}
+
+func (s *sqliteNodeService) ensureNamespace(tx *sql.Tx, name string) (string, error) {
+	nsID, err := s.resolveNamespaceIDByNameTx(tx, name)
+	if err != nil {
+		return "", err
+	}
+	if nsID != "" {
+		return nsID, nil
+	}
+
+	id := s.generateUniqueID()
+	now := time.Now().UTC().Format(time.RFC3339)
+	if _, err := tx.Exec("INSERT INTO nodes (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
+		id, name, now, now); err != nil {
+		return "", err
+	}
+	if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, '_type::namespace')", id); err != nil {
+		return "", err
+	}
+	if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
+		id, id, models.RelInNamespace); err != nil {
+		return "", err
+	}
+	userID, err := s.resolveUserRef(tx, s.userID)
+	if err != nil {
+		return "", err
+	}
+	if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
+		id, userID, models.RelCreated); err != nil {
+		return "", err
+	}
+	return id, nil
+}