refactor: unify tags and edges into single rels table

2026-04-01 12:50:45 +02:00
parent 27c72db042
commit 6288879468
9 changed files with 296 additions and 249 deletions
--- 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 {
--- 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