feat(go): implement note linking with tests

main.go

@@ -2,11 +2,13 @@ package main
 
 import (
 	"embed"
+	"fmt"
 	"log"
 	"mime"
 	"net/http"
 	"path"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"time"
 
@@ -77,6 +79,74 @@ type Note struct {
 	Content   string    `json:"content" gorm:"not null"`
 	CreatedAt time.Time `json:"createdAt"`
 	UpdatedAt time.Time `json:"updatedAt"`
+	// Link relationships
+	LinksTo   []*Note   `json:"linksTo,omitempty" gorm:"many2many:note_links;joinForeignKey:source_note_id;joinReferences:target_note_id"`
+	LinkedBy  []*Note   `json:"linkedBy,omitempty" gorm:"many2many:note_links;joinForeignKey:target_note_id;joinReferences:source_note_id"`
+}
+
+// Link represents a connection between two notes
+type NoteLink struct {
+	SourceNoteID string    `gorm:"primaryKey"`
+	TargetNoteID string    `gorm:"primaryKey"`
+	CreatedAt    time.Time `gorm:"autoCreateTime"`
+}
+
+// ExtractLinks finds all [[note-title]] style links in the content
+func (n *Note) ExtractLinks(content string) []string {
+	re := regexp.MustCompile(`\[\[(.*?)\]\]`)
+	matches := re.FindAllStringSubmatch(content, -1)
+	titles := make([]string, 0, len(matches))
+	for _, match := range matches {
+		if len(match) > 1 {
+			titles = append(titles, match[1])
+		}
+	}
+	return titles
+}
+
+// UpdateLinks updates the note's links based on its content
+func (n *Note) UpdateLinks(db *gorm.DB) error {
+	// Start a transaction
+	tx := db.Begin()
+	if tx.Error != nil {
+		return fmt.Errorf("failed to start transaction: %w", tx.Error)
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// Delete existing links
+	if err := tx.Where("source_note_id = ?", n.ID).Delete(&NoteLink{}).Error; err != nil {
+		tx.Rollback()
+		return fmt.Errorf("failed to delete existing links: %w", err)
+	}
+
+	// Extract and create new links
+	titles := n.ExtractLinks(n.Content)
+	for _, title := range titles {
+		var target Note
+		if err := tx.Where("title = ?", title).First(&target).Error; err != nil {
+			if err == gorm.ErrRecordNotFound {
+				// Skip non-existent notes
+				continue
+			}
+			tx.Rollback()
+			return fmt.Errorf("failed to find target note %q: %w", title, err)
+		}
+
+		link := NoteLink{
+			SourceNoteID: n.ID,
+			TargetNoteID: target.ID,
+		}
+		if err := tx.Create(&link).Error; err != nil {
+			tx.Rollback()
+			return fmt.Errorf("failed to create link to %q: %w", title, err)
+		}
+	}
+
+	return tx.Commit().Error
 }
 
 var db *gorm.DB
@@ -120,7 +190,7 @@ func main() {
 
 func handleGetNotes(c *gin.Context) {
 	var notes []Note
-	if err := db.Order("updated_at desc").Find(&notes).Error; err != nil {
+	if err := db.Preload("LinksTo").Order("updated_at desc").Find(&notes).Error; err != nil {
 		log.Printf("ERROR: Failed to query notes: %v", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
@@ -140,12 +210,48 @@ func handleCreateNote(c *gin.Context) {
 	// Generate a new UUID for the note
 	note.ID = uuid.New().String()
 
-	if err := db.Create(&note).Error; err != nil {
+	// Start a transaction
+	tx := db.Begin()
+	if tx.Error != nil {
+		log.Printf("ERROR: Failed to start transaction: %v", tx.Error)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": tx.Error.Error()})
+		return
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// Create the note
+	if err := tx.Create(&note).Error; err != nil {
+		tx.Rollback()
 		log.Printf("ERROR: Failed to create note: %v", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
+	// Update links
+	if err := note.UpdateLinks(tx); err != nil {
+		tx.Rollback()
+		log.Printf("ERROR: Failed to update note links: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	if err := tx.Commit().Error; err != nil {
+		log.Printf("ERROR: Failed to commit transaction: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Load the note with its relationships
+	if err := db.Preload("LinksTo").First(&note).Error; err != nil {
+		log.Printf("ERROR: Failed to load note relationships: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
 	c.JSON(http.StatusCreated, note)
 }
 
@@ -153,7 +259,7 @@ func handleGetNote(c *gin.Context) {
 	id := c.Param("id")
 	var note Note
 
-	if err := db.First(&note, "id = ?", id).Error; err != nil {
+	if err := db.Preload("LinksTo").Preload("LinkedBy").First(&note, "id = ?", id).Error; err != nil {
 		if err == gorm.ErrRecordNotFound {
 			c.Status(http.StatusNotFound)
 			return
@@ -176,16 +282,53 @@ func handleUpdateNote(c *gin.Context) {
 		return
 	}
 
-	if err := db.Model(&Note{}).Where("id = ?", id).Updates(map[string]interface{}{
+	// Start a transaction
+	tx := db.Begin()
+	if tx.Error != nil {
+		log.Printf("ERROR: Failed to start transaction: %v", tx.Error)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": tx.Error.Error()})
+		return
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// Update the note
+	if err := tx.Model(&Note{}).Where("id = ?", id).Updates(map[string]interface{}{
 		"title":      note.Title,
 		"content":    note.Content,
 		"updated_at": note.UpdatedAt,
 	}).Error; err != nil {
+		tx.Rollback()
 		log.Printf("ERROR: Failed to update note %s: %v", id, err)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
+	// Load the updated note for link processing
+	if err := tx.First(&note, "id = ?", id).Error; err != nil {
+		tx.Rollback()
+		log.Printf("ERROR: Failed to load note %s: %v", id, err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Update links
+	if err := note.UpdateLinks(tx); err != nil {
+		tx.Rollback()
+		log.Printf("ERROR: Failed to update note links: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	if err := tx.Commit().Error; err != nil {
+		log.Printf("ERROR: Failed to commit transaction: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
 	c.Status(http.StatusOK)
 }
 

main_test.go

@@ -0,0 +1,184 @@
+package main
+
+import (
+	"testing"
+	"time"
+
+	"github.com/glebarez/sqlite"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+func setupTestDB(t *testing.T) *gorm.DB {
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("Failed to open test database: %v", err)
+	}
+
+	if err := db.AutoMigrate(&Note{}, &NoteLink{}); err != nil {
+		t.Fatalf("Failed to migrate test database: %v", err)
+	}
+
+	return db
+}
+
+func createTestNote(t *testing.T, db *gorm.DB, title, content string) *Note {
+	note := &Note{
+		ID:        uuid.New().String(),
+		Title:     title,
+		Content:   content,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := db.Create(note).Error; err != nil {
+		t.Fatalf("Failed to create test note: %v", err)
+	}
+
+	return note
+}
+
+func TestExtractLinks(t *testing.T) {
+	tests := []struct {
+		name     string
+		content  string
+		expected []string
+	}{
+		{
+			name:     "no links",
+			content:  "Just some text without links",
+			expected: []string{},
+		},
+		{
+			name:     "single link",
+			content:  "Text with [[another note]] link",
+			expected: []string{"another note"},
+		},
+		{
+			name:     "multiple links",
+			content:  "Text with [[first]] and [[second]] links",
+			expected: []string{"first", "second"},
+		},
+		{
+			name:     "repeated links",
+			content:  "[[same]] link [[same]] twice",
+			expected: []string{"same", "same"},
+		},
+	}
+
+	note := &Note{}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := note.ExtractLinks(tt.content)
+			if len(got) != len(tt.expected) {
+				t.Errorf("ExtractLinks() got %v links, want %v", len(got), len(tt.expected))
+			}
+			for i, link := range got {
+				if link != tt.expected[i] {
+					t.Errorf("ExtractLinks() got %v, want %v", link, tt.expected[i])
+				}
+			}
+		})
+	}
+}
+
+func TestUpdateLinks(t *testing.T) {
+	db := setupTestDB(t)
+
+	// Create some test notes
+	note1 := createTestNote(t, db, "First Note", "Content with [[Second Note]] and [[Third Note]]")
+	note2 := createTestNote(t, db, "Second Note", "Some content")
+	createTestNote(t, db, "Third Note", "More content") // Create but don't need to track
+
+	// Test creating links
+	t.Run("create links", func(t *testing.T) {
+		if err := note1.UpdateLinks(db); err != nil {
+			t.Fatalf("UpdateLinks() error = %v", err)
+		}
+
+		// Verify links were created
+		var links []NoteLink
+		if err := db.Find(&links).Error; err != nil {
+			t.Fatalf("Failed to query links: %v", err)
+		}
+
+		if len(links) != 2 {
+			t.Errorf("Expected 2 links, got %d", len(links))
+		}
+
+		// Load note with relationships
+		var loadedNote Note
+		if err := db.Preload("LinksTo").First(&loadedNote, "id = ?", note1.ID).Error; err != nil {
+			t.Fatalf("Failed to load note: %v", err)
+		}
+
+		if len(loadedNote.LinksTo) != 2 {
+			t.Errorf("Expected 2 LinksTo relationships, got %d", len(loadedNote.LinksTo))
+		}
+	})
+
+	// Test updating links
+	t.Run("update links", func(t *testing.T) {
+		note1.Content = "Content with [[Second Note]] only" // Remove Third Note link
+		if err := note1.UpdateLinks(db); err != nil {
+			t.Fatalf("UpdateLinks() error = %v", err)
+		}
+
+		// Verify links were updated
+		var links []NoteLink
+		if err := db.Find(&links).Error; err != nil {
+			t.Fatalf("Failed to query links: %v", err)
+		}
+
+		if len(links) != 1 {
+			t.Errorf("Expected 1 link, got %d", len(links))
+		}
+
+		// Load note with relationships
+		var loadedNote Note
+		if err := db.Preload("LinksTo").First(&loadedNote, "id = ?", note1.ID).Error; err != nil {
+			t.Fatalf("Failed to load note: %v", err)
+		}
+
+		if len(loadedNote.LinksTo) != 1 {
+			t.Errorf("Expected 1 LinksTo relationship, got %d", len(loadedNote.LinksTo))
+		}
+	})
+
+	// Test bidirectional relationships
+	t.Run("bidirectional relationships", func(t *testing.T) {
+		// Add a link back to First Note
+		note2.Content = "Content with [[First Note]]"
+		if err := note2.UpdateLinks(db); err != nil {
+			t.Fatalf("UpdateLinks() error = %v", err)
+		}
+
+		// Check First Note's LinkedBy
+		var note1Updated Note
+		if err := db.Preload("LinkedBy").First(&note1Updated, "id = ?", note1.ID).Error; err != nil {
+			t.Fatalf("Failed to load note: %v", err)
+		}
+
+		if len(note1Updated.LinkedBy) != 1 {
+			t.Errorf("Expected 1 LinkedBy relationship, got %d", len(note1Updated.LinkedBy))
+		}
+	})
+
+	// Test non-existent links
+	t.Run("non-existent links", func(t *testing.T) {
+		note1.Content = "Content with [[Non-existent Note]]"
+		if err := note1.UpdateLinks(db); err != nil {
+			t.Fatalf("UpdateLinks() error = %v", err)
+		}
+
+		// Verify no links were created
+		var links []NoteLink
+		if err := db.Find(&links).Error; err != nil {
+			t.Fatalf("Failed to query links: %v", err)
+		}
+
+		if len(links) != 1 { // Should still have the link from Second Note to First Note
+			t.Errorf("Expected 1 link, got %d", len(links))
+		}
+	})
+}