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

cmd/add.go

@@ -1,18 +1,15 @@
 package cmd
 
 import (
-	"axolotl/models"
 	"axolotl/output"
 	"axolotl/service"
 	"fmt"
 	"os"
-	"slices"
-	"strings"
 
 	"github.com/spf13/cobra"
 )
 
-var cDue, cContent string
+var cDue, cContent, cStatus, cPrio, cType, cNamespace, cAssignee string
 var cTags, cRels []string
 
 var addCmd = &cobra.Command{
@@ -20,61 +17,51 @@ var addCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		svc, err := service.GetNodeService(cfg)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "failed to create:", err)
+			fmt.Fprintln(os.Stderr, err)
+			return
 		}
 
-		// default relations
-		if !slices.ContainsFunc(cRels, func(e string) bool { return strings.HasPrefix(e, "in_namespace:") }) {
-			cRels = append(cRels, "in_namespace:"+cfg.GetUser())
+		input := service.AddInput{
+			Title:     args[0],
+			Content:   cContent,
+			DueDate:   cDue,
+			Type:      cType,
+			Status:    cStatus,
+			Priority:  cPrio,
+			Namespace: cNamespace,
+			Assignee:  cAssignee,
+			Tags:      cTags,
 		}
 
-		// parse relations
-		rels := make(map[models.RelType][]string)
 		for _, r := range cRels {
-			rel, err := parseRelFlag(svc, r)
+			ri, err := parseRelInput(r)
 			if err != nil {
 				fmt.Fprintln(os.Stderr, err)
 				return
 			}
-			rels[rel.Type] = append(rels[rel.Type], rel.Target)
+			input.Rels = append(input.Rels, ri)
 		}
 
-		// create
-		n, err := svc.Create(args[0], cContent, cDue, nil, rels)
+		n, err := svc.Add(input)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "failed to create:", err)
 			return
 		}
 
-		for _, t := range cTags {
-			n.AddTag(t)
-		}
-
-		// default tags
-		if !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_type::") }) {
-			n.AddTag("_type::issue")
-		}
-		if n.HasTag("_type::issue") && !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_status::") }) {
-			n.AddTag("_status::open")
-		}
-
-		// persist tags added above
-		if err := svc.Update(n); err != nil {
-			fmt.Fprintln(os.Stderr, "failed to update with tags:", err)
-			return
-		}
-
 		output.PrintNode(cmd.OutOrStdout(), svc, n, jsonFlag)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(addCmd)
-	addPropertyFlags(addCmd)
-	addCmd.Flags().Set("type", "issue")
 	f := addCmd.Flags()
-	f.StringVar(&cDue, "due", "", "")
-	f.StringVar(&cContent, "content", "", "")
-	f.StringArrayVar(&cTags, "tag", nil, "")
-	f.StringArrayVar(&cRels, "rel", nil, "")
+	f.StringVar(&cType, "type", "issue", "node type (issue, note, …)")
+	f.StringVar(&cStatus, "status", "", "initial status (open, done)")
+	f.StringVar(&cPrio, "prio", "", "priority (high, medium, low)")
+	f.StringVar(&cNamespace, "namespace", "", "namespace name or ID")
+	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)")
 }

cmd/edit.go

@@ -45,17 +45,18 @@ var editCmd = &cobra.Command{
 			return
 		}
 
-		if content, err := os.ReadFile(tmp.Name()); err == nil {
-			n.Content = string(content)
-			if err := svc.Update(n); err != nil {
-				fmt.Fprintln(os.Stderr, "failed to update:", err)
-				return
-			}
-			n, _ = svc.GetByID(args[0])
-			output.PrintNode(cmd.OutOrStdout(), svc, n, jsonFlag)
-		} else {
+		content, err := os.ReadFile(tmp.Name())
+		if err != nil {
 			fmt.Fprintln(os.Stderr, "failed to read temp file:", err)
+			return
 		}
+		s := string(content)
+		n, err = svc.Update(args[0], service.UpdateInput{Content: &s})
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "failed to update:", err)
+			return
+		}
+		output.PrintNode(cmd.OutOrStdout(), svc, n, jsonFlag)
 	},
 }
 

