feat(wip): create or update post handler & command

Author: desertthunder

cmd/publication_commands.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/spf13/cobra"
 	"github.com/stormlightlabs/noteleaf/internal/handlers"
@@ -154,5 +155,98 @@ Use filters to show specific subsets:
 	}
 	root.AddCommand(statusCmd)
 
+	postCmd := &cobra.Command{
+		Use:   "post [note-id]",
+		Short: "Create a new document on leaflet",
+		Long: `Publish a local note to leaflet.pub as a new document.
+
+This command converts your markdown note to leaflet's block format and creates
+a new document on the platform. The note will be linked to the leaflet document
+for future updates via the patch command.
+
+Examples:
+  noteleaf pub post 123                # Publish note 123
+  noteleaf pub post 123 --draft        # Create as draft
+  noteleaf pub post 123 --preview      # Preview without posting
+  noteleaf pub post 123 --validate     # Validate conversion only`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			noteID, err := parseNoteID(args[0])
+			if err != nil {
+				return err
+			}
+
+			isDraft, _ := cmd.Flags().GetBool("draft")
+			preview, _ := cmd.Flags().GetBool("preview")
+			validate, _ := cmd.Flags().GetBool("validate")
+
+			defer c.handler.Close()
+
+			if preview {
+				return c.handler.PostPreview(cmd.Context(), noteID, isDraft)
+			}
+
+			if validate {
+				return c.handler.PostValidate(cmd.Context(), noteID, isDraft)
+			}
+
+			return c.handler.Post(cmd.Context(), noteID, isDraft)
+		},
+	}
+	postCmd.Flags().Bool("draft", false, "Create as draft instead of publishing")
+	postCmd.Flags().Bool("preview", false, "Show what would be posted without actually posting")
+	postCmd.Flags().Bool("validate", false, "Validate markdown conversion without posting")
+	root.AddCommand(postCmd)
+
+	patchCmd := &cobra.Command{
+		Use:   "patch [note-id]",
+		Short: "Update an existing document on leaflet",
+		Long: `Update an existing leaflet document from a local note.
+
+This command converts your markdown note to leaflet's block format and updates
+the existing document on the platform. The note must have been previously posted
+or pulled from leaflet (it needs a leaflet record key).
+
+The document's draft/published status is preserved from the note's current state.
+
+Examples:
+  noteleaf pub patch 123            # Update existing document
+  noteleaf pub patch 123 --preview  # Preview without updating
+  noteleaf pub patch 123 --validate # Validate conversion only`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			noteID, err := parseNoteID(args[0])
+			if err != nil {
+				return err
+			}
+
+			preview, _ := cmd.Flags().GetBool("preview")
+			validate, _ := cmd.Flags().GetBool("validate")
+
+			defer c.handler.Close()
+
+			if preview {
+				return c.handler.PatchPreview(cmd.Context(), noteID)
+			}
+
+			if validate {
+				return c.handler.PatchValidate(cmd.Context(), noteID)
+			}
+
+			return c.handler.Patch(cmd.Context(), noteID)
+		},
+	}
+	patchCmd.Flags().Bool("preview", false, "Show what would be updated without actually patching")
+	patchCmd.Flags().Bool("validate", false, "Validate markdown conversion without patching")
+	root.AddCommand(patchCmd)
+
 	return root
 }
+
+func parseNoteID(arg string) (int64, error) {
+	noteID, err := strconv.ParseInt(arg, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("invalid note ID '%s': must be a number", arg)
+	}
+	return noteID, nil
+}

cmd/publication_commands_test.go

@@ -66,6 +66,8 @@ func TestPublicationCommand(t *testing.T) {
 				"pull",
 				"list [--published|--draft|--all]",
 				"status",
+				"post [note-id]",
+				"patch [note-id]",
 			}
 
 			for _, expected := range expectedSubcommands {
@@ -176,6 +178,196 @@ func TestPublicationCommand(t *testing.T) {
 		})
 	})
 
+	t.Run("Post Command", func(t *testing.T) {
+		t.Run("requires note ID argument", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for missing note ID")
+			}
+		})
+
+		t.Run("rejects invalid note ID", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "not-a-number"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for invalid note ID")
+			}
+			if !strings.Contains(err.Error(), "invalid note ID") {
+				t.Errorf("Expected 'invalid note ID' error, got: %v", err)
+			}
+		})
+
+		t.Run("fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("preview mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--preview"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --preview to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("validate mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--validate"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --validate to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("accepts draft flag", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--draft"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --draft to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("accepts preview and draft flags together", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--preview", "--draft"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --preview --draft to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Patch Command", func(t *testing.T) {
+		t.Run("requires note ID argument", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for missing note ID")
+			}
+		})
+
+		t.Run("rejects invalid note ID", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "not-a-number"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for invalid note ID")
+			}
+			if !strings.Contains(err.Error(), "invalid note ID") {
+				t.Errorf("Expected 'invalid note ID' error, got: %v", err)
+			}
+		})
+
+		t.Run("fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "123"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected patch to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("preview mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "123", "--preview"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected patch --preview to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("validate mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "123", "--validate"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected patch --validate to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+	})
+
 	t.Run("Command Help", func(t *testing.T) {
 		t.Run("root help", func(t *testing.T) {
 			handler, cleanup := createTestPublicationHandler(t)