eliaskohout/ax
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix assignee filter bug in List

Browse Source
This commit is contained in:
Elias Kohout
2026-03-29 18:58:34 +02:00
parent 9e8c37564f
commit 13b4c4b651
22 changed files with 939 additions and 555 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
db/alias.go
View File

@@ -1,42 +0,0 @@
package db
import "errors"
type Alias struct{ Name, Command string }
func (db *DB) GetAlias(n string) (*Alias, error) {
a := &Alias{}
err := db.QueryRow("SELECT name, command FROM aliases WHERE name = ?", n).Scan(&a.Name, &a.Command)
return a, err
}
func (db *DB) SetAlias(n, c string) error {
_, err := db.Exec("INSERT INTO aliases (name, command) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET command = excluded.command", n, c)
return err
}
func (db *DB) DeleteAlias(n string) error {
res, err := db.Exec("DELETE FROM aliases WHERE name = ?", n)
if err != nil {
return err
}
if a, _ := res.RowsAffected(); a == 0 {
return errors.New("alias not found")
}
return nil
}
func (db *DB) ListAliases() ([]*Alias, error) {
rows, err := db.Query("SELECT name, command FROM aliases ORDER BY name")
if err != nil {
return nil, err
}
defer rows.Close()
var aliases []*Alias
for rows.Next() {
a := &Alias{}
rows.Scan(&a.Name, &a.Command)
aliases = append(aliases, a)
}
return aliases, nil
}

18
db/db.go
View File