cmd/list.go

@@ -10,6 +10,7 @@ import (
 )
 
 var lTags, lRels []string
+var lStatus, lPrio, lType, lNamespace, lAssignee, lMention string
 
 var listCmd = &cobra.Command{
 	Use: "list", Short: "List nodes",
@@ -20,21 +21,26 @@ var listCmd = &cobra.Command{
 			return
 		}
 
-		opts := []service.ListOption{}
-		if len(lTags) > 0 {
-			opts = append(opts, service.WithTags(lTags...))
+		filter := service.ListFilter{
+			Tags:      lTags,
+			Status:    lStatus,
+			Priority:  lPrio,
+			Type:      lType,
+			Namespace: lNamespace,
+			Assignee:  lAssignee,
+			Mention:   lMention,
 		}
 
-		for _, relStr := range lRels {
-			rel, err := parseRelFlag(svc, relStr)
+		for _, r := range lRels {
+			ri, err := parseRelInput(r)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "failed to parse relation flag: %v", err)
 				return
 			}
-			opts = append(opts, service.WithRels(rel))
+			filter.Rels = append(filter.Rels, ri)
 		}
 
-		if nodes, err := svc.List(opts...); err == nil {
+		if nodes, err := svc.List(filter); err == nil {
 			output.PrintNodes(cmd.OutOrStdout(), svc, nodes, jsonFlag)
 		} else {
 			fmt.Fprintf(os.Stderr, "err: %v\n", err)
@@ -44,9 +50,13 @@ var listCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(listCmd)
-	addPropertyFlags(listCmd)
 	f := listCmd.Flags()
-	//TODO: assignee/ mention flags?
-	f.StringArrayVar(&lTags, "tag", nil, "")
-	f.StringArrayVar(&lRels, "rel", nil, "")
+	f.StringArrayVar(&lTags, "tag", nil, "filter by tag")
+	f.StringArrayVar(&lRels, "rel", nil, "filter by relation (type:target)")
+	f.StringVar(&lStatus, "status", "", "filter by status")
+	f.StringVar(&lPrio, "prio", "", "filter by priority")
+	f.StringVar(&lType, "type", "", "filter by type")
+	f.StringVar(&lNamespace, "namespace", "", "filter by namespace")
+	f.StringVar(&lAssignee, "assignee", "", "filter by assignee")
+	f.StringVar(&lMention, "mention", "", "filter by mention")
 }

cmd/rel.go

@@ -7,13 +7,10 @@ import (
 	"strings"
 )
 
-func parseRelFlag(svc service.NodeService, s string) (*models.Rel, error) {
+// parseRelInput parses a "type:target" string into a RelInput.
+func parseRelInput(s string) (service.RelInput, error) {
 	if p := strings.SplitN(s, ":", 2); len(p) == 2 {
-		return &models.Rel{Type: models.RelType(p[0]), Target: p[1]}, nil
+		return service.RelInput{Type: models.RelType(p[0]), Target: p[1]}, nil
 	}
-
-	// name resolution for rels
-	//TODO:
-
-	return &models.Rel{}, fmt.Errorf("invalid relation format: %s (expected type:id)", s)
+	return service.RelInput{}, fmt.Errorf("invalid relation format: %s (expected type:target)", s)
 }

cmd/root.go

@@ -21,7 +21,6 @@ func Execute() {
 		os.Exit(1)
 	}
 	registerAliasCommands()
-	rootCmd.SetArgs(transformArgs(os.Args[1:]))
 	if err := rootCmd.Execute(); err != nil {
 		os.Exit(1)
 	}
@@ -31,15 +30,6 @@ func init() {
 	rootCmd.PersistentFlags().BoolVar(&jsonFlag, "json", false, "")
 }
 
-func addPropertyFlags(cmd *cobra.Command) {
-	cmd.Flags().String("type", "", "node type")
-	cmd.Flags().String("status", "", "node status")
-	cmd.Flags().String("prio", "", "node priority")
-	cmd.Flags().String("namespace", "", "node namespace")
-	cmd.Flags().String("assignee", "", "node assignee")
-	cmd.Flags().String("mention", "", "node mention")
-}
-
 func registerAliasCommands() {
 	rootCmd.AddGroup(&cobra.Group{ID: "aliases", Title: "Aliases:"})
 	aliases, _ := cfg.ListAliases()
@@ -70,7 +60,7 @@ func registerAliasCommands() {
 					}
 					expanded = append(expanded, replaced)
 				}
-				rootCmd.SetArgs(transformArgs(expanded))
+				rootCmd.SetArgs(expanded)
 				if err := rootCmd.Execute(); err != nil {
 					os.Exit(1)
 				}
@@ -78,48 +68,3 @@ func registerAliasCommands() {
 		})
 	}
 }
