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

refactor: unify tags and edges into single rels table

Browse Source
This commit is contained in:
Elias Kohout
2026-04-01 12:50:45 +02:00
parent 27c72db042
commit 6288879468
9 changed files with 296 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
cmd/add.go
View File

@@ -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)")
}

19
cmd/list.go
View File

@@ -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")

20
cmd/rel.go
View File

@@ -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
}

29
cmd/update.go
View File

@@ -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)")
}

26
models/node.go
View File

@@ -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 ""

24
service/node_service.go
View File

@@ -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 {

223
service/node_service_impl.go
View File

@@ -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

165
store/sqlite.go
View File

@@ -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)
}

21
store/store.go
View File

@@ -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.