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

refactor: replace explicit fields with tag-based property system

Browse Source
This commit is contained in:
Elias Kohout
2026-03-27 02:11:46 +01:00
parent 2d4cff717b
commit b2225cff7b
17 changed files with 485 additions and 825 deletions
Download Patch File Download Diff File Expand all files Collapse all files

325
db/node.go
View File

@@ -10,37 +10,45 @@ import (
"time"
)
func generateID() string {
const chars = "abcdefghijklmnopqrstuvwxyz"
func genID() string {
b := make([]byte, 5)
for i := range b {
b[i] = chars[rand.Intn(26)]
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 {
//TODO: Check if all ids are reserved
for {
id := generateID()
var exists bool
db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&exists)
if !exists {
id := genID()
e, _ := db.NodeExists(id)
if !e {
return id
}
}
}
type CreateParams struct {
Title string
Content string
DueDate string
Type string
Status string
Priority string
Namespace string
Tags []string
Rels map[models.RelType][]string
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
}
func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
@@ -49,78 +57,35 @@ func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
return nil, err
}
defer tx.Rollback()
now, id := time.Now().UTC().Format(time.RFC3339), db.generateUniqueID()
now := time.Now().UTC().Format(time.RFC3339)
id := 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,
)
_, 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
}
tags := p.Tags
if p.Type != "" {
tags = append(tags, models.PropertyTag("type", p.Type))
} else {
tags = append(tags, models.PropertyTag("type", "issue"))
}
if p.Status != "" {
tags = append(tags, models.PropertyTag("status", p.Status))
}
if p.Priority != "" {
tags = append(tags, models.PropertyTag("prio", p.Priority))
}
ns := p.Namespace
if ns == "" {
ns = GetCurrentUser()
}
tags = append(tags, models.PropertyTag("namespace", ns))
for _, tag := range tags {
if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, tag); err != nil {
for _, t := range append(p.Tags, parse.Mentions(p.Title+" "+p.Content)...) {
if !strings.HasPrefix(t, "_") && strings.HasPrefix(t, "@") {
if _, err = tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, "_inbox::"+t[1:]); err != nil {
return nil, err
}
} else if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, t); err != nil {
return nil, err
}
}
for relType, targets := range p.Rels {
for _, target := range targets {
if _, err := tx.Exec(
"INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
id, target, relType,
); err != nil {
for rt, tgts := range p.Rels {
for _, tgt := range tgts {
if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt); err != nil {
return nil, err
}
}
}
allText := p.Title + " " + p.Content
for _, u := range parse.Mentions(allText) {
tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("inbox", u))
}
if err := tx.Commit(); err != nil {
return nil, err
}
return db.NodeByID(id)
}
type UpdateParams struct {
Title string
Content string
DueDate string
ClearDue bool
Status string
Priority string
AddTags []string
RemoveTags []string
AddRels map[models.RelType][]string
RemoveRels map[models.RelType][]string
}
func (db *DB) UpdateNode(id string, p UpdateParams) error {
tx, err := db.Begin()
if err != nil {
@@ -128,231 +93,197 @@ func (db *DB) UpdateNode(id string, p UpdateParams) error {
}
defer tx.Rollback()
now := time.Now().UTC().Format(time.RFC3339)
_, err = tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", now, id)
if err != nil {
upd := func(col, val string) error {
_, err := tx.Exec("UPDATE nodes SET "+col+" = ? WHERE id = ?", val, id)
return err
}
//TODO: does it make sense to check for emtpy sting? should it be possible to set the content to ""?
if p.Title != "" {
_, err = tx.Exec("UPDATE nodes SET title = ? WHERE id = ?", p.Title, id)
if err != nil {
if err := upd("title", p.Title); err != nil {
return err
}
}
if p.Content != "" {
_, err = tx.Exec("UPDATE nodes SET content = ? WHERE id = ?", p.Content, id)
if err != nil {
if err := upd("content", p.Content); err != nil {
return err
}
}
if p.DueDate != "" {
_, err = tx.Exec("UPDATE nodes SET due_date = ? WHERE id = ?", p.DueDate, id)
if err != nil {
if err := upd("due_date", p.DueDate); err != nil {
return err
}
}
if p.ClearDue {
_, err = tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id)
if err != nil {
if _, err := tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id); err != nil {
return err
}
}
for _, tag := range p.AddTags {
tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, tag)
for _, t := range p.RemoveTags {
tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, t)
}
for _, tag := range p.RemoveTags {
tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, tag)
for _, t := range p.AddTags {
tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, t)
}
if p.Status != "" {
tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", id)
tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("status", p.Status))
}
if p.Priority != "" {
tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag LIKE '_prio::%'", id)
tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("prio", p.Priority))
}
for relType, targets := range p.AddRels {
for _, target := range targets {
tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, target, relType)
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 relType, targets := range p.RemoveRels {
for _, target := range targets {
tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, target, relType)
for rt, tgts := range p.AddRels {
for _, tgt := range tgts {
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 {
//TODO: check if this delete propagates?
_, err := db.Exec("DELETE FROM nodes WHERE id = ?", id)
return err
}
type ListFilter struct {
Type string
Status string
Priority string
Namespace string
Tag string
Inbox string
Assignee string
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 := "SELECT DISTINCT n.id FROM nodes n"
args := []interface{}{}
joins := []string{}
conds := []string{}
q, args, joins, conds := "SELECT DISTINCT n.id FROM nodes n", []any{}, []string{}, []string{}
if len(f.TagPrefixes) == 0 {
f.TagPrefixes = append(f.TagPrefixes, "")
}
if f.Type != "" {
joins = append(joins, "JOIN tags t_type ON n.id = t_type.node_id")
conds = append(conds, "t_type.tag = ?")
args = append(args, models.PropertyTag("type", f.Type))
}
if f.Status != "" {
joins = append(joins, "JOIN tags t_status ON n.id = t_status.node_id")
conds = append(conds, "t_status.tag = ?")
args = append(args, models.PropertyTag("status", f.Status))
}
if f.Priority != "" {
joins = append(joins, "JOIN tags t_prio ON n.id = t_prio.node_id")
conds = append(conds, "t_prio.tag = ?")
args = append(args, models.PropertyTag("prio", f.Priority))
}
if f.Namespace != "" {
joins = append(joins, "JOIN tags t_ns ON n.id = t_ns.node_id")
conds = append(conds, "t_ns.tag = ?")
args = append(args, models.PropertyTag("namespace", f.Namespace))
}
if f.Tag != "" {
joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
conds = append(conds, "t_tag.tag = ?")
args = append(args, f.Tag)
}
if f.Inbox != "" {
joins = append(joins, "JOIN tags t_inbox ON n.id = t_inbox.node_id")
conds = append(conds, "t_inbox.tag = ?")
args = append(args, models.PropertyTag("inbox", f.Inbox))
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)
joins, conds, args = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id"), append(conds, "r_assign.to_id = ? AND r_assign.rel_type = ?"), append(args, f.Assignee, models.RelAssignee)
}
if len(joins) > 0 {
q += " " + strings.Join(joins, " ")
q += " " + strings.Join(joins, " ") + " "
}
q += "GROUP BY n.id"
if len(conds) > 0 {
q += " WHERE " + strings.Join(conds, " AND ")
q += " HAVING " + strings.Join(conds, " AND ")
}
q += " ORDER BY n.created_at DESC"
rows, err := db.Query(q, args...)
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
}
n, err := db.NodeByID(id)
if err != nil {
if n, err := db.NodeByID(id); err == nil {
nodes = append(nodes, n)
} else {
return nil, err
}
nodes = append(nodes, n)
}
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,
)
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 blockerID string
if err := rows.Scan(&blockerID); err != nil {
var bID, tag string
if err := rows.Scan(&bID); err != nil {
return false, nil, err
}
var tag string
err := db.QueryRow(
"SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'",
blockerID,
).Scan(&tag)
if err == sql.ErrNoRows {
blocking = append(blocking, blockerID)
if err := db.QueryRow("SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", bID).Scan(&tag); err == sql.ErrNoRows {
continue
}
if err != nil {
} else if err != nil {
return false, nil, err
}
if strings.HasSuffix(tag, "::open") {
blocking = append(blocking, blockerID)
blocking = append(blocking, bID)
}
}
return len(blocking) == 0, blocking, nil
}
func (db *DB) GetAllUsers() ([]string, error) {
rows, err := db.Query("SELECT n.id FROM nodes n JOIN tags t ON n.id = t.node_id WHERE t.tag = ?", models.PropertyTag("type", "user"))
//TODO: Seperate sql query for performance
nodes, err := db.ListNodes(ListFilter{TagPrefixes: []string{"_type::user"}})
if err != nil {
return nil, err
}
defer rows.Close()
var users []string
for rows.Next() {
var id string
rows.Scan(&id)
users = append(users, id)
users := make([]string, len(nodes))
for i, n := range nodes {
users[i] = n.ID
}
return users, nil
}
func (db *DB) GetSubtasks(parentID string) ([]*models.Node, error) {
rows, err := db.Query(
"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
parentID, models.RelSubtask,
)
rows, err := db.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", parentID, models.RelSubtask)
if err != nil {
return nil, err
}
defer rows.Close()
var nodes []*models.Node
for rows.Next() {
var id string
rows.Scan(&id)
n, err := db.NodeByID(id)
if err != nil {
if n, err := db.NodeByID(id); err == nil {
nodes = append(nodes, n)
} else {
return nil, err
}
nodes = append(nodes, n)
}
return nodes, nil
}
func ParseRelFlag(s string) (models.RelType, string, error) {
parts := strings.SplitN(s, ":", 2)
if len(parts) != 2 {
return "", "", fmt.Errorf("invalid relation format: %s (expected type:id)", s)
}
return models.RelType(parts[0]), parts[1], nil
}