@@ -5,7 +5,6 @@ import (
"errors"
"fmt"
"os"
"os/user"
"path/filepath"
_ "modernc.org/sqlite"
@@ -22,7 +21,6 @@ var (
`CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, title TEXT NOT NULL, content TEXT, due_date TEXT, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)`,
`CREATE TABLE IF NOT EXISTS tags (node_id TEXT NOT NULL, tag TEXT NOT NULL, PRIMARY KEY (node_id, tag), FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
`CREATE TABLE IF NOT EXISTS rels (from_id TEXT NOT NULL, to_id TEXT NOT NULL, rel_type TEXT NOT NULL, PRIMARY KEY (from_id, to_id, rel_type), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE, FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
`CREATE TABLE IF NOT EXISTS aliases (name TEXT PRIMARY KEY, command TEXT NOT NULL)`,
`CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)`, `CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`, `CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`,
}
)
@@ -72,12 +70,14 @@ func Open(path string) (*DB, error) {
return &DB{DB: db, path: path}, nil
}
func GetCurrentUser() string {
if u := os.Getenv("AX_USER"); u != "" {
return u
func (db *DB) GetUserByUsername(username string) (string, error) {
var id string
err := 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'`, username).Scan(&id)
if err == sql.ErrNoRows {
return "", nil
}
if u, err := user.Current(); err == nil {
return u.Username
}
return "unknown"
return id, err
}

431
db/node.go
View File

@@ -1,431 +0,0 @@
package db
import (
"axolotl/models"
"axolotl/parse"
"database/sql"
"fmt"
"math/rand"
"strings"
"time"
)
func genID() string {
b := make([]byte, 5)
for i := range b {
b[i] = "abcdefghijklmnopqrstuvwxyz"[rand.Intn(26)]
}
return string(b)
}
func ParseRelFlag(s string) (models.RelType, string, error) {
if p := strings.SplitN(s, ":", 2); len(p) == 2 {
return models.RelType(p[0]), p[1], nil
}
return "", "", fmt.Errorf("invalid relation format: %s (expected type:id)", s)
}
func (db *DB) generateUniqueID() string {
for {
id := genID()
e, _ := db.NodeExists(id)
if !e {
return id
}
}
}
func (db *DB) ensureUser(tx *sql.Tx, username string) (string, error) {
var existingID string
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'`, username).Scan(&existingID)
if err == nil {
return existingID, nil
}
if err != sql.ErrNoRows {
return "", err
}
id := db.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 (db *DB) resolveUserRef(tx *sql.Tx, ref string) (string, error) {
if exists, _ := db.NodeExists(ref); exists {
return ref, nil
}
return db.ensureUser(tx, ref)
}
func (db *DB) GetUserByUsername(username string) (string, error) {
var id string
err := 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'`, username).Scan(&id)
if err == sql.ErrNoRows {
return "", nil
}
return id, err
}
func (db *DB) ensureNamespace(tx *sql.Tx, name string) (string, error) {
var existingID string
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'`, name).Scan(&existingID)
if err == nil {
return existingID, nil
}
if err != sql.ErrNoRows {
return "", err
}
id := db.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 := db.resolveUserRef(tx, GetCurrentUser())
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
}
func (db *DB) resolveNamespaceRef(tx *sql.Tx, ref string) (string, error) {
if exists, _ := db.NodeExists(ref); exists {
return ref, nil
}
return db.ensureNamespace(tx, ref)
}
type CreateParams struct {
Title, Content, DueDate string
Tags []string
Rels map[models.RelType][]string
}
type UpdateParams struct {
Title, Content, DueDate *string
ClearDue bool
AddTags, RemoveTags []string
AddRels, RemoveRels map[models.RelType][]string
}
type ListFilter struct {
TagPrefixes []string
Assignee string
MentionsUser string
}
func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
now, id := time.Now().UTC().Format(time.RFC3339), db.generateUniqueID()
_, err = tx.Exec("INSERT INTO nodes (id, title, content, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
id, p.Title, p.Content, p.DueDate, now, now)
if err != nil {
return nil, err
}
for _, m := range parse.Mentions(p.Title + " " + p.Content) {
userID, err := db.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 p.Tags {
if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, t); err != nil {
return nil, err
}
}
for rt, tgts := range p.Rels {
for _, tgt := range tgts {
if rt == models.RelAssignee || rt == models.RelCreated {
var err error
if tgt, err = db.resolveUserRef(tx, tgt); err != nil {
return nil, err
}
}
if rt == models.RelInNamespace {
var err error
if tgt, err = db.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 err := tx.Commit(); err != nil {
return nil, err
}
return db.NodeByID(id)
}
func (db *DB) UpdateNode(id string, p UpdateParams) error {
tx, err := db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var currentTitle, currentContent string
err = tx.QueryRow("SELECT title, COALESCE(content, '') FROM nodes WHERE id = ?", id).Scan(&currentTitle, &currentContent)
if err != nil {
return err
}
upd := func(col, val string) error {
_, err := tx.Exec("UPDATE nodes SET "+col+" = ? WHERE id = ?", val, id)
return err
}
newTitle, newContent := currentTitle, currentContent
if p.Title != nil {
if err := upd("title", *p.Title); err != nil {
return err
}
newTitle = *p.Title
}
if p.Content != nil {
if err := upd("content", *p.Content); err != nil {
return err
}
newContent = *p.Content
}
if p.DueDate != nil {
if err := upd("due_date", *p.DueDate); err != nil {
return err
}
}
if p.ClearDue {
if _, err := tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id); err != nil {
return err
}
}
if p.Title != nil || p.Content != nil {
newMentions := parse.Mentions(newTitle + " " + newContent)
rows, err := tx.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", 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 := db.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 (?, ?, ?)", 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 = ?", id, uid, models.RelMentions); err != nil {
return err
}
}
}
}
for _, t := range p.RemoveTags {
tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, t)
}
for _, t := range p.AddTags {
tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, t)
}
for rt, tgts := range p.RemoveRels {
for _, tgt := range tgts {
tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, tgt, rt)
}
}
for rt, tgts := range p.AddRels {
for _, tgt := range tgts {
if rt == models.RelAssignee || rt == models.RelCreated {
var err error
if tgt, err = db.resolveUserRef(tx, tgt); err != nil {
return err
}
}
if rt == models.RelInNamespace {
var err error
if tgt, err = db.resolveNamespaceRef(tx, tgt); err != nil {
return err
}
}
tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt)
}
}
if _, err = tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", time.Now().UTC().Format(time.RFC3339), id); err != nil {
return err
}
return tx.Commit()
}
func (db *DB) DeleteNode(id string) error {
_, err := db.Exec("DELETE FROM nodes WHERE id = ?", id)
return err
}
func (db *DB) NodeExists(id string) (bool, error) {
var e bool
err := db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&e)
return e, err
}
func (db *DB) NodeByID(id string) (*models.Node, error) {
n := &models.Node{Relations: make(map[string][]string)}
q := 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 := 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 := 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 (db *DB) ListNodes(f ListFilter) ([]*models.Node, error) {
q, args, joins, conds := "SELECT DISTINCT n.id FROM nodes n", []any{}, []string{}, []string{}
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 "
args = append(args, t)
}
conds = append(conds, "SUM(CASE WHEN "+cond[:len(cond)-4]+" THEN 1 ELSE 0 END) >= ?")
args = append(args, len(f.TagPrefixes))
if f.Assignee != "" {
joins = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id")
conds = append(conds, "r_assign.to_id = ? AND r_assign.rel_type = ?")
args = append(args, f.Assignee, models.RelAssignee)
}
if f.MentionsUser != "" {
joins = append(joins, "JOIN rels r_mentions ON n.id = r_mentions.from_id")
conds = append(conds, "r_mentions.to_id = ? AND r_mentions.rel_type = ?")
args = append(args, f.MentionsUser, models.RelMentions)
}
if len(joins) > 0 {
q += " " + strings.Join(joins, " ") + " "
}
q += "GROUP BY n.id"
if len(conds) > 0 {
q += " HAVING " + strings.Join(conds, " AND ")
}
rows, err := 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 := db.NodeByID(id); err == nil {
nodes = append(nodes, n)
} else {
return nil, err
}
}
return nodes, nil
}
func (db *DB) CanClose(id string) (bool, []string, error) {
rows, err := 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 := 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
}

14
db/rel.go
View File

@@ -34,13 +34,17 @@ func (db *DB) GetIncomingRels(id string, r models.RelType) ([]string, error) {
}
func (db *DB) GetRelNames(n *models.Node, r models.RelType) ([]string, error) {
result := make([]string, 0, len(n.Relations[string(r)]))
for _, id := range n.Relations[string(r)] {
node, err := db.NodeByID(id)
if err != nil {
ids := n.Relations[string(r)]
if len(ids) == 0 {
return nil, nil
}
result := make([]string, 0, len(ids))
for _, id := range ids {
var title string
if err := db.QueryRow("SELECT title FROM nodes WHERE id = ?", id).Scan(&title); err != nil {
return nil, err
}
result = append(result, node.Title)
result = append(result, title)
}
return result, nil
}