refactor: improve slug generation and error handling in upload process

Author: novnc

handlers/paste.go

@@ -16,6 +16,50 @@ import (
 	"github.com/johnwmail/nclip/utils"
 )
 
+// Helper: generateUniqueSlug tries to generate a unique slug using batch logic
+func (h *PasteHandler) generateUniqueSlug() (string, error) {
+	batchSize := 5
+	lengths := []int{5, 6, 7}
+	var slug string
+	for _, length := range lengths {
+		candidates, err := utils.GenerateSlugBatch(batchSize, length)
+		if err != nil {
+			return "", fmt.Errorf("failed to generate slug")
+		}
+		for _, candidate := range candidates {
+			existing, err := h.store.Get(candidate)
+			if err != nil || existing == nil || existing.IsExpired() {
+				slug = candidate
+				return slug, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("failed to generate unique slug after 3 batches")
+}
+
+// Helper: parseBurnTTL parses TTL for burn-after-read
+func (h *PasteHandler) parseBurnTTL(c *gin.Context) (time.Time, error) {
+	ttlStr := c.GetHeader("X-TTL")
+	if ttlStr != "" {
+		d, err := time.ParseDuration(ttlStr)
+		minTTL := time.Hour
+		maxTTL := 7 * 24 * time.Hour
+		if utils.IsDebugEnabled() {
+			log.Printf("[DEBUG] Parsed X-TTL duration: %v (raw: %s)", d, ttlStr)
+		}
+		if err != nil || d < minTTL || d > maxTTL {
+			return time.Time{}, fmt.Errorf("X-TTL must be between 1h and 7d")
+		}
+		return time.Now().Add(d), nil
+	}
+	return time.Now().Add(h.config.DefaultTTL), nil
+}
+
+// Helper: respondError sends a JSON error response
+func respondError(c *gin.Context, status int, msg string) {
+	c.JSON(status, gin.H{"error": msg})
+}
+
 // PasteHandler handles paste-related operations
 type PasteHandler struct {
 	store             storage.PasteStore
@@ -279,94 +323,51 @@ func (h *PasteHandler) UploadBurn(c *gin.Context) {
 	var filename string
 	var err error
 
-	// Check if it's a multipart form (file upload)
-	if c.Request.Header.Get("Content-Type") != "" &&
-		strings.HasPrefix(c.Request.Header.Get("Content-Type"), "multipart/form-data") {
-
+	// Extract content
+	if c.Request.Header.Get("Content-Type") != "" && strings.HasPrefix(c.Request.Header.Get("Content-Type"), "multipart/form-data") {
 		file, header, err := c.Request.FormFile("file")
 		if err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": "No file provided"})
+			respondError(c, http.StatusBadRequest, "No file provided")
 			return
 		}
-		defer func() { _ = file.Close() }() // Ignore close errors in defer
-
+		defer func() { _ = file.Close() }()
 		filename = header.Filename
 		content, err = io.ReadAll(io.LimitReader(file, h.config.BufferSize))
 		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read file"})
+			respondError(c, http.StatusInternalServerError, "Failed to read file")
 			return
 		}
 	} else {
-		// Raw content upload
 		content, err = io.ReadAll(io.LimitReader(c.Request.Body, h.config.BufferSize))
 		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read content"})
+			respondError(c, http.StatusInternalServerError, "Failed to read content")
 			return
 		}
 	}
-
 	if len(content) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Empty content"})
+		respondError(c, http.StatusBadRequest, "Empty content")
 		return
 	}
 
-	// Generate unique slug using batch logic (lengths: 5, 6, 7)
-	batchSize := 5
-	lengths := []int{5, 6, 7}
-	var slug string
-	var lastCandidates []string
-	var lastCollisions []string
-	found := false
-	for _, length := range lengths {
-		candidates, err := utils.GenerateSlugBatch(batchSize, length)
-		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate slug"})
-			return
-		}
-		lastCandidates = candidates
-		lastCollisions = nil
-		for _, candidate := range candidates {
-			existing, err := h.store.Get(candidate)
-			if err != nil || existing == nil || existing.IsExpired() {
-				slug = candidate
-				found = true
-				break
-			} else {
-				lastCollisions = append(lastCollisions, candidate)
-			}
-		}
-		if found {
-			break
-		}
-	}
-	if !found {
-		log.Printf("[ERROR] Could not generate unique slug after 3 batches. Last candidates: %v. Collisions: %v", lastCandidates, lastCollisions)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate unique slug after 3 batches"})
+	// Generate unique slug
+	slug, err := h.generateUniqueSlug()
+	if err != nil {
+		log.Printf("[ERROR] %v", err)
+		respondError(c, http.StatusInternalServerError, err.Error())
 		return
 	}
 
 	// Detect content type
 	contentType := utils.DetectContentType(filename, content)
 
-	// Support custom TTL via X-TTL header
-	ttlStr := c.GetHeader("X-TTL")
-	var expiresAt time.Time
-	if ttlStr != "" {
-		d, err := time.ParseDuration(ttlStr)
-		minTTL := time.Hour
-		maxTTL := 7 * 24 * time.Hour
-		if utils.IsDebugEnabled() {
-			log.Printf("[DEBUG] Parsed X-TTL duration: %v (raw: %s)", d, ttlStr)
-		}
-		if err != nil || d < minTTL || d > maxTTL {
-			log.Printf("[ERROR] X-TTL out of range or invalid: %v (raw: %s)", d, ttlStr)
-			c.JSON(http.StatusBadRequest, gin.H{"error": "X-TTL must be between 1h and 7d"})
-			return
-		}
-		expiresAt = time.Now().Add(d)
-	} else {
-		expiresAt = time.Now().Add(h.config.DefaultTTL)
+	// Parse TTL
+	expiresAt, err := h.parseBurnTTL(c)
+	if err != nil {
+		log.Printf("[ERROR] %v", err)
+		respondError(c, http.StatusBadRequest, err.Error())
+		return
 	}
+
 	paste := &models.Paste{
 		ID:            slug,
 		CreatedAt:     time.Now(),
@@ -379,20 +380,19 @@ func (h *PasteHandler) UploadBurn(c *gin.Context) {
 
 	// Store content and metadata
 	if err := h.store.StoreContent(slug, content); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to store content"})
+		respondError(c, http.StatusInternalServerError, "Failed to store content")
 		return
 	}
 	if err := h.store.Store(paste); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to store metadata"})
+		respondError(c, http.StatusInternalServerError, "Failed to store metadata")
 		return
 	}
 
 	// Generate URL
 	pasteURL := h.generatePasteURL(c, slug)
 
 	// Return URL as plain text for cli tools compatibility
-	if h.isCli(c) ||
-		c.Request.Header.Get("Accept") == "text/plain" {
+	if h.isCli(c) || c.Request.Header.Get("Accept") == "text/plain" {
 		c.String(http.StatusOK, pasteURL+"\n")
 		return
 	}

utils/mime.go

@@ -7,6 +7,43 @@ import (
 	"strings"
 )
 
+// extensionMap holds common mime type to extension mappings
+var extensionMap = map[string]string{
+	"application/zip":              ".zip",
+	"application/x-zip-compressed": ".zip",
+	"application/x-zip":            ".zip",
+	"application/x-tar":            ".tar",
+	"application/tar":              ".tar",
+	"application/x-gzip":           ".gz",
+	"application/gzip":             ".gz",
+	"application/x-7z-compressed":  ".7z",
+	"application/7z":               ".7z",
+	"application/x-bzip2":          ".bz2",
+	"application/bzip2":            ".bz2",
+	"application/x-xz":             ".xz",
+	"application/xz":               ".xz",
+	"application/x-rar-compressed": ".rar",
+	"application/vnd.rar":          ".rar",
+	"application/rar":              ".rar",
+	"application/pdf":              ".pdf",
+	"image/jpeg":                   ".jpg",
+	"image/png":                    ".png",
+	"image/gif":                    ".gif",
+	"image/webp":                   ".webp",
+	"image/svg+xml":                ".svg",
+	"application/octet-stream":     ".bin",
+	"application/x-binary":         ".bin",
+	"application/bin":              ".bin",
+}
+
+func extensionByMimeMap(mimeType string) string {
+	ext, ok := extensionMap[strings.ToLower(mimeType)]
+	if ok {
+		return ext
+	}
+	return ""
+}
+
 // DetectContentType attempts to detect the MIME type of content
 // It first tries to detect from the filename, then from the content itself
 func DetectContentType(filename string, content []byte) string {
@@ -53,50 +90,11 @@ func ExtensionByMime(mimeType string) string {
 	if mimeType == "" {
 		return ""
 	}
-
 	if base, _, err := mime.ParseMediaType(mimeType); err == nil {
 		mimeType = base
 	}
-
 	if exts, _ := mime.ExtensionsByType(mimeType); len(exts) > 0 && exts[0] != "" {
 		return exts[0]
 	}
-
-	switch strings.ToLower(mimeType) {
-	case "application/zip", "application/x-zip-compressed", "application/x-zip":
-		return ".zip"
-	case "application/x-tar", "application/tar":
-		return ".tar"
-	case "application/x-gzip", "application/gzip":
-		return ".gz"
-	case "application/x-7z-compressed", "application/7z":
-		return ".7z"
-	case "application/x-bzip2", "application/bzip2":
-		return ".bz2"
-	case "application/x-xz", "application/xz":
-		return ".xz"
-	case "application/x-rar-compressed", "application/vnd.rar", "application/rar":
-		return ".rar"
-	case "application/pdf":
-		return ".pdf"
-	case "image/jpeg":
-		return ".jpg"
-	case "image/png":
-		return ".png"
-	case "image/gif":
-		return ".gif"
-	case "image/webp":
-		return ".webp"
-	case "image/svg+xml":
-		return ".svg"
-	case "application/octet-stream", "application/x-binary", "application/bin":
-		return ".bin"
-	}
-
-	// fallback: only treat as binary for true binary types
-	lower := strings.ToLower(mimeType)
-	if lower == "application/octet-stream" || lower == "application/x-binary" || lower == "application/bin" {
-		return ".bin"
-	}
-	return ""
+	return extensionByMimeMap(mimeType)
 }