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

switch namespaces from tags to relations with auto-creation

Browse Source
This commit is contained in:
Elias Kohout
2026-03-28 04:15:36 +01:00
parent 9b250c20f9
commit f907657c6f
6 changed files with 128 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
cmd/create.go
View File

@@ -30,12 +30,9 @@ var createCmd = &cobra.Command{
if slices.Contains(cTags, "_type::issue") && !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_status::") }) {
cTags = append(cTags, "_status::open")
}
if !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_namespace::") }) {
cTags = append(cTags, "_namespace::"+db.GetCurrentUser())
}
rels := make(map[models.RelType][]string)
relCreated := false
relCreated, relNamespace := false, false
for _, r := range cRels {
rt, tgt, err := db.ParseRelFlag(r)
if err != nil {
@@ -45,11 +42,17 @@ var createCmd = &cobra.Command{
if rt == models.RelCreated {
relCreated = true
}
if rt == models.RelInNamespace {
relNamespace = true
}
rels[rt] = append(rels[rt], tgt)
}
if !relCreated {
rels[models.RelCreated] = append(rels[models.RelCreated], db.GetCurrentUser())
}
if !relNamespace {
rels[models.RelInNamespace] = append(rels[models.RelInNamespace], db.GetCurrentUser())
}
if n, err := d.CreateNode(db.CreateParams{Title: args[0], Content: cContent, DueDate: cDue, Tags: cTags, Rels: rels}); err != nil {
fmt.Fprintln(os.Stderr, "failed to create:", err)

2
cmd/list.go
View File

@@ -23,7 +23,7 @@ var listCmd = &cobra.Command{
if nodes, err := d.ListNodes(db.ListFilter{TagPrefixes: lTags, Assignee: lAssignee}); err == nil {
output.PrintNodes(cmd.OutOrStdout(), nodes, jsonFlag)
} else {
fmt.Fprintln(os.Stderr, "err: %v", err)
fmt.Fprintf(os.Stderr, "err: %v\n", err)
}
},
}

79
db/node.go
View File

@@ -67,6 +67,50 @@ func (db *DB) resolveUserRef(tx *sql.Tx, ref string) (string, error) {
return db.ensureUser(tx, ref)
}
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
@@ -120,6 +164,12 @@ func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
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
}
@@ -187,6 +237,12 @@ func (db *DB) UpdateNode(id string, p UpdateParams) error {
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)
}
}
@@ -255,7 +311,9 @@ func (db *DB) ListNodes(f ListFilter) ([]*models.Node, error) {
args = append(args, len(f.TagPrefixes))
if f.Assignee != "" {
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)
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 len(joins) > 0 {
@@ -309,22 +367,3 @@ func (db *DB) CanClose(id string) (bool, []string, error) {
}
return len(blocking) == 0, blocking, 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)
if err != nil {
return nil, err
}
defer rows.Close()
var nodes []*models.Node
for rows.Next() {
var id string
rows.Scan(&id)
if n, err := db.NodeByID(id); err == nil {
nodes = append(nodes, n)
} else {
return nil, err
}
}
return nodes, nil
}

12
db/rel.go
View File

@@ -32,3 +32,15 @@ func (db *DB) GetRelated(id string, r models.RelType) ([]string, error) {
func (db *DB) GetIncomingRels(id string, r models.RelType) ([]string, error) {
return getIDs(db, "SELECT from_id FROM rels WHERE to_id = ? AND rel_type = ?", id, r)
}
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 {
return nil, err
}
result = append(result, node.Title)
}
return result, nil
}

11
models/node.go
View File

@@ -21,6 +21,7 @@ const (
RelRelated RelType = "related"
RelCreated RelType = "created"
RelAssignee RelType = "assignee"
RelInNamespace RelType = "in_namespace"
)
func (n *Node) GetProperty(k string) string {
@@ -33,3 +34,13 @@ func (n *Node) GetProperty(k string) string {
}
return ""
}
func (n *Node) GetDisplayTags() []string {
var tags []string
for _, t := range n.Tags {
if !strings.HasPrefix(t, "_") {
tags = append(tags, t)
}
}
return tags
}

69
output/output.go
View File