-
-func transformArgs(args []string) []string {
-	tagAliases := map[string]string{
-		"--status": "_status",
-		"--prio":   "_prio",
-		"--type":   "_type",
-	}
-	relAliases := map[string]string{
-		"--namespace": "in_namespace",
-		"--assignee":  "assignee",
-		"--mention":   "mentions",
-	}
-	result := []string{}
-
-	for i := 0; i < len(args); i++ {
-		if idx := strings.Index(args[i], "="); idx != -1 {
-			flag := args[i][:idx]
-			val := args[i][idx+1:]
-			if prop, ok := tagAliases[flag]; ok {
-				result = append(result, "--tag", prop+"::"+val)
-				continue
-			}
-			if prop, ok := relAliases[flag]; ok {
-				result = append(result, "--rel", prop+":"+val)
-				continue
-			}
-		}
-
-		flag := args[i]
-		if i+1 < len(args) {
-			if prop, ok := tagAliases[flag]; ok {
-				result = append(result, "--tag", prop+"::"+args[i+1])
-				i++
-				continue
-			}
-			if prop, ok := relAliases[flag]; ok {
-				result = append(result, "--rel", prop+":"+args[i+1])
-				i++
-				continue
-			}
-		}
-		result = append(result, args[i])
-	}
-	return result
-}

cmd/update.go

@@ -1,20 +1,19 @@
 package cmd
 
 import (
-	"axolotl/models"
 	"axolotl/output"
 	"axolotl/service"
 	"fmt"
 	"os"
-	"slices"
 
 	"github.com/spf13/cobra"
 )
 
 var (
-	uTitle, uContent, uDue               string
-	uClearDue                            bool
-	uAddTags, uRmTags, uAddRels, uRmRels []string
+	uTitle, uContent, uDue                               string
+	uClearDue                                            bool
+	uStatus, uPrio, uType, uNamespace, uAssignee         string
+	uAddTags, uRmTags, uAddRels, uRmRels                 []string
 )
 
 var updateCmd = &cobra.Command{
@@ -26,106 +25,80 @@ var updateCmd = &cobra.Command{
 			return
 		}
 
-		node, err := svc.GetByID(args[0])
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "node not found:", args[0])
-			return
+		input := service.UpdateInput{
+			AddTags:    uAddTags,
+			RemoveTags: uRmTags,
 		}
 
