489 lines
12 KiB
Go
489 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"axolotl/models"
|
|
"axolotl/store"
|
|
"fmt"
|
|
"maps"
|
|
"regexp"
|
|
"slices"
|
|
"time"
|
|
)
|
|
|
|
type nodeServiceImpl struct {
|
|
store store.Store
|
|
userID string
|
|
}
|
|
|
|
var mentionRegex = regexp.MustCompile(`@([a-z0-9_]+)`)
|
|
|
|
func mentions(t string) []string {
|
|
seen := make(map[string]bool)
|
|
for _, m := range mentionRegex.FindAllStringSubmatch(t, -1) {
|
|
seen[m[1]] = true
|
|
}
|
|
return slices.Collect(maps.Keys(seen))
|
|
}
|
|
|
|
// --- Query ---
|
|
|
|
func (s *nodeServiceImpl) GetByID(id string) (*models.Node, error) {
|
|
return s.store.GetNode(id)
|
|
}
|
|
|
|
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)
|
|
}
|
|
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
|
|
}
|
|
id, ok := s.lookupRelTarget(e.relType, e.name)
|
|
if !ok {
|
|
return nil, nil // named target doesn't exist; no nodes can match
|
|
}
|
|
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(tagPrefixes, relFilters)
|
|
}
|
|
|
|
// --- 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)
|
|
}
|
|
|
|
id, err := s.store.GenerateID()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = s.store.Transaction(func(st store.Store) error {
|
|
now := time.Now().UTC().Format(time.RFC3339)
|
|
if err := st.AddNode(id, input.Title, input.Content, input.DueDate, now, now); err != nil {
|
|
return err
|
|
}
|
|
|
|
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 {
|
|
return err
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
}
|
|
|
|
if !hasCreated {
|
|
userID, err := s.resolveUserRef(st, s.userID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := st.AddEdge(id, userID, models.RelCreated); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.store.GetNode(id)
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
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 input.Title != nil || input.Content != nil {
|
|
if err := s.syncMentions(st, id, current, title, content); 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})
|
|
}
|
|
if input.Assignee != nil {
|
|
addRels = append(addRels, RelInput{Type: models.RelAssignee, Target: *input.Assignee})
|
|
}
|
|
addRels = append(addRels, input.AddRels...)
|
|
|
|
currentRels := current.Relations()
|
|
for _, ri := range addRels {
|
|
resolved, err := s.resolveRelTarget(st, ri)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// 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 _, ri := range input.RemoveRels {
|
|
resolved, err := s.resolveRelTarget(st, ri)
|
|
if 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)
|
|
}
|
|
|
|
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 {
|
|
// 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}})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var blocking []string
|
|
for _, b := range blockers {
|
|
if b.GetProperty("status") == "open" {
|
|
blocking = append(blocking, b.ID)
|
|
}
|
|
}
|
|
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 {
|
|
return "", err
|
|
}
|
|
for _, n := range nodes {
|
|
if n.Title == title {
|
|
return n.ID, nil
|
|
}
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
func (s *nodeServiceImpl) resolveUserRef(st store.Store, ref string) (string, error) {
|
|
if exists, _ := st.NodeExists(ref); exists {
|
|
return ref, nil
|
|
}
|
|
return s.ensureUser(st, ref)
|
|
}
|
|
|
|
func (s *nodeServiceImpl) ensureUser(st store.Store, username string) (string, error) {
|
|
userID, err := s.resolveIDByNameAndType(st, username, "user")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if userID != "" {
|
|
return userID, nil
|
|
}
|
|
id, err := st.GenerateID()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
now := time.Now().UTC().Format(time.RFC3339)
|
|
if err := st.AddNode(id, username, "", "", now, now); err != nil {
|
|
return "", err
|
|
}
|
|
if err := st.AddTag(id, "_type::user"); err != nil {
|
|
return "", err
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
func (s *nodeServiceImpl) resolveNamespaceRef(st store.Store, ref string) (string, error) {
|
|
if exists, _ := st.NodeExists(ref); exists {
|
|
return ref, nil
|
|
}
|
|
return s.ensureNamespace(st, ref)
|
|
}
|
|
|
|
func (s *nodeServiceImpl) ensureNamespace(st store.Store, name string) (string, error) {
|
|
nsID, err := s.resolveIDByNameAndType(st, name, "namespace")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if nsID != "" {
|
|
return nsID, nil
|
|
}
|
|
id, err := st.GenerateID()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
now := time.Now().UTC().Format(time.RFC3339)
|
|
if err := st.AddNode(id, name, "", "", now, now); err != nil {
|
|
return "", err
|
|
}
|
|
if err := st.AddTag(id, "_type::namespace"); err != nil {
|
|
return "", err
|
|
}
|
|
if err := st.AddEdge(id, id, models.RelInNamespace); 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 {
|
|
return "", err
|
|
}
|
|
return id, nil
|
|
}
|
|
|