@@ -46,7 +46,7 @@ var (
"low": {" ", "low", cDim},
"": {" ", "n/a", cDim},
}
relIcons = map[string]string{"blocks": "\uf068", "subtask": "\uf0da", "related": "\uf0c1", "assignee": "\uf007"}
relIcons = map[string]string{"blocks": "\uf068", "subtask": "\uf0da", "related": "\uf0c1", "assignee": "\uf007", "in_namespace": "\uf07b"}
prioRanks = map[string]int{"high": 3, "medium": 2, "low": 1}
statusRanks = map[string]int{"open": 2, "": 1, "done": 0}
)
@@ -72,16 +72,6 @@ func render(rm RenderMap, key string, short bool) string {
return v.c.Sprint(v.l)
}
func getDisplayTags(n *models.Node) []string {
var tags []string
for _, t := range n.Tags {
if !strings.HasPrefix(t, "_") {
tags = append(tags, t)
}
}
return tags
}
func PrintNodes(w io.Writer, nodes []*models.Node, jsonOut bool) error {
if jsonOut {
return json.NewEncoder(w).Encode(nodes)
@@ -91,6 +81,11 @@ func PrintNodes(w io.Writer, nodes []*models.Node, jsonOut bool) error {
return nil
}
d, err := db.GetDB()
if err != nil {
return err
}
fmt.Fprintln(w)
sort.Slice(nodes, func(i, j int) bool {
si, sj := nodes[i].GetProperty("status"), nodes[j].GetProperty("status")
@@ -101,15 +96,19 @@ func PrintNodes(w io.Writer, nodes []*models.Node, jsonOut bool) error {
})
for _, n := range nodes {
tags := getDisplayTags(n)
ns_rels, err := d.GetRelNames(n, models.RelInNamespace)
if err != nil {
return err
}
fmt.Fprintf(w, " %s %s %s %s %s %s",
cDim.Sprint(n.ID),
render(prioRM, n.GetProperty("prio"), true),
render(statusRM, n.GetProperty("status"), true),
render(typeRM, n.GetProperty("type"), true),
cTitle.Sprint(truncate(n.Title, 80)),
cDim.Sprint("["+n.GetProperty("namespace")+"]"),
cDim.Sprint("["+strings.Join(ns_rels, ",")+"]"),
)
tags := n.GetDisplayTags()
if len(tags) > 0 {
fmt.Fprintf(w, " %s", cPrimary.Sprint("#"+strings.Join(tags, " #")))
}
@@ -128,13 +127,33 @@ func PrintNode(w io.Writer, n *models.Node, jsonOut bool) error {
fmt.Fprintln(w, cDim.Sprint(" ───────────────────────────────"))
fmt.Fprintf(w, " Status: %s\n", render(statusRM, n.GetProperty("status"), false))
fmt.Fprintf(w, " Priority: %s\n", render(prioRM, n.GetProperty("prio"), false))
fmt.Fprintf(w, " Namespace: %s\n", cWarn.Sprint(n.GetProperty("namespace")))
if n.DueDate != "" {
fmt.Fprintf(w, " Due: %s %s\n", iconCalendar, n.DueDate)
}
fmt.Fprintf(w, " Created: %s\n", cDim.Sprint(n.CreatedAt))
fmt.Fprintf(w, " Updated: %s\n", cDim.Sprint(n.UpdatedAt))
if tags := n.GetDisplayTags(); len(tags) > 0 {
fmt.Fprintf(w, "\n tags: %s\n", cPrimary.Sprint(strings.Join(tags, " • ")))
}
if db, err := db.GetDB(); err != nil {
fmt.Fprintf(w, "failed to attach to db: %v", err)
} else {
for relType := range n.Relations {
names, err := db.GetRelNames(n, models.RelType(relType))
if err != nil {
fmt.Fprintf(w, "err: %v", err)
}
if len(names) > 0 {
fmt.Fprintf(w, "\n %s\n", string(relType))
}
for _, name := range names {
fmt.Fprintf(w, " %s %s\n", relIcons[relType], name)
}
}
}
if n.Content != "" {
fmt.Fprintln(w, "\n"+cPrimary.Sprint(" Content:"))
for i, line := range strings.Split(n.Content, "\n") {
@@ -146,28 +165,6 @@ func PrintNode(w io.Writer, n *models.Node, jsonOut bool) error {
}
}
if tags := getDisplayTags(n); len(tags) > 0 {
fmt.Fprintf(w, "\n tags: %s\n", cPrimary.Sprint(strings.Join(tags, " • ")))
}
if db, err := db.GetDB(); err == nil {
if len(n.Relations) > 0 {
for relType, ids := range n.Relations {
if relIcon, ok := relIcons[string(relType)]; ok {
fmt.Fprintf(w, "\n %s\n", string(relType))
for _, id := range ids {
node, err := db.NodeByID(id)
if err == nil {
fmt.Fprintf(w, " %s %s\n", relIcon, node.Title)
}
}
}
}
}
} else {
fmt.Fprintf(w, "failed to attach to db: %v", err)
}
fmt.Fprintln(w)
return nil
}