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

refactor: clean up NodeService interface; move all integrity logic behind it

Browse Source
This commit is contained in:
Elias Kohout
2026-03-31 15:55:47 +02:00
parent ed9117951f
commit 8d831d131b
9 changed files with 484 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
service/config_file.go
View File

@@ -16,8 +16,8 @@ type fileConfig struct {
}
var defaultAliases = []*Alias{
{Name: "mine", Command: "list --assignee $me --tag _type::issue --tag _status::open", Description: "Show open issues assigned to you"},
{Name: "due", Command: "list --tag _type::issue --tag _status::open", Description: "Show open issues"},
{Name: "mine", Command: "list --assignee $me --type issue --status open", Description: "Show open issues assigned to you"},
{Name: "due", Command: "list --type issue --status open", Description: "Show open issues"},
{Name: "inbox", Command: "list --mention $me", Description: "Show your inbox"},
}

95
service/node_service.go
View File

@@ -5,14 +5,82 @@ import (
"axolotl/store"
)
// NodeService is the single entry point for all node operations.
// All data-model integrity rules are enforced here; callers cannot produce
// invalid state by interacting with this interface alone.
type NodeService interface {
Create(title, content, dueDate string, tags []string, rels map[models.RelType][]string) (*models.Node, error)
Update(node *models.Node) error
Delete(id string) error
// Query
GetByID(id string) (*models.Node, error)
List(opts ...ListOption) ([]*models.Node, error)
Exists(id string) (bool, error)
CanClose(id string) (bool, []string, error)
List(filter ListFilter) ([]*models.Node, error)
// Lifecycle
Add(input AddInput) (*models.Node, error)
Update(id string, input UpdateInput) (*models.Node, error)
Delete(id string) error
// User management
AddUser(name string) (*models.Node, error)
ListUsers() ([]*models.Node, error)
}
// AddInput describes a new node to create.
type AddInput struct {
Title string
Content string
DueDate string
Type string // default: "issue"
Status string // default: "open" when Type is "issue"
Priority string
// Namespace is a namespace name or node ID. Defaults to the current user.
Namespace string
// Assignee is a username or node ID.
Assignee string
// Tags are arbitrary user-defined labels (not system properties).
Tags []string
// Rels are additional typed edges (e.g. blocks, subtask, related).
Rels []RelInput
}
// UpdateInput describes changes to apply to an existing node.
// Nil pointer fields mean "no change".
type UpdateInput struct {
Title *string
Content *string
DueDate *string // nil = no change; pointer to "" = clear due date
// Status "done" is rejected when the node has open blockers.
Status *string
Priority *string
Type *string
// Namespace replaces the current namespace.
Namespace *string
// Assignee replaces the current assignee.
Assignee *string
AddTags []string
RemoveTags []string
AddRels []RelInput
RemoveRels []RelInput
}
// ListFilter specifies which nodes to return. Empty fields are ignored.
type ListFilter struct {
Tags []string
Status string
Priority string
Type string
// Namespace filters by namespace name or node ID.
Namespace string
// Assignee filters by username or node ID.
Assignee string
// Mention filters to nodes that mention the given username or node ID.
Mention string
// Rels are additional relation filters (e.g. blocks:someID).
Rels []RelInput
}
// RelInput is a typed, directed edge with a target that may be a name or node ID.
type RelInput struct {
Type models.RelType
Target string // name or node ID; the service resolves names
}
func InitNodeService(path string) error {
@@ -26,18 +94,3 @@ func GetNodeService(cfg Config) (NodeService, error) {
}
return &nodeServiceImpl{store: st, userID: cfg.GetUser()}, nil
}
type listFilter struct {
tagPrefixes []string
relPrefixes []*models.Rel
}
type ListOption func(*listFilter)
func WithTags(prefixes ...string) ListOption {
return func(f *listFilter) { f.tagPrefixes = append(f.tagPrefixes, prefixes...) }
}
func WithRels(prefixes ...*models.Rel) ListOption {
return func(f *listFilter) { f.relPrefixes = append(f.relPrefixes, prefixes...) }
}

450
service/node_service_impl.go
View File