-		// parse relations
-		addRels, rmRels := make(map[models.RelType][]string), make(map[models.RelType][]string)
-		parseRel := func(src []string, dst map[models.RelType][]string) bool {
-			for _, r := range src {
-				rel, err := parseRelFlag(svc, r)
-				if err != nil {
-					fmt.Fprintln(os.Stderr, err)
-					return false
-				}
-				dst[rel.Type] = append(dst[rel.Type], rel.Target)
-			}
-			return true
-		}
-		if !parseRel(uAddRels, addRels) || !parseRel(uRmRels, rmRels) {
-			return
-		}
-
-		// enforce blocking of tasks
-		//TODO: mabye part of the backend?
-		if slices.Contains(uAddTags, "_status::done") {
-			ok, blockers, err := svc.CanClose(args[0])
-			if err != nil {
-				fmt.Fprintln(os.Stderr, "failed to check blockers:", err)
-				os.Exit(1)
-			}
-			if !ok {
-				fmt.Fprintf(os.Stderr, "cannot close: blocked by %v\n", blockers)
-				os.Exit(1)
-			}
-		}
-
-		// update main fields
 		if cmd.Flags().Changed("title") {
-			node.Title = uTitle
+			input.Title = &uTitle
 		}
 		if cmd.Flags().Changed("content") {
-			node.Content = uContent
+			input.Content = &uContent
 		}
 		if cmd.Flags().Changed("due") {
-			node.DueDate = uDue
+			input.DueDate = &uDue
 		}
 		if uClearDue {
-			node.DueDate = ""
+			empty := ""
+			input.DueDate = &empty
+		}
+		if cmd.Flags().Changed("status") {
+			input.Status = &uStatus
+		}
+		if cmd.Flags().Changed("prio") {
+			input.Priority = &uPrio
+		}
+		if cmd.Flags().Changed("type") {
+			input.Type = &uType
+		}
+		if cmd.Flags().Changed("namespace") {
+			input.Namespace = &uNamespace
+		}
+		if cmd.Flags().Changed("assignee") {
+			input.Assignee = &uAssignee
 		}
 
-		// udpate tags
-		for _, t := range uRmTags {
-			if err := node.RemoveTag(t); err != nil {
-				fmt.Fprintln(os.Stderr, "failed to remove tag:", err)
+		for _, r := range uAddRels {
+			ri, err := parseRelInput(r)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
 				return
 			}
+			input.AddRels = append(input.AddRels, ri)
 		}
-		for _, t := range uAddTags {
-			node.AddTag(t)
+		for _, r := range uRmRels {
+			ri, err := parseRelInput(r)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				return
+			}
+			input.RemoveRels = append(input.RemoveRels, ri)
 		}
 
-		// update relations
-		for rt, tgts := range rmRels {
-			for _, tgt := range tgts {
-				if err := node.RemoveRelation(rt, tgt); err != nil {
-					fmt.Fprintln(os.Stderr, "failed to remove relation:", err)
-					return
-				}
-			}
-		}
-		for rt, tgts := range addRels {
-			for _, tgt := range tgts {
-				node.AddRelation(rt, tgt)
-			}
-		}
-
-		// persist update
-		if err := svc.Update(node); err != nil {
-			fmt.Fprintln(os.Stderr, "failed to update:", err)
-			return
-		}
-		if n, err := svc.GetByID(args[0]); err == nil {
-			output.PrintNode(cmd.OutOrStdout(), svc, n, jsonFlag)
-		} else {
-			fmt.Fprintln(os.Stderr, "failed to fetch node:", err)
+		n, err := svc.Update(args[0], input)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
 		}
+		output.PrintNode(cmd.OutOrStdout(), svc, n, jsonFlag)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(updateCmd)
-	addPropertyFlags(updateCmd)
 	f := updateCmd.Flags()
-	f.StringVar(&uTitle, "title", "", "")
-	f.StringVar(&uContent, "content", "", "")
-	f.StringVar(&uDue, "due", "", "")
-	f.BoolVar(&uClearDue, "clear-due", false, "")
-	f.StringArrayVar(&uAddTags, "tag", nil, "")
-	f.StringArrayVar(&uRmTags, "tag-remove", nil, "")
-	f.StringArrayVar(&uAddRels, "rel", nil, "")
-	f.StringArrayVar(&uRmRels, "rel-remove", nil, "")
+	f.StringVar(&uTitle, "title", "", "new title")
+	f.StringVar(&uContent, "content", "", "new content")
+	f.StringVar(&uDue, "due", "", "due date")
+	f.BoolVar(&uClearDue, "clear-due", false, "clear due date")
+	f.StringVar(&uStatus, "status", "", "status (open, done)")
+	f.StringVar(&uPrio, "prio", "", "priority (high, medium, low)")
+	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)")
 }