From 6288879468508a15b120be7c10553dedebd40d4b Mon Sep 17 00:00:00 2001 From: Elias Kohout Date: Wed, 1 Apr 2026 12:50:45 +0200 Subject: [PATCH] refactor: unify tags and edges into single rels table --- cmd/add.go | 18 +-- cmd/list.go | 19 +-- cmd/rel.go | 20 +++- cmd/update.go | 29 +++-- models/node.go | 26 ++-- service/node_service.go | 24 ++-- service/node_service_impl.go | 223 ++++++++++++++++++++--------------- store/sqlite.go | 165 +++++++++++++------------- store/store.go | 21 ++-- 9 files changed, 296 insertions(+), 249 deletions(-) diff --git a/cmd/add.go b/cmd/add.go index a515b35..b8abcb2 100644 --- a/cmd/add.go +++ b/cmd/add.go @@ -26,18 +26,22 @@ var addCmd = &cobra.Command{ Title: args[0], Content: cContent, DueDate: cDue, - Tags: append([]string{}, cTags...), } - // Shorthand flags expand to tags or rels. + // --tag is an alias for --rel with no target. + for _, tag := range cTags { + input.Rels = append(input.Rels, service.RelInput{Type: models.RelType(tag), Target: ""}) + } + + // Shorthand flags expand to property rels or edge rels. if cType != "" { - input.Tags = append(input.Tags, "_type::"+cType) + input.Rels = append(input.Rels, service.RelInput{Type: models.RelType("_type::" + cType), Target: ""}) } if cStatus != "" { - input.Tags = append(input.Tags, "_status::"+cStatus) + input.Rels = append(input.Rels, service.RelInput{Type: models.RelType("_status::" + cStatus), Target: ""}) } if cPrio != "" { - input.Tags = append(input.Tags, "_prio::"+cPrio) + input.Rels = append(input.Rels, service.RelInput{Type: models.RelType("_prio::" + cPrio), Target: ""}) } if cNamespace != "" { input.Rels = append(input.Rels, service.RelInput{Type: models.RelInNamespace, Target: cNamespace}) @@ -75,6 +79,6 @@ func init() { f.StringVar(&cAssignee, "assignee", "", "assignee username or ID") f.StringVar(&cDue, "due", "", "due date") f.StringVar(&cContent, "content", "", "node body") - f.StringArrayVar(&cTags, "tag", nil, "custom tags") - f.StringArrayVar(&cRels, "rel", nil, "additional relations (type:target)") + f.StringArrayVar(&cTags, "tag", nil, "label tag (alias for --rel tagname)") + f.StringArrayVar(&cRels, "rel", nil, "relation (prefix::value or relname:target)") } diff --git a/cmd/list.go b/cmd/list.go index 1b47b07..481d195 100644 --- a/cmd/list.go +++ b/cmd/list.go @@ -22,19 +22,22 @@ var listCmd = &cobra.Command{ return } - filter := service.ListFilter{ - Tags: append([]string{}, lTags...), + var filter service.ListFilter + + // --tag is an alias for a label filter with no target. + for _, tag := range lTags { + filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType(tag), Target: ""}) } - // Shorthand flags expand to tag prefixes or rel filters. + // Shorthand flags expand to property filters or edge filters. if lStatus != "" { - filter.Tags = append(filter.Tags, "_status::"+lStatus) + filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType("_status::" + lStatus), Target: ""}) } if lPrio != "" { - filter.Tags = append(filter.Tags, "_prio::"+lPrio) + filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType("_prio::" + lPrio), Target: ""}) } if lType != "" { - filter.Tags = append(filter.Tags, "_type::"+lType) + filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType("_type::" + lType), Target: ""}) } if lNamespace != "" { filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelInNamespace, Target: lNamespace}) @@ -66,8 +69,8 @@ var listCmd = &cobra.Command{ func init() { rootCmd.AddCommand(listCmd) f := listCmd.Flags() - f.StringArrayVar(&lTags, "tag", nil, "filter by tag") - f.StringArrayVar(&lRels, "rel", nil, "filter by relation (type:target)") + f.StringArrayVar(&lTags, "tag", nil, "filter by label tag") + f.StringArrayVar(&lRels, "rel", nil, "filter by relation (prefix::value or relname:target)") f.StringVar(&lStatus, "status", "", "filter by status") f.StringVar(&lPrio, "prio", "", "filter by priority") f.StringVar(&lType, "type", "", "filter by type") diff --git a/cmd/rel.go b/cmd/rel.go index f2b0a3f..3eb395b 100644 --- a/cmd/rel.go +++ b/cmd/rel.go @@ -3,14 +3,24 @@ package cmd import ( "axolotl/models" "axolotl/service" - "fmt" "strings" ) -// parseRelInput parses a "type:target" string into a RelInput. +// parseRelInput parses a rel string into a RelInput. +// +// Formats: +// - "prefix::value" → property rel with no target (tag) +// - "relname:target" → edge rel with a target node +// - "tagname" → simple label rel with no target (alias for --tag) func parseRelInput(s string) (service.RelInput, error) { - if p := strings.SplitN(s, ":", 2); len(p) == 2 { - return service.RelInput{Type: models.RelType(p[0]), Target: p[1]}, nil + if strings.Contains(s, "::") { + // Property: name::value — no target node. + return service.RelInput{Type: models.RelType(s), Target: ""}, nil } - return service.RelInput{}, fmt.Errorf("invalid relation format: %s (expected type:target)", s) + if idx := strings.Index(s, ":"); idx >= 0 { + // Edge rel: relname:target. + return service.RelInput{Type: models.RelType(s[:idx]), Target: s[idx+1:]}, nil + } + // Simple label tag — no target node. + return service.RelInput{Type: models.RelType(s), Target: ""}, nil } diff --git a/cmd/update.go b/cmd/update.go index 81ab40f..8c4141a 100644 --- a/cmd/update.go +++ b/cmd/update.go @@ -27,10 +27,7 @@ var updateCmd = &cobra.Command{ return } - input := service.UpdateInput{ - AddTags: append([]string{}, uAddTags...), - RemoveTags: uRmTags, - } + var input service.UpdateInput if cmd.Flags().Changed("title") { input.Title = &uTitle @@ -46,15 +43,23 @@ var updateCmd = &cobra.Command{ input.DueDate = &empty } - // Shorthand flags expand to tags or rels. + // --tag / --tag-remove are aliases for --rel / --rel-remove with no target. + for _, tag := range uAddTags { + input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType(tag), Target: ""}) + } + for _, tag := range uRmTags { + input.RemoveRels = append(input.RemoveRels, service.RelInput{Type: models.RelType(tag), Target: ""}) + } + + // Shorthand flags expand to property rels or edge rels. if cmd.Flags().Changed("type") { - input.AddTags = append(input.AddTags, "_type::"+uType) + input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType("_type::" + uType), Target: ""}) } if cmd.Flags().Changed("status") { - input.AddTags = append(input.AddTags, "_status::"+uStatus) + input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType("_status::" + uStatus), Target: ""}) } if cmd.Flags().Changed("prio") { - input.AddTags = append(input.AddTags, "_prio::"+uPrio) + input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType("_prio::" + uPrio), Target: ""}) } if cmd.Flags().Changed("namespace") { input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelInNamespace, Target: uNamespace}) @@ -101,8 +106,8 @@ func init() { f.StringVar(&uType, "type", "", "node type") f.StringVar(&uNamespace, "namespace", "", "namespace name or ID") f.StringVar(&uAssignee, "assignee", "", "assignee username or ID") - f.StringArrayVar(&uAddTags, "tag", nil, "add tags") - f.StringArrayVar(&uRmTags, "tag-remove", nil, "remove tags") - f.StringArrayVar(&uAddRels, "rel", nil, "add relations (type:target)") - f.StringArrayVar(&uRmRels, "rel-remove", nil, "remove relations (type:target)") + f.StringArrayVar(&uAddTags, "tag", nil, "add label tag (alias for --rel tagname)") + f.StringArrayVar(&uRmTags, "tag-remove", nil, "remove label tag") + f.StringArrayVar(&uAddRels, "rel", nil, "add relation (prefix::value or relname:target)") + f.StringArrayVar(&uRmRels, "rel-remove", nil, "remove relation (prefix::value or relname:target)") } diff --git a/models/node.go b/models/node.go index 2bb2631..0af9568 100644 --- a/models/node.go +++ b/models/node.go @@ -5,8 +5,6 @@ import ( "strings" ) -var PropertyPrefixes = []string{"_type::", "_status::", "_prio::"} - type Node struct { ID string `json:"id"` Title string `json:"title"` @@ -28,17 +26,16 @@ func (n *Node) AddTag(tag string) { if tag == "" { return } - for _, prefix := range PropertyPrefixes { - if strings.HasPrefix(tag, prefix) { - var newTags []string - for _, t := range n.Tags { - if !strings.HasPrefix(t, prefix) { - newTags = append(newTags, t) - } + // If it's a property (name::value format), replace any existing tag with the same prefix. + if idx := strings.Index(tag, "::"); idx >= 0 { + prefix := tag[:idx+2] + var newTags []string + for _, t := range n.Tags { + if !strings.HasPrefix(t, prefix) { + newTags = append(newTags, t) } - n.Tags = newTags - break } + n.Tags = newTags } if !slices.Contains(n.Tags, tag) { n.Tags = append(n.Tags, tag) @@ -86,11 +83,10 @@ func (n *Node) RemoveRelation(relType RelType, target string) { } func (n *Node) GetProperty(k string) string { + prefix := "_" + k + "::" for _, t := range n.Tags { - if strings.HasPrefix(t, "_") { - if p := strings.SplitN(t[1:], "::", 2); len(p) == 2 && p[0] == k { - return p[1] - } + if strings.HasPrefix(t, prefix) { + return strings.TrimPrefix(t, prefix) } } return "" diff --git a/service/node_service.go b/service/node_service.go index 0a86046..90b8b7d 100644 --- a/service/node_service.go +++ b/service/node_service.go @@ -31,44 +31,40 @@ type NodeService interface { } // AddInput describes a new node to create. -// Tags may include special property tags (_type::, _status::, _prio::); the -// service applies defaults (type=issue, status=open for issues) and validates. -// Rels may include assignee, in_namespace, blocks, subtask, related, etc.; -// user and namespace targets are auto-created as needed. +// Rels may contain tag rels (Target == ""), property rels (Target == "", +// Type is "prefix::value"), and edge rels (Target is a node name or ID). +// The service applies defaults (type=issue, status=open for issues) and validates. type AddInput struct { Title string Content string DueDate string - Tags []string Rels []RelInput } // UpdateInput describes changes to apply to an existing node. -// Nil pointer fields mean "no change". -// Setting _status::done in AddTags is rejected when the node has open blockers. +// AddRels and RemoveRels accept both tag rels (Target == "") and edge rels. +// Setting _status::done in AddRels is rejected when the node has open blockers. // Adding assignee or in_namespace rels replaces the previous single target. type UpdateInput struct { Title *string Content *string DueDate *string // nil = no change; pointer to "" = clear due date - AddTags []string - RemoveTags []string AddRels []RelInput RemoveRels []RelInput } // ListFilter specifies which nodes to return. Empty slices are ignored. -// Tags are matched as exact tag values or prefixes (e.g. "_status::open"). -// Rels are resolved to node IDs; a missing target returns no results. +// Tag filters (Target == "") match by rel_name prefix. +// Edge filters (Target != "") are resolved to node IDs. type ListFilter struct { - Tags []string Rels []RelInput } -// RelInput is a typed, directed edge with a target that may be a name or node ID. +// RelInput is a typed, directed rel with a target that may be a name or node ID. +// Target == "" means this is a tag or property rel (no target node). type RelInput struct { Type models.RelType - Target string // name or node ID; the service resolves names + Target string // name or node ID; the service resolves names. Empty = tag rel. } func InitNodeService(path string) error { diff --git a/service/node_service_impl.go b/service/node_service_impl.go index 9fd70ef..5be4152 100644 --- a/service/node_service_impl.go +++ b/service/node_service_impl.go @@ -52,7 +52,7 @@ func (ac *accessContext) canWrite(namespaceID string) bool { } // getAccessContext builds an accessContext by reading the current user's outgoing -// has_write_access and has_read_access edges. If the user node does not yet exist +// has_write_access and has_read_access rels. If the user node does not yet exist // (first-time bootstrap) both maps are empty. func (s *nodeServiceImpl) getAccessContext() (*accessContext, error) { ctx := &accessContext{ @@ -91,10 +91,13 @@ func (s *nodeServiceImpl) nodeNamespaceID(n *models.Node) string { } // checkRelTargetWrite verifies the current user has write access to the namespace -// of each relation target. Targets that do not yet exist are skipped (they will -// be created during the transaction and access granted there). +// of each edge rel target. Tag rels (empty Target) and targets that do not yet +// exist are skipped. func (s *nodeServiceImpl) checkRelTargetWrite(ac *accessContext, addRels []RelInput) error { for _, ri := range addRels { + if ri.Target == "" { + continue // tag rel — no target node to check + } targetID, found := s.lookupRelTarget(ri.Type, ri.Target) if !found || targetID == "" { continue @@ -118,35 +121,33 @@ var ( validPrios = map[string]bool{"high": true, "medium": true, "low": true} ) -func validateTags(tags []string) error { - for _, t := range tags { - if v, ok := strings.CutPrefix(t, "_type::"); ok { +// validateRels checks that any _ -prefixed rel names are known system properties +// and that their values are valid. Users may not define custom _ -prefixed rels. +func validateRels(rels []RelInput) error { + for _, r := range rels { + name := string(r.Type) + if !strings.HasPrefix(name, "_") { + continue + } + if v, ok := strings.CutPrefix(name, "_type::"); ok { if !validTypes[v] { return fmt.Errorf("invalid type %q: must be one of issue, note, user, namespace", v) } - } else if v, ok := strings.CutPrefix(t, "_status::"); ok { + } else if v, ok := strings.CutPrefix(name, "_status::"); ok { if !validStatuses[v] { return fmt.Errorf("invalid status %q: must be one of open, done", v) } - } else if v, ok := strings.CutPrefix(t, "_prio::"); ok { + } else if v, ok := strings.CutPrefix(name, "_prio::"); ok { if !validPrios[v] { return fmt.Errorf("invalid priority %q: must be one of high, medium, low", v) } + } else { + return fmt.Errorf("invalid relation %q: custom _ prefix not allowed", name) } } return nil } -// tagValue returns the value of the first tag with the given prefix, or "". -func tagValue(tags []string, prefix string) string { - for _, t := range tags { - if v, ok := strings.CutPrefix(t, prefix); ok { - return v - } - } - return "" -} - // --- Query --- func (s *nodeServiceImpl) GetByID(id string) (*models.Node, error) { @@ -165,15 +166,21 @@ func (s *nodeServiceImpl) GetByID(id string) (*models.Node, error) { } func (s *nodeServiceImpl) List(filter ListFilter) ([]*models.Node, error) { - var relFilters []*models.Rel + var storeFilters []*models.Rel for _, ri := range filter.Rels { - id, ok := s.lookupRelTarget(ri.Type, ri.Target) - if !ok { - return nil, nil // named target doesn't exist; no nodes can match + if ri.Target == "" { + // Tag filter: pass through with empty target. + storeFilters = append(storeFilters, &models.Rel{Type: ri.Type, Target: ""}) + } else { + // Edge filter: resolve target name to node ID. + id, ok := s.lookupRelTarget(ri.Type, ri.Target) + if !ok { + return nil, nil // named target doesn't exist; no nodes can match + } + storeFilters = append(storeFilters, &models.Rel{Type: ri.Type, Target: id}) } - relFilters = append(relFilters, &models.Rel{Type: ri.Type, Target: id}) } - nodes, err := s.store.FindNodes(filter.Tags, relFilters) + nodes, err := s.store.FindNodes(storeFilters) if err != nil { return nil, err } @@ -193,22 +200,28 @@ func (s *nodeServiceImpl) List(filter ListFilter) ([]*models.Node, error) { // --- Lifecycle --- func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) { - // Copy tags so we can extend without mutating the input. - tags := make([]string, len(input.Tags)) - copy(tags, input.Tags) + // Build tag set from tag rels (Target == ""), applying property-replacement semantics. + tmp := models.NewNode() + for _, r := range input.Rels { + if r.Target == "" { + tmp.AddTag(string(r.Type)) + } + } // Apply defaults. - nodeType := tagValue(tags, "_type::") - if nodeType == "" { - nodeType = "issue" - tags = append(tags, "_type::issue") + if tmp.GetProperty("type") == "" { + tmp.AddTag("_type::issue") } - if nodeType == "issue" && tagValue(tags, "_status::") == "" { - tags = append(tags, "_status::open") + if tmp.GetProperty("type") == "issue" && tmp.GetProperty("status") == "" { + tmp.AddTag("_status::open") } - // Validate special tags. - if err := validateTags(tags); err != nil { + // Validate all rels (including the resolved default tags). + tagRels := make([]RelInput, len(tmp.Tags)) + for i, t := range tmp.Tags { + tagRels[i] = RelInput{Type: models.RelType(t)} + } + if err := validateRels(append(tagRels, input.Rels...)); err != nil { return nil, err } @@ -217,43 +230,33 @@ func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) { if err != nil { return nil, err } - // Determine the target namespace name (explicit or default). targetNSName := s.userID for _, ri := range input.Rels { - if ri.Type == models.RelInNamespace { + if ri.Type == models.RelInNamespace && ri.Target != "" { targetNSName = ri.Target break } } - // Check write access only when the namespace already exists; if it doesn't - // exist yet it will be created in the transaction and access granted there. if nsID, found := s.lookupRelTarget(models.RelInNamespace, targetNSName); found { if !ac.canWrite(nsID) { return nil, fmt.Errorf("permission denied: no write access to namespace %q", targetNSName) } } - // Check write access for all other relation targets. - var nonNSRels []RelInput + var nonNSEdgeRels []RelInput for _, ri := range input.Rels { - if ri.Type != models.RelInNamespace { - nonNSRels = append(nonNSRels, ri) + if ri.Target != "" && ri.Type != models.RelInNamespace { + nonNSEdgeRels = append(nonNSEdgeRels, ri) } } - if err := s.checkRelTargetWrite(ac, nonNSRels); err != nil { + if err := s.checkRelTargetWrite(ac, nonNSEdgeRels); err != nil { return nil, err } - // Build initial relation map from rels input. - rels := make(map[models.RelType][]string) hasNamespace := false for _, ri := range input.Rels { - if ri.Type == models.RelInNamespace { + if ri.Type == models.RelInNamespace && ri.Target != "" { hasNamespace = true } - rels[ri.Type] = append(rels[ri.Type], ri.Target) - } - if !hasNamespace { - rels[models.RelInNamespace] = []string{s.userID} } id, err := s.store.GenerateID() @@ -267,44 +270,60 @@ func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) { return err } + // Store tag rels. + for _, t := range tmp.Tags { + if err := st.AddRel(id, t, ""); err != nil { + return err + } + } + + // Mentions. for _, m := range mentions(input.Title + " " + input.Content) { userID, err := s.resolveUserRef(st, m) if err != nil { return err } - if err := st.AddEdge(id, userID, models.RelMentions); err != nil { - return err - } - } - - for _, t := range tags { - if err := st.AddTag(id, t); err != nil { + if err := st.AddRel(id, string(models.RelMentions), userID); err != nil { return err } } + // Edge rels. hasCreated := false - for rt, tgts := range rels { - for _, tgt := range tgts { - if rt == models.RelCreated { - hasCreated = true - } - resolved, err := s.resolveRelTarget(st, RelInput{Type: rt, Target: tgt}) - if err != nil { - return err - } - if err := st.AddEdge(id, resolved, rt); err != nil { - return err - } + for _, ri := range input.Rels { + if ri.Target == "" { + continue // already stored as tag + } + if ri.Type == models.RelCreated { + hasCreated = true + } + resolved, err := s.resolveRelTarget(st, ri) + if err != nil { + return err + } + if err := st.AddRel(id, string(ri.Type), resolved); err != nil { + return err } } + // Default namespace. + if !hasNamespace { + nsID, err := s.resolveNamespaceRef(st, s.userID) + if err != nil { + return err + } + if err := st.AddRel(id, string(models.RelInNamespace), nsID); err != nil { + return err + } + } + + // Default created. if !hasCreated { userID, err := s.resolveUserRef(st, s.userID) if err != nil { return err } - if err := st.AddEdge(id, userID, models.RelCreated); err != nil { + if err := st.AddRel(id, string(models.RelCreated), userID); err != nil { return err } } @@ -318,8 +337,8 @@ func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) { } func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, error) { - // Validate tags before doing any I/O. - if err := validateTags(input.AddTags); err != nil { + // Validate rels before doing any I/O. + if err := validateRels(input.AddRels); err != nil { return nil, err } @@ -340,8 +359,8 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er } // Enforce blocking constraint before allowing status=done. - for _, t := range input.AddTags { - if t == "_status::done" { + for _, r := range input.AddRels { + if r.Target == "" && string(r.Type) == "_status::done" { if err := s.checkBlockers(id); err != nil { return nil, err } @@ -355,7 +374,6 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er return err } - // Determine final scalar values. title, content, dueDate := current.Title, current.Content, current.DueDate if input.Title != nil { title = *input.Title @@ -378,24 +396,28 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er for _, t := range current.Tags { tmp.AddTag(t) } - for _, t := range input.AddTags { - tmp.AddTag(t) + for _, r := range input.AddRels { + if r.Target == "" { + tmp.AddTag(string(r.Type)) + } } - for _, t := range input.RemoveTags { - tmp.RemoveTag(t) + for _, r := range input.RemoveRels { + if r.Target == "" { + tmp.RemoveTag(string(r.Type)) + } } currentTags, newTags := current.Tags, tmp.Tags for _, t := range currentTags { if !slices.Contains(newTags, t) { - if err := st.RemoveTag(id, t); err != nil { + if err := st.RemoveRel(id, t, ""); err != nil { return err } } } for _, t := range newTags { if !slices.Contains(currentTags, t) { - if err := st.AddTag(id, t); err != nil { + if err := st.AddRel(id, t, ""); err != nil { return err } } @@ -410,6 +432,9 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er currentRels := current.Relations for _, ri := range input.AddRels { + if ri.Target == "" { + continue // already handled as tag + } resolved, err := s.resolveRelTarget(st, ri) if err != nil { return err @@ -417,22 +442,25 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er // Single-value relations replace the previous target. if ri.Type == models.RelAssignee || ri.Type == models.RelInNamespace { for _, oldTgt := range currentRels[string(ri.Type)] { - if err := st.RemoveEdge(id, oldTgt, ri.Type); err != nil { + if err := st.RemoveRel(id, string(ri.Type), oldTgt); err != nil { return err } } } - if err := st.AddEdge(id, resolved, ri.Type); err != nil { + if err := st.AddRel(id, string(ri.Type), resolved); err != nil { return err } } for _, ri := range input.RemoveRels { + if ri.Target == "" { + continue // already handled as tag + } resolved, err := s.resolveRelTarget(st, ri) if err != nil { return err } - if err := st.RemoveEdge(id, resolved, ri.Type); err != nil { + if err := st.RemoveRel(id, string(ri.Type), resolved); err != nil { return err } } @@ -476,14 +504,13 @@ func (s *nodeServiceImpl) AddUser(name string) (*models.Node, error) { } func (s *nodeServiceImpl) ListUsers() ([]*models.Node, error) { - return s.store.FindNodes([]string{"_type::user"}, nil) + return s.store.FindNodes([]*models.Rel{{Type: "_type::user", Target: ""}}) } // --- Internal helpers --- func (s *nodeServiceImpl) checkBlockers(id string) error { - // Find all nodes that declare a blocks → id relation (i.e., open blockers). - blockers, err := s.store.FindNodes(nil, []*models.Rel{{Type: models.RelBlocks, Target: id}}) + blockers, err := s.store.FindNodes([]*models.Rel{{Type: models.RelBlocks, Target: id}}) if err != nil { return err } @@ -512,14 +539,14 @@ func (s *nodeServiceImpl) syncMentions(st store.Store, id string, current *model } mentionedUserIDs[userID] = true if !existingMentionIDs[userID] { - if err := st.AddEdge(id, userID, models.RelMentions); err != nil { + if err := st.AddRel(id, string(models.RelMentions), userID); err != nil { return err } } } for uid := range existingMentionIDs { if !mentionedUserIDs[uid] { - if err := st.RemoveEdge(id, uid, models.RelMentions); err != nil { + if err := st.RemoveRel(id, string(models.RelMentions), uid); err != nil { return err } } @@ -536,7 +563,7 @@ func (s *nodeServiceImpl) resolveRelTarget(st store.Store, ri RelInput) (string, case models.RelInNamespace, models.RelHasReadAccess, models.RelHasWriteAccess: return s.resolveNamespaceRef(st, ri.Target) default: - return ri.Target, nil // blocks/subtask/related expect raw node IDs + return ri.Target, nil // blocks/subtask/related/custom expect raw node IDs } } @@ -562,9 +589,9 @@ func (s *nodeServiceImpl) lookupRelTarget(relType models.RelType, target string) return id, true } -// resolveIDByNameAndType finds a node by title and _type tag without creating it. +// resolveIDByNameAndType finds a node by title and _type property without creating it. func (s *nodeServiceImpl) resolveIDByNameAndType(st store.Store, title, nodeType string) (string, error) { - nodes, err := st.FindNodes([]string{"_type::" + nodeType}, nil) + nodes, err := st.FindNodes([]*models.Rel{{Type: models.RelType("_type::" + nodeType), Target: ""}}) if err != nil { return "", err } @@ -599,7 +626,7 @@ func (s *nodeServiceImpl) ensureUser(st store.Store, username string) (string, e if err := st.AddNode(id, username, "", "", now, now); err != nil { return "", err } - if err := st.AddTag(id, "_type::user"); err != nil { + if err := st.AddRel(id, "_type::user", ""); err != nil { return "", err } return id, nil @@ -628,21 +655,21 @@ func (s *nodeServiceImpl) ensureNamespace(st store.Store, name string) (string, if err := st.AddNode(id, name, "", "", now, now); err != nil { return "", err } - if err := st.AddTag(id, "_type::namespace"); err != nil { + if err := st.AddRel(id, "_type::namespace", ""); err != nil { return "", err } - if err := st.AddEdge(id, id, models.RelInNamespace); err != nil { + if err := st.AddRel(id, string(models.RelInNamespace), id); err != nil { return "", err } userID, err := s.resolveUserRef(st, s.userID) if err != nil { return "", err } - if err := st.AddEdge(id, userID, models.RelCreated); err != nil { + if err := st.AddRel(id, string(models.RelCreated), userID); err != nil { return "", err } // Grant the creator write access to the new namespace. - if err := st.AddEdge(userID, id, models.RelHasWriteAccess); err != nil { + if err := st.AddRel(userID, string(models.RelHasWriteAccess), id); err != nil { return "", err } return id, nil diff --git a/store/sqlite.go b/store/sqlite.go index fdbe660..90eef70 100644 --- a/store/sqlite.go +++ b/store/sqlite.go @@ -15,9 +15,7 @@ import ( var migrations = []string{ `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 INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)`, + `CREATE TABLE IF NOT EXISTS rels (from_id TEXT NOT NULL, rel_name TEXT NOT NULL, to_id TEXT NOT NULL DEFAULT '', PRIMARY KEY (from_id, rel_name, to_id), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE)`, `CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`, `CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`, } @@ -81,22 +79,58 @@ func FindAndOpenSQLiteStore() (Store, error) { } } -// NewSQLiteStore opens a SQLite database at the given path and applies -// per-connection PRAGMAs. foreign_keys must be set on every connection. +// NewSQLiteStore opens a SQLite database at the given path, runs a one-time +// schema migration if needed, then applies per-connection PRAGMAs. func NewSQLiteStore(path string) (Store, error) { db, err := sql.Open("sqlite", path) if err != nil { return nil, fmt.Errorf("failed to open database: %w", err) } - for _, q := range []string{"PRAGMA journal_mode=WAL", "PRAGMA busy_timeout=5000", "PRAGMA foreign_keys=ON"} { + // FK must be OFF during migration (table drops/renames). + for _, q := range []string{"PRAGMA journal_mode=WAL", "PRAGMA busy_timeout=5000", "PRAGMA foreign_keys=OFF"} { if _, err := db.Exec(q); err != nil { db.Close() return nil, err } } + if err := migrateSchema(db); err != nil { + db.Close() + return nil, fmt.Errorf("schema migration failed: %w", err) + } + if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil { + db.Close() + return nil, err + } return &SQLiteStore{db: db}, nil } +// migrateSchema migrates from the legacy two-table (tags + rels) schema to the +// unified rels-only schema. It is a no-op when migration has already been applied. +func migrateSchema(db *sql.DB) error { + var tagsExists int + if err := db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='tags'").Scan(&tagsExists); err != nil { + return err + } + if tagsExists == 0 { + return nil // already on new schema + } + for _, stmt := range []string{ + `CREATE TABLE rels_new (from_id TEXT NOT NULL, rel_name TEXT NOT NULL, to_id TEXT NOT NULL DEFAULT '', PRIMARY KEY (from_id, rel_name, to_id), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE)`, + `INSERT OR IGNORE INTO rels_new (from_id, rel_name, to_id) SELECT from_id, rel_type, to_id FROM rels`, + `INSERT OR IGNORE INTO rels_new (from_id, rel_name, to_id) SELECT node_id, tag, '' FROM tags`, + `DROP TABLE rels`, + `DROP TABLE tags`, + `ALTER TABLE rels_new RENAME TO rels`, + `CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`, + `CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`, + } { + if _, err := db.Exec(stmt); err != nil { + return err + } + } + return nil +} + // --- Transaction --- func (s *SQLiteStore) Transaction(fn func(Store) error) error { @@ -137,25 +171,19 @@ func getNode(q querier, id string) (*models.Node, error) { if err != nil { return nil, err } - rows, err := q.Query("SELECT tag FROM tags WHERE node_id = ?", id) + rows, err := q.Query("SELECT rel_name, to_id FROM rels WHERE from_id = ?", id) if err != nil { return nil, err } defer rows.Close() for rows.Next() { - var tag string - rows.Scan(&tag) - n.AddTag(tag) - } - rows2, err := q.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id) - if err != nil { - return nil, err - } - defer rows2.Close() - for rows2.Next() { - var toID, relType string - rows2.Scan(&toID, &relType) - n.AddRelation(models.RelType(relType), toID) + var relName, toID string + rows.Scan(&relName, &toID) + if toID == "" { + n.AddTag(relName) + } else { + n.AddRelation(models.RelType(relName), toID) + } } return n, nil } @@ -190,8 +218,8 @@ func (s *SQLiteStore) GetNode(id string) (*models.Node, error) { return getNode( func (s *SQLiteStore) UpdateNode(id, title, content, dueDate, updatedAt string) error { return updateNode(s.db, id, title, content, dueDate, updatedAt) } -func (s *SQLiteStore) DeleteNode(id string) error { return deleteNode(s.db, id) } -func (s *SQLiteStore) NodeExists(id string) (bool, error) { return nodeExists(s.db, id) } +func (s *SQLiteStore) DeleteNode(id string) error { return deleteNode(s.db, id) } +func (s *SQLiteStore) NodeExists(id string) (bool, error) { return nodeExists(s.db, id) } func (s *txStore) AddNode(id, title, content, dueDate, createdAt, updatedAt string) error { return addNode(s.tx, id, title, content, dueDate, createdAt, updatedAt) @@ -229,81 +257,60 @@ func generateID(q querier) (string, error) { func (s *SQLiteStore) GenerateID() (string, error) { return generateID(s.db) } func (s *txStore) GenerateID() (string, error) { return generateID(s.db) } -// --- Tag operations --- +// --- Rel operations --- -func addTag(q querier, nodeID, tag string) error { - _, err := q.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", nodeID, tag) +func addRel(q querier, nodeID, relName, toID string) error { + _, err := q.Exec("INSERT OR IGNORE INTO rels (from_id, rel_name, to_id) VALUES (?, ?, ?)", nodeID, relName, toID) return err } -func removeTag(q querier, nodeID, tag string) error { - _, err := q.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", nodeID, tag) +func removeRel(q querier, nodeID, relName, toID string) error { + _, err := q.Exec("DELETE FROM rels WHERE from_id = ? AND rel_name = ? AND to_id = ?", nodeID, relName, toID) return err } -func (s *SQLiteStore) AddTag(nodeID, tag string) error { return addTag(s.db, nodeID, tag) } -func (s *SQLiteStore) RemoveTag(nodeID, tag string) error { return removeTag(s.db, nodeID, tag) } -func (s *txStore) AddTag(nodeID, tag string) error { return addTag(s.tx, nodeID, tag) } -func (s *txStore) RemoveTag(nodeID, tag string) error { return removeTag(s.tx, nodeID, tag) } - -// --- Edge operations --- - -func addEdge(q querier, fromID, toID string, relType models.RelType) error { - _, err := q.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", fromID, toID, relType) - return err +func (s *SQLiteStore) AddRel(nodeID, relName, toID string) error { + return addRel(s.db, nodeID, relName, toID) } - -func removeEdge(q querier, fromID, toID string, relType models.RelType) error { - _, err := q.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", fromID, toID, relType) - return err +func (s *SQLiteStore) RemoveRel(nodeID, relName, toID string) error { + return removeRel(s.db, nodeID, relName, toID) } - -func (s *SQLiteStore) AddEdge(fromID, toID string, relType models.RelType) error { - return addEdge(s.db, fromID, toID, relType) +func (s *txStore) AddRel(nodeID, relName, toID string) error { + return addRel(s.tx, nodeID, relName, toID) } -func (s *SQLiteStore) RemoveEdge(fromID, toID string, relType models.RelType) error { - return removeEdge(s.db, fromID, toID, relType) -} -func (s *txStore) AddEdge(fromID, toID string, relType models.RelType) error { - return addEdge(s.tx, fromID, toID, relType) -} -func (s *txStore) RemoveEdge(fromID, toID string, relType models.RelType) error { - return removeEdge(s.tx, fromID, toID, relType) +func (s *txStore) RemoveRel(nodeID, relName, toID string) error { + return removeRel(s.tx, nodeID, relName, toID) } // --- FindNodes --- -func findNodes(q querier, tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) { - // Edge filter args come first (in JOIN ON clauses), tag args come last (in HAVING). +func findNodes(q querier, filters []*models.Rel) ([]*models.Node, error) { query := "SELECT DISTINCT n.id FROM nodes n" var joins []string var args []any - // Edge filtering: each filter becomes an inner join with conditions in the ON clause. - for i, ef := range edgeFilters { + for i, f := range filters { alias := fmt.Sprintf("r%d", i) - joins = append(joins, fmt.Sprintf( - "JOIN rels %s ON n.id = %s.from_id AND %s.rel_type = ? AND %s.to_id = ?", - alias, alias, alias, alias, - )) - args = append(args, string(ef.Type), ef.Target) + if f.Target == "" { + // Tag/property filter: match rels with empty to_id by rel_name prefix. + joins = append(joins, fmt.Sprintf( + "JOIN rels %s ON n.id = %s.from_id AND %s.to_id = '' AND %s.rel_name LIKE ? || '%%'", + alias, alias, alias, alias, + )) + args = append(args, string(f.Type)) + } else { + // Edge filter: match rel by exact rel_name and to_id. + joins = append(joins, fmt.Sprintf( + "JOIN rels %s ON n.id = %s.from_id AND %s.rel_name = ? AND %s.to_id = ?", + alias, alias, alias, alias, + )) + args = append(args, string(f.Type), f.Target) + } } - // Tag filtering: join tags and use HAVING with aggregate to require all prefixes. - joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id") - if len(tagPrefixes) == 0 { - tagPrefixes = []string{""} + if len(joins) > 0 { + query += " " + strings.Join(joins, " ") } - cond := "" - for _, t := range tagPrefixes { - cond += "t_tag.tag LIKE ? || '%' OR " - args = append(args, t) - } - having := "SUM(CASE WHEN " + cond[:len(cond)-4] + " THEN 1 ELSE 0 END) >= ?" - args = append(args, len(tagPrefixes)) - - query += " " + strings.Join(joins, " ") - query += " GROUP BY n.id HAVING " + having query += " ORDER BY n.created_at DESC" rows, err := q.Query(query, args...) @@ -332,10 +339,10 @@ func findNodes(q querier, tagPrefixes []string, edgeFilters []*models.Rel) ([]*m return nodes, nil } -func (s *SQLiteStore) FindNodes(tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) { - return findNodes(s.db, tagPrefixes, edgeFilters) +func (s *SQLiteStore) FindNodes(filters []*models.Rel) ([]*models.Node, error) { + return findNodes(s.db, filters) } -func (s *txStore) FindNodes(tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) { - return findNodes(s.tx, tagPrefixes, edgeFilters) +func (s *txStore) FindNodes(filters []*models.Rel) ([]*models.Node, error) { + return findNodes(s.tx, filters) } diff --git a/store/store.go b/store/store.go index da88705..73ff1ee 100644 --- a/store/store.go +++ b/store/store.go @@ -3,26 +3,25 @@ package store import "axolotl/models" // Store is a primitive graph persistence interface. It provides basic -// operations for nodes, tags, and directed edges. No business logic lives here. +// operations for nodes and directed rels. No business logic lives here. +// "Tag" rels are rels with an empty toID (e.g. "_type::issue" or "backend"). type Store interface { // Nodes AddNode(id, title, content, dueDate, createdAt, updatedAt string) error - GetNode(id string) (*models.Node, error) // returns node with tags and edges populated + GetNode(id string) (*models.Node, error) // returns node with tags and rels populated UpdateNode(id, title, content, dueDate, updatedAt string) error // empty dueDate stores NULL DeleteNode(id string) error NodeExists(id string) (bool, error) GenerateID() (string, error) // returns a random 5-char ID guaranteed unique in the store - // Tags - AddTag(nodeID, tag string) error - RemoveTag(nodeID, tag string) error + // Rels: relName is the relation name; toID is empty for "tag" rels (properties/labels). + AddRel(nodeID, relName, toID string) error + RemoveRel(nodeID, relName, toID string) error - // Edges (directed, typed) - AddEdge(fromID, toID string, relType models.RelType) error - RemoveEdge(fromID, toID string, relType models.RelType) error - - // Query returns fully-populated nodes matching all given tag prefixes and edge filters. - FindNodes(tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) + // FindNodes returns fully-populated nodes matching all given filters. + // Filters with empty Target match nodes by rel_name prefix with empty toID (tag/property). + // Filters with non-empty Target match nodes by exact rel_name and toID (edge). + FindNodes(filters []*models.Rel) ([]*models.Node, error) // Transaction runs fn inside an atomic transaction. If fn returns an error // the transaction is rolled back; otherwise it is committed.