@@ -3,6 +3,7 @@ package service
import (
"axolotl/models"
"axolotl/store"
"fmt"
"maps"
"regexp"
"slices"
@@ -24,79 +25,94 @@ func mentions(t string) []string {
return slices.Collect(maps.Keys(seen))
}
// --- Query ---
func (s *nodeServiceImpl) GetByID(id string) (*models.Node, error) {
return s.store.GetNode(id)
}
func (s *nodeServiceImpl) Exists(id string) (bool, error) {
return s.store.NodeExists(id)
}
func (s *nodeServiceImpl) Delete(id string) error {
return s.store.DeleteNode(id)
}
func (s *nodeServiceImpl) CanClose(id string) (bool, []string, error) {
node, err := s.store.GetNode(id)
if err != nil {
return false, nil, err
func (s *nodeServiceImpl) List(filter ListFilter) ([]*models.Node, error) {
// Build tag prefixes from both semantic fields and raw tags.
tagPrefixes := append([]string{}, filter.Tags...)
if filter.Status != "" {
tagPrefixes = append(tagPrefixes, "_status::"+filter.Status)
}
blockerIDs := node.Relations()[string(models.RelBlocks)]
var blocking []string
for _, bID := range blockerIDs {
blocker, err := s.store.GetNode(bID)
if err != nil {
return false, nil, err
if filter.Priority != "" {
tagPrefixes = append(tagPrefixes, "_prio::"+filter.Priority)
}
if filter.Type != "" {
tagPrefixes = append(tagPrefixes, "_type::"+filter.Type)
}
// Build rel filters, resolving names to node IDs (read-only, no auto-creation).
type relEntry struct {
relType models.RelType
name string
}
namedRels := []relEntry{
{models.RelAssignee, filter.Assignee},
{models.RelInNamespace, filter.Namespace},
{models.RelMentions, filter.Mention},
}
var relFilters []*models.Rel
for _, e := range namedRels {
if e.name == "" {
continue
}
if blocker.GetProperty("status") == "open" {
blocking = append(blocking, bID)
}
}
return len(blocking) == 0, blocking, nil
}
func (s *nodeServiceImpl) List(opts ...ListOption) ([]*models.Node, error) {
f := &listFilter{}
for _, opt := range opts {
opt(f)
}
// Resolve rel filter targets from names to node IDs (read-only, no auto-creation).
resolvedRels := make([]*models.Rel, 0, len(f.relPrefixes))
for _, rel := range f.relPrefixes {
resolvedID, ok := s.lookupRelTarget(rel.Type, rel.Target)
id, ok := s.lookupRelTarget(e.relType, e.name)
if !ok {
return nil, nil // target doesn't exist; no nodes can match
return nil, nil // named target doesn't exist; no nodes can match
}
resolvedRels = append(resolvedRels, &models.Rel{Type: rel.Type, Target: resolvedID})
relFilters = append(relFilters, &models.Rel{Type: e.relType, Target: id})
}
for _, ri := range filter.Rels {
id, ok := s.lookupRelTarget(ri.Type, ri.Target)
if !ok {
return nil, nil
}
relFilters = append(relFilters, &models.Rel{Type: ri.Type, Target: id})
}
return s.store.FindNodes(f.tagPrefixes, resolvedRels)
return s.store.FindNodes(tagPrefixes, relFilters)
}
// lookupRelTarget resolves a rel filter target (name or ID) to a node ID without
// creating anything. Returns (id, false) when the target doesn't exist in the store.
func (s *nodeServiceImpl) lookupRelTarget(relType models.RelType, target string) (string, bool) {
if exists, _ := s.store.NodeExists(target); exists {
return target, true
}
var nodeType string
switch relType {
case models.RelAssignee, models.RelCreated, models.RelMentions:
nodeType = "user"
case models.RelInNamespace:
nodeType = "namespace"
default:
return target, true // other rel types expect a raw node ID
}
id, err := s.resolveIDByNameAndType(s.store, target, nodeType)
if err != nil || id == "" {
return "", false
}
return id, true
}
// --- Lifecycle ---
func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) {
// Apply defaults.
nodeType := input.Type
if nodeType == "" {
nodeType = "issue"
}
status := input.Status
if status == "" && nodeType == "issue" {
status = "open"
}
// Build initial tag set from semantic fields.
tags := []string{"_type::" + nodeType}
if status != "" {
tags = append(tags, "_status::"+status)
}
if input.Priority != "" {
tags = append(tags, "_prio::"+input.Priority)
}
tags = append(tags, input.Tags...)
// Build initial relation map from semantic fields.
rels := make(map[models.RelType][]string)
if input.Namespace != "" {
rels[models.RelInNamespace] = []string{input.Namespace}
} else {
rels[models.RelInNamespace] = []string{s.userID} // default: creator's namespace
}
if input.Assignee != "" {
rels[models.RelAssignee] = []string{input.Assignee}
}
for _, ri := range input.Rels {
rels[ri.Type] = append(rels[ri.Type], ri.Target)
}
func (s *nodeServiceImpl) Create(title, content, dueDate string, tags []string, rels map[models.RelType][]string) (*models.Node, error) {
id, err := s.store.GenerateID()
if err != nil {
return nil, err
@@ -104,11 +120,11 @@ func (s *nodeServiceImpl) Create(title, content, dueDate string, tags []string,
err = s.store.Transaction(func(st store.Store) error {
now := time.Now().UTC().Format(time.RFC3339)
if err := st.AddNode(id, title, content, dueDate, now, now); err != nil {
if err := st.AddNode(id, input.Title, input.Content, input.DueDate, now, now); err != nil {
return err
}
for _, m := range mentions(title + " " + content) {
for _, m := range mentions(input.Title + " " + input.Content) {
userID, err := s.resolveUserRef(st, m)
if err != nil {
return err
@@ -130,19 +146,11 @@ func (s *nodeServiceImpl) Create(title, content, dueDate string, tags []string,
if rt == models.RelCreated {
hasCreated = true
}
if rt == models.RelAssignee || rt == models.RelCreated {
var err error
if tgt, err = s.resolveUserRef(st, tgt); err != nil {
return err
}
resolved, err := s.resolveRelTarget(st, RelInput{Type: rt, Target: tgt})
if err != nil {
return err
}
if rt == models.RelInNamespace {
var err error
if tgt, err = s.resolveNamespaceRef(st, tgt); err != nil {
return err
}
}
if err := st.AddEdge(id, tgt, rt); err != nil {
if err := st.AddEdge(id, resolved, rt); err != nil {
return err
}
}
@@ -166,117 +174,240 @@ func (s *nodeServiceImpl) Create(title, content, dueDate string, tags []string,
return s.store.GetNode(id)
}
func (s *nodeServiceImpl) Update(node *models.Node) error {
current, err := s.store.GetNode(node.ID)
if err != nil {
return err
func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, error) {
// Enforce blocking constraint before allowing status=done.
if input.Status != nil && *input.Status == "done" {
if err := s.checkBlockers(id); err != nil {
return nil, err
}
}
return s.store.Transaction(func(st store.Store) error {
// Update scalar fields if changed.
if node.Title != current.Title || node.Content != current.Content || node.DueDate != current.DueDate {
updatedAt := time.Now().UTC().Format(time.RFC3339)
if err := st.UpdateNode(node.ID, node.Title, node.Content, node.DueDate, updatedAt); err != nil {
return err
err := s.store.Transaction(func(st store.Store) error {
current, err := st.GetNode(id)
if err != nil {
return err
}
// Determine final scalar values.
title, content, dueDate := current.Title, current.Content, current.DueDate
if input.Title != nil {
title = *input.Title
}
if input.Content != nil {
content = *input.Content
}
if input.DueDate != nil {
dueDate = *input.DueDate
}
now := time.Now().UTC().Format(time.RFC3339)
if err := st.UpdateNode(id, title, content, dueDate, now); err != nil {
return err
}
// Compute new tag set using the model's AddTag/RemoveTag to preserve
// property-prefix replacement semantics.
tmp := models.NewNode()
for _, t := range current.Tags() {
tmp.AddTag(t)
}
if input.Type != nil {
tmp.AddTag("_type::" + *input.Type)
}
if input.Status != nil {
tmp.AddTag("_status::" + *input.Status)
}
if input.Priority != nil {
tmp.AddTag("_prio::" + *input.Priority)
}
for _, t := range input.AddTags {
tmp.AddTag(t)
}
for _, t := range input.RemoveTags {
tmp.RemoveTag(t) //nolint: the error is only for _type:: removal, which is intentionally prevented
}
// Sync tags to store.
currentTags, newTags := current.Tags(), tmp.Tags()
for _, t := range currentTags {
if !slices.Contains(newTags, t) {
if err := st.RemoveTag(id, t); err != nil {
return err
}
}
}
for _, t := range newTags {
if !slices.Contains(currentTags, t) {
if err := st.AddTag(id, t); err != nil {
return err
}
}
}
// Sync mention edges when title or content changed.
if node.Title != current.Title || node.Content != current.Content {
newMentions := mentions(node.Title + " " + node.Content)
existingMentionIDs := make(map[string]bool)
for _, uid := range current.Relations()[string(models.RelMentions)] {
existingMentionIDs[uid] = true
}
mentionedUserIDs := make(map[string]bool)
for _, m := range newMentions {
userID, err := s.resolveUserRef(st, m)
if err != nil {
return err
}
mentionedUserIDs[userID] = true
if !existingMentionIDs[userID] {
if err := st.AddEdge(node.ID, userID, models.RelMentions); err != nil {
return err
}
}
}
for uid := range existingMentionIDs {
if !mentionedUserIDs[uid] {
if err := st.RemoveEdge(node.ID, uid, models.RelMentions); err != nil {
return err
}
}
if input.Title != nil || input.Content != nil {
if err := s.syncMentions(st, id, current, title, content); err != nil {
return err
}
}
// Sync tags.
currentTags := current.Tags()
nodeTags := node.Tags()
for _, t := range currentTags {
if !slices.Contains(nodeTags, t) {
if err := st.RemoveTag(node.ID, t); err != nil {
return err
}
}
// Build relation additions, including structured fields.
var addRels []RelInput
if input.Namespace != nil {
addRels = append(addRels, RelInput{Type: models.RelInNamespace, Target: *input.Namespace})
}
for _, t := range nodeTags {
if !slices.Contains(currentTags, t) {
if err := st.AddTag(node.ID, t); err != nil {
return err
}
}
if input.Assignee != nil {
addRels = append(addRels, RelInput{Type: models.RelAssignee, Target: *input.Assignee})
}
addRels = append(addRels, input.AddRels...)
// Sync edges (excluding mention edges, already handled above).
currentRels := current.Relations()
nodeRels := node.Relations()
for rt, tgts := range currentRels {
if rt == string(models.RelMentions) {
continue
for _, ri := range addRels {
resolved, err := s.resolveRelTarget(st, ri)
if err != nil {
return err
}
for _, tgt := range tgts {
if nodeRels[rt] == nil || !slices.Contains(nodeRels[rt], tgt) {
if err := st.RemoveEdge(node.ID, tgt, models.RelType(rt)); err != nil {
// 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 {
return err
}
}
}
if err := st.AddEdge(id, resolved, ri.Type); err != nil {
return err
}
}
for rt, tgts := range nodeRels {
if rt == string(models.RelMentions) {
continue
for _, ri := range input.RemoveRels {
resolved, err := s.resolveRelTarget(st, ri)
if err != nil {
return err
}
for _, tgt := range tgts {
if currentRels[rt] == nil || !slices.Contains(currentRels[rt], tgt) {
resolvedTgt := tgt
if models.RelType(rt) == models.RelAssignee || models.RelType(rt) == models.RelCreated {
var err error
if resolvedTgt, err = s.resolveUserRef(st, tgt); err != nil {
return err
}
}
if models.RelType(rt) == models.RelInNamespace {
var err error
if resolvedTgt, err = s.resolveNamespaceRef(st, tgt); err != nil {
return err
}
}
if err := st.AddEdge(node.ID, resolvedTgt, models.RelType(rt)); err != nil {
return err
}
}
if err := st.RemoveEdge(id, resolved, ri.Type); err != nil {
return err
}
}
return nil
})
if err != nil {
return nil, err
}
return s.store.GetNode(id)
}
// resolveIDByNameAndType finds a node by title and _type tag.
// Loads all nodes of that type and filters in-memory (few users/namespaces expected).
func (s *nodeServiceImpl) Delete(id string) error {
return s.store.DeleteNode(id)
}
// --- User management ---
func (s *nodeServiceImpl) AddUser(name string) (*models.Node, error) {
var id string
err := s.store.Transaction(func(st store.Store) error {
var err error
id, err = s.ensureUser(st, name)
return err
})
if err != nil {
return nil, err
}
return s.store.GetNode(id)
}
func (s *nodeServiceImpl) ListUsers() ([]*models.Node, error) {
return s.store.FindNodes([]string{"_type::user"}, nil)
}
// --- Internal helpers ---
func (s *nodeServiceImpl) checkBlockers(id string) error {
node, err := s.store.GetNode(id)
if err != nil {
return err
}
var blocking []string
for _, bID := range node.Relations()[string(models.RelBlocks)] {
blocker, err := s.store.GetNode(bID)
if err != nil {
return err
}
if blocker.GetProperty("status") == "open" {
blocking = append(blocking, bID)
}
}
if len(blocking) > 0 {
return fmt.Errorf("cannot close: blocked by %v", blocking)
}
return nil
}
func (s *nodeServiceImpl) syncMentions(st store.Store, id string, current *models.Node, newTitle, newContent string) error {
existingMentionIDs := make(map[string]bool)
for _, uid := range current.Relations()[string(models.RelMentions)] {
existingMentionIDs[uid] = true
}
mentionedUserIDs := make(map[string]bool)
for _, m := range mentions(newTitle + " " + newContent) {
userID, err := s.resolveUserRef(st, m)
if err != nil {
return err
}
mentionedUserIDs[userID] = true
if !existingMentionIDs[userID] {
if err := st.AddEdge(id, userID, models.RelMentions); err != nil {
return err
}
}
}
for uid := range existingMentionIDs {
if !mentionedUserIDs[uid] {
if err := st.RemoveEdge(id, uid, models.RelMentions); err != nil {
return err
}
}
}
return nil
}
// resolveRelTarget resolves a RelInput target to a node ID, auto-creating users
// and namespaces as needed. Use only inside a transaction.
func (s *nodeServiceImpl) resolveRelTarget(st store.Store, ri RelInput) (string, error) {
switch ri.Type {
case models.RelAssignee, models.RelCreated, models.RelMentions:
return s.resolveUserRef(st, ri.Target)
case models.RelInNamespace:
return s.resolveNamespaceRef(st, ri.Target)
default:
return ri.Target, nil // blocks/subtask/related expect raw node IDs
}
}
// lookupRelTarget resolves a filter target to a node ID without creating anything.
// Returns ("", false) when the target doesn't exist.
func (s *nodeServiceImpl) lookupRelTarget(relType models.RelType, target string) (string, bool) {
if exists, _ := s.store.NodeExists(target); exists {
return target, true
}
var nodeType string
switch relType {
case models.RelAssignee, models.RelCreated, models.RelMentions:
nodeType = "user"
case models.RelInNamespace:
nodeType = "namespace"
default:
return target, true
}
id, err := s.resolveIDByNameAndType(s.store, target, nodeType)
if err != nil || id == "" {
return "", false
}
return id, true
}
// resolveIDByNameAndType finds a node by title and _type tag without creating it.
func (s *nodeServiceImpl) resolveIDByNameAndType(st store.Store, title, nodeType string) (string, error) {
nodes, err := st.FindNodes([]string{"_type::" + nodeType}, nil)
if err != nil {
@@ -305,7 +436,6 @@ func (s *nodeServiceImpl) ensureUser(st store.Store, username string) (string, e
if userID != "" {
return userID, nil
}
id, err := st.GenerateID()
if err != nil {
return "", err
@@ -335,7 +465,6 @@ func (s *nodeServiceImpl) ensureNamespace(st store.Store, name string) (string,
if nsID != "" {
return nsID, nil
}
id, err := st.GenerateID()
if err != nil {
return "", err
@@ -359,3 +488,4 @@ func (s *nodeServiceImpl) ensureNamespace(st store.Store, name string) (string,
}
return id, nil
}