quicknotes/main.go

package main

import (
	"embed"
	"log"
	"mime"
	"net/http"
	"path"
	"path/filepath"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/glebarez/sqlite"
	"github.com/google/uuid"
	"gorm.io/gorm"
)

func serveStaticFile(c *gin.Context, prefix string) error {
	cleanPath := path.Clean(c.Request.URL.Path)
	if cleanPath == "/" {
		cleanPath = "/index.html"
	}

	// Try to read the exact file first
	content, err := frontend.ReadFile(prefix + cleanPath)
	ext := strings.ToLower(filepath.Ext(cleanPath))

	// If file not found OR the path has no extension (likely a route path), serve index.html
	if err != nil || ext == "" {
		content, err = frontend.ReadFile(prefix + "/index.html")
		if err != nil {
			return err
		}
		c.Header("Content-Type", "text/html; charset=utf-8")
		// Add security headers for HTML content
		c.Header("X-Content-Type-Options", "nosniff")
		c.Data(http.StatusOK, "text/html; charset=utf-8", content)
		return nil
	}

	// For actual files, set the correct MIME type
	var mimeType string
	switch ext {
	case ".js":
		mimeType = "application/javascript; charset=utf-8"
	case ".css":
		mimeType = "text/css; charset=utf-8"
	case ".html":
		mimeType = "text/html; charset=utf-8"
	case ".json":
		mimeType = "application/json; charset=utf-8"
	case ".png":
		mimeType = "image/png"
	case ".svg":
		mimeType = "image/svg+xml"
	default:
		mimeType = mime.TypeByExtension(ext)
		if mimeType == "" {
			// Try to detect content type from the content itself
			mimeType = http.DetectContentType(content)
		}
	}

	// Set security headers for all responses
	c.Header("X-Content-Type-Options", "nosniff")
	c.Data(http.StatusOK, mimeType, content)
	return nil
}

//go:embed frontend/build/* frontend/static/*
var frontend embed.FS

type Note struct {
	ID        string    `json:"id" gorm:"primaryKey"`
	Title     string    `json:"title" gorm:"not null"`
	Content   string    `json:"content" gorm:"not null"`
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

var db *gorm.DB

func main() {
	var err error
	db, err = gorm.Open(sqlite.Open("notes.db"), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	// Auto migrate the schema
	if err := db.AutoMigrate(&Note{}); err != nil {
		log.Fatal(err)
	}

	// Create Gin router
	r := gin.Default()

	// API routes
	api := r.Group("/api")
	{
		notes := api.Group("/notes")
		{
			notes.GET("", handleGetNotes)
			notes.POST("", handleCreateNote)
			notes.GET("/:id", handleGetNote)
			notes.PUT("/:id", handleUpdateNote)
			notes.DELETE("/:id", handleDeleteNote)
		}

		api.POST("/test/reset", handleReset)
	}

	// Serve frontend
	r.NoRoute(handleFrontend)

	log.Printf("INFO: Server starting on http://localhost:3000")
	log.Fatal(r.Run(":3000"))
}

func handleGetNotes(c *gin.Context) {
	var notes []Note
	if err := db.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
	}

	c.JSON(http.StatusOK, notes)
}

func handleCreateNote(c *gin.Context) {
	var note Note
	if err := c.ShouldBindJSON(&note); err != nil {
		log.Printf("ERROR: Failed to decode note: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Generate a new UUID for the note
	note.ID = uuid.New().String()

	if err := db.Create(&note).Error; err != nil {
		log.Printf("ERROR: Failed to create note: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusCreated, note)
}

func handleGetNote(c *gin.Context) {
	id := c.Param("id")
	var note Note

	if err := db.First(&note, "id = ?", id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.Status(http.StatusNotFound)
			return
		}
		log.Printf("ERROR: Failed to get note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, note)
}

func handleUpdateNote(c *gin.Context) {
	id := c.Param("id")
	var note Note

	if err := c.ShouldBindJSON(&note); err != nil {
		log.Printf("ERROR: Failed to decode note update: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if err := db.Model(&Note{}).Where("id = ?", id).Updates(map[string]interface{}{
		"title":      note.Title,
		"content":    note.Content,
		"updated_at": note.UpdatedAt,
	}).Error; err != nil {
		log.Printf("ERROR: Failed to update note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusOK)
}

func handleDeleteNote(c *gin.Context) {
	id := c.Param("id")

	if err := db.Delete(&Note{}, "id = ?", id).Error; err != nil {
		log.Printf("ERROR: Failed to delete note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusNoContent)
}

func handleReset(c *gin.Context) {
	if err := db.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&Note{}).Error; err != nil {
		log.Printf("ERROR: Failed to reset database: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.Status(http.StatusOK)
}

func handleFrontend(c *gin.Context) {
	// Don't serve API routes
	if path.Dir(c.Request.URL.Path) == "/api" {
		c.Status(http.StatusNotFound)
		return
	}

	err := serveStaticFile(c, "frontend/build")
	if err != nil { // if serveStaticFile returns an error, it has already tried to serve index.html as fallback
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
	}
}