feat: add migration to add frontmatter to markdown files (#565)

Author: perber

cmd/leafwiki/main.go

@@ -4,6 +4,7 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"log/slog"
 	"os"
 	"strings"
 	"time"
@@ -53,7 +54,22 @@ func printUsage() {
 	`)
 }
 
+func setupLogger() {
+	level := slog.LevelInfo
+	if os.Getenv("LOG_LEVEL") == "debug" {
+		level = slog.LevelDebug
+	}
+
+	handler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		Level:     level,
+		AddSource: true,
+	})
+
+	slog.SetDefault(slog.New(handler))
+}
+
 func main() {
+	setupLogger()
 
 	// flags
 	hostFlag := flag.String("host", "", "host/IP address to bind the server to (e.g. 127.0.0.1 or 0.0.0.0)")

internal/core/tree/errors.go

@@ -11,3 +11,4 @@ var ErrMovePageCircularReference = errors.New("circular reference detected")
 var ErrPageCannotBeMovedToItself = errors.New("page cannot be moved to itself")
 var ErrInvalidSortOrder = errors.New("invalid sort order")
 var ErrFrontmatterParse = errors.New("frontmatter parse error")
+var ErrFileNotFound = errors.New("file not found")

internal/core/tree/page_store.go

@@ -308,6 +308,19 @@ func (f *PageStore) MovePage(entry *PageNode, parentEntry *PageNode) error {
 	return nil
 }
 
+// ReadPageRaw returns the raw content of a page including frontmatter
+func (f *PageStore) ReadPageRaw(entry *PageNode) (string, error) {
+	filePath, err := f.getFilePath(entry)
+	if err != nil {
+		return "", err
+	}
+	raw, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+	return string(raw), nil
+}
+
 // ReadPageContent returns the content of a page
 func (f *PageStore) ReadPageContent(entry *PageNode) (string, error) {
 	if entry == nil {
@@ -362,5 +375,5 @@ func (f *PageStore) getFilePath(entry *PageNode) (string, error) {
 		return path.Join(entryPath, "index.md"), nil
 	}
 
-	return "", errors.New("file not found")
+	return "", ErrFileNotFound
 }

internal/core/tree/schema.go

@@ -7,7 +7,7 @@ import (
 	"path/filepath"
 )
 
-const CurrentSchemaVersion = 1
+const CurrentSchemaVersion = 2
 
 type SchemaInfo struct {
 	Version int `json:"version"`

internal/core/tree/tree_service.go

@@ -1,8 +1,9 @@
 package tree
 
 import (
+	"errors"
 	"fmt"
-	"log"
+	"log/slog"
 	"os"
 	"sort"
 	"strings"
@@ -19,6 +20,7 @@ type TreeService struct {
 	treeFilename string
 	tree         *PageNode
 	store        *PageStore
+	log          *slog.Logger
 
 	mu sync.RWMutex
 }
@@ -30,6 +32,7 @@ func NewTreeService(storageDir string) *TreeService {
 		treeFilename: "tree.json",
 		tree:         nil,
 		store:        NewPageStore(storageDir),
+		log:          slog.Default().With("component", "TreeService"),
 	}
 }
 
@@ -47,42 +50,56 @@ func (t *TreeService) LoadTree() error {
 	}
 
 	// Load the schema version
-	log.Printf("Checking schema version...")
+	t.log.Info("Checking schema version...")
 	schema, err := loadSchema(t.storageDir)
 	if err != nil {
-		log.Printf("Error loading schema: %v", err)
+		t.log.Error("Error loading schema", "error", err)
 		return err
 	}
 
 	if schema.Version < CurrentSchemaVersion {
-		log.Printf("Migrating schema from version %d to %d...", schema.Version, CurrentSchemaVersion)
+		t.log.Info("Migrating schema", "fromVersion", schema.Version, "toVersion", CurrentSchemaVersion)
 		if err := t.migrate(schema.Version); err != nil {
-			log.Printf("Error migrating schema: %v", err)
+			t.log.Error("Error migrating schema", "error", err)
 			return err
 		}
-
-		// migration was successful, update schema version
-		if err := saveSchema(t.storageDir, CurrentSchemaVersion); err != nil {
-			log.Printf("Error saving schema: %v", err)
-			return err
-		}
-
-		return t.saveTreeLocked()
 	}
 
 	return err
 }
 
 func (t *TreeService) migrate(fromVersion int) error {
-	if fromVersion < 1 {
-		if err := t.migrateTreeToV1Schema(); err != nil {
+
+	for v := fromVersion; v < CurrentSchemaVersion; v++ {
+		switch v {
+		case 0:
+			if err := t.migrateToV1(); err != nil {
+				t.log.Error("Error migrating to v1", "error", err)
+				return err
+			}
+		case 1:
+			if err := t.migrateToV2(); err != nil {
+				t.log.Error("Error migrating to v2", "error", err)
+				return err
+			}
+		}
+
+		// Save the tree after each migration step
+		if err := t.saveTreeLocked(); err != nil {
+			t.log.Error("Error saving tree after migration", "version", v+1, "error", err)
+			return err
+		}
+
+		// Update the schema version file
+		if err := saveSchema(t.storageDir, v+1); err != nil {
+			t.log.Error("Error saving schema", "version", v+1, "error", err)
 			return err
 		}
 	}
 	return nil
 }
 
-func (t *TreeService) migrateTreeToV1Schema() error {
+func (t *TreeService) migrateToV1() error {
 	// Backfill metadata for all pages
 	var backfillMetadata func(node *PageNode) error
 	backfillMetadata = func(node *PageNode) error {
@@ -98,7 +115,7 @@ func (t *TreeService) migrateTreeToV1Schema() error {
 			// Log the error and continue
 			// We still want to backfill metadata for other nodes
 			// but we cannot do it for this node
-			log.Printf("could not get file path for node %s: %v", node.ID, err)
+			t.log.Error("Could not get file path for node", "nodeID", node.ID, "error", err)
 			return nil
 		}
 
@@ -111,7 +128,7 @@ func (t *TreeService) migrateTreeToV1Schema() error {
 			createdAt = info.ModTime().UTC()
 			updatedAt = info.ModTime().UTC()
 		} else if !os.IsNotExist(err) {
-			log.Printf("could not stat file for node %s at path %s: %v", node.ID, filePath, err)
+			t.log.Error("Could not stat file for node", "nodeID", node.ID, "filePath", filePath, "error", err)
 		}
 
 		node.Metadata = PageMetadata{
@@ -129,9 +146,113 @@ func (t *TreeService) migrateTreeToV1Schema() error {
 		return nil
 	}
 
+	if t.tree == nil {
+		return ErrTreeNotLoaded
+	}
+
 	return backfillMetadata(t.tree)
 }
 
+// migrateToV2 migrates the tree to the v2 schema
+// Adds frontmatter to all existing pages if missing
+func (t *TreeService) migrateToV2() error {
+	// Traverse all pages and add frontmatter if missing
+	var addFrontmatter func(node *PageNode) error
+	addFrontmatter = func(node *PageNode) error {
+		// Read the content of the page
+		content, err := t.store.ReadPageRaw(node)
+		if err != nil {
+			if errors.Is(err, os.ErrNotExist) || errors.Is(err, ErrFileNotFound) {
+				t.log.Warn("Page file does not exist, skipping frontmatter addition", "nodeID", node.ID)
+				// Recurse into children
+				for _, child := range node.Children {
+					if err := addFrontmatter(child); err != nil {
+						t.log.Error("Error adding frontmatter to child node", "nodeID", child.ID, "error", err)
+						return err
+					}
+				}
+				return nil
+			}
+			t.log.Error("Could not read page content for node", "nodeID", node.ID, "error", err)
+			return fmt.Errorf("could not read page content for node %s: %v", node.ID, err)
+		}
+
+		// Parse the frontmatter
+		fm, body, has, err := ParseFrontmatter(content)
+		if err != nil {
+			t.log.Error("Could not parse frontmatter for node", "nodeID", node.ID, "error", err)
+			return fmt.Errorf("could not parse frontmatter for node %s: %v", node.ID, err)
+		}
+
+		// Decide if we need to change anything
+		changed := false
+
+		// If there is no frontmatter, start with a new one
+		if !has {
+			fm = Frontmatter{}
+			changed = true
+		}
+
+		// Ensure required fields exist
+		if strings.TrimSpace(fm.LeafWikiID) == "" {
+			fm.LeafWikiID = node.ID
+			changed = true
+		}
+		// Optional but nice: keep title in sync *at least once*
+		// (you might choose to NOT overwrite existing title)
+		if strings.TrimSpace(fm.LeafWikiTitle) == "" {
+			fm.LeafWikiTitle = node.Title
+			changed = true
+		}
+
+		// Only write if changed
+		if changed {
+			newContent, err := BuildMarkdownWithFrontmatter(fm, body)
+			if err != nil {
+				t.log.Error("could not build markdown with frontmatter", "nodeID", node.ID, "error", err)
+				return fmt.Errorf("could not build markdown with frontmatter for node %s: %w", node.ID, err)
+			}
+
+			filePath, err := t.store.getFilePath(node)
+			if err != nil {
+				t.log.Error("could not get file path", "nodeID", node.ID, "error", err)
+				return fmt.Errorf("could not get file path for node %s: %w", node.ID, err)
+			}
+
+			if err := writeFileAtomic(filePath, []byte(newContent), 0o644); err != nil {
+				t.log.Error("could not write updated page content", "nodeID", node.ID, "filePath", filePath, "error", err)
+				return fmt.Errorf("could not write updated page content for node %s: %w", node.ID, err)
+			}
+
+			t.log.Info("frontmatter backfilled", "nodeID", node.ID, "path", filePath)
+		}
+
+		// Recurse into children
+		for _, child := range node.Children {
+			if err := addFrontmatter(child); err != nil {
+				t.log.Error("Error adding frontmatter to child node", "nodeID", child.ID, "error", err)
+				return err
+			}
+		}
+
+		return nil
+	}
+
+	if t.tree == nil {
+		return ErrTreeNotLoaded
+	}
+
+	// start the recursion from the children of the root
+	for _, child := range t.tree.Children {
+		if err := addFrontmatter(child); err != nil {
+			t.log.Error("Error adding frontmatter to child node", "nodeID", child.ID, "error", err)
+			return err
+		}
+	}
+
+	return nil
+}
+
 // SaveTree saves the tree to the storage directory
 func (t *TreeService) SaveTree() error {
 	t.mu.Lock()