REST API ডিজাইন

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/google/uuid"
)

// --- Domain Types ---
type Post struct {
	ID        string   `json:"id"`
	Slug      string   `json:"slug"`
	Title     string   `json:"title"`
	Body      string   `json:"body"`
	AuthorID  string   `json:"authorId"`
	Tags      []string `json:"tags"`
	Published bool     `json:"published"`
	CreatedAt string   `json:"createdAt"`
	UpdatedAt string   `json:"updatedAt"`
}

type PaginatedResponse struct {
	Data       interface{} `json:"data"`
	Pagination Pagination  `json:"pagination"`
}

type Pagination struct {
	Cursor  *string `json:"cursor"`
	HasMore bool    `json:"hasMore"`
	Total   int     `json:"total"`
}

type ValidationError struct {
	Field   string `json:"field"`
	Message string `json:"message"`
}

// --- Store ---
type PostStore struct {
	mu    sync.RWMutex
	posts map[string]Post
}

func NewPostStore() *PostStore {
	s := &PostStore{posts: make(map[string]Post)}
	// Seed data
	for i := 1; i <= 50; i++ {
		id := uuid.New().String()
		tags := []string{"frontend", "react"}
		if i%2 == 0 {
			tags = []string{"system-design", "backend"}
		}
		s.posts[id] = Post{
			ID:        id,
			Slug:      fmt.Sprintf("post-%d", i),
			Title:     fmt.Sprintf("Blog Post %d", i),
			Body:      fmt.Sprintf("Content of post %d about system design.", i),
			AuthorID:  fmt.Sprintf("user-%d", (i%5)+1),
			Tags:      tags,
			Published: i%3 != 0,
			CreatedAt: time.Now().Add(-time.Duration(i) * 24 * time.Hour).UTC().Format(time.RFC3339),
			UpdatedAt: time.Now().Add(-time.Duration(i) * 12 * time.Hour).UTC().Format(time.RFC3339),
		}
	}
	return s
}

// --- Validation ---
func validateCreatePost(data map[string]interface{}, store *PostStore) []ValidationError {
	var errs []ValidationError

	title, _ := data["title"].(string)
	if len(strings.TrimSpace(title)) < 3 {
		errs = append(errs, ValidationError{Field: "title", Message: "Must be at least 3 characters"})
	}
	if len(title) > 200 {
		errs = append(errs, ValidationError{Field: "title", Message: "Must be at most 200 characters"})
	}

	body, _ := data["body"].(string)
	if len(strings.TrimSpace(body)) < 10 {
		errs = append(errs, ValidationError{Field: "body", Message: "Must be at least 10 characters"})
	}

	authorID, _ := data["authorId"].(string)
	if authorID == "" {
		errs = append(errs, ValidationError{Field: "authorId", Message: "Required"})
	}

	// Check slug uniqueness
	if title != "" {
		slug := slugify(title)
		store.mu.RLock()
		for _, p := range store.posts {
			if p.Slug == slug {
				errs = append(errs, ValidationError{Field: "title", Message: "A post with this title already exists"})
				break
			}
		}
		store.mu.RUnlock()
	}

	return errs
}

var slugRegex = regexp.MustCompile(`[^a-z0-9]+`)

func slugify(text string) string {
	slug := slugRegex.ReplaceAllString(strings.ToLower(text), "-")
	return strings.Trim(slug, "-")
}

// --- Handlers ---
type PostHandler struct {
	store *PostStore
}

func writeJSON(w http.ResponseWriter, status int, data interface{}) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(data)
}

func (h *PostHandler) List(w http.ResponseWriter, r *http.Request) {
	q := r.URL.Query()

	limit, _ := strconv.Atoi(q.Get("limit"))
	if limit <= 0 || limit > 100 {
		limit = 20
	}
	cursor := q.Get("cursor")
	tag := q.Get("tag")
	authorID := q.Get("author_id")
	published := q.Get("published")

	h.store.mu.RLock()
	items := make([]Post, 0, len(h.store.posts))
	for _, p := range h.store.posts {
		if tag != "" && !contains(p.Tags, tag) {
			continue
		}
		if authorID != "" && p.AuthorID != authorID {
			continue
		}
		if published != "" {
			pub := published == "true"
			if p.Published != pub {
				continue
			}
		}
		items = append(items, p)
	}
	h.store.mu.RUnlock()

	// Sort by createdAt descending
	sort.Slice(items, func(i, j int) bool {
		return items[i].CreatedAt > items[j].CreatedAt
	})

	total := len(items)

	// Cursor-based pagination
	if cursor != "" {
		idx := -1
		for i, p := range items {
			if p.ID == cursor {
				idx = i
				break
			}
		}
		if idx >= 0 {
			items = items[idx+1:]
		}
	}

	hasMore := len(items) > limit
	if len(items) > limit {
		items = items[:limit]
	}

	var nextCursor *string
	if hasMore && len(items) > 0 {
		c := items[len(items)-1].ID
		nextCursor = &c
	}

	writeJSON(w, http.StatusOK, PaginatedResponse{
		Data:       items,
		Pagination: Pagination{Cursor: nextCursor, HasMore: hasMore, Total: total},
	})
}

func (h *PostHandler) Create(w http.ResponseWriter, r *http.Request) {
	var data map[string]interface{}
	if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&data); err != nil {
		writeJSON(w, http.StatusBadRequest, map[string]interface{}{"error": "Invalid JSON", "status": 400})
		return
	}

	errs := validateCreatePost(data, h.store)
	if len(errs) > 0 {
		writeJSON(w, 422, map[string]interface{}{"errors": errs, "status": 422})
		return
	}

	now := time.Now().UTC().Format(time.RFC3339)
	title := strings.TrimSpace(data["title"].(string))

	tags := []string{}
	if t, ok := data["tags"].([]interface{}); ok {
		for _, v := range t {
			if s, ok := v.(string); ok {
				tags = append(tags, s)
			}
		}
	}

	post := Post{
		ID:        uuid.New().String(),
		Slug:      slugify(title),
		Title:     title,
		Body:      strings.TrimSpace(data["body"].(string)),
		AuthorID:  data["authorId"].(string),
		Tags:      tags,
		Published: false,
		CreatedAt: now,
		UpdatedAt: now,
	}

	h.store.mu.Lock()
	h.store.posts[post.ID] = post
	h.store.mu.Unlock()

	w.Header().Set("Location", "/api/posts/"+post.Slug)
	writeJSON(w, http.StatusCreated, map[string]interface{}{"data": post, "status": 201})
}

func (h *PostHandler) Get(w http.ResponseWriter, _ *http.Request, identifier string) {
	h.store.mu.RLock()
	defer h.store.mu.RUnlock()

	// Lookup by ID or slug
	if post, ok := h.store.posts[identifier]; ok {
		writeJSON(w, http.StatusOK, map[string]interface{}{"data": post, "status": 200})
		return
	}
	for _, p := range h.store.posts {
		if p.Slug == identifier {
			writeJSON(w, http.StatusOK, map[string]interface{}{"data": p, "status": 200})
			return
		}
	}
	writeJSON(w, http.StatusNotFound, map[string]interface{}{"error": "Post not found", "status": 404})
}

func (h *PostHandler) Delete(w http.ResponseWriter, _ *http.Request, id string) {
	h.store.mu.Lock()
	defer h.store.mu.Unlock()
	if _, ok := h.store.posts[id]; !ok {
		writeJSON(w, http.StatusNotFound, map[string]interface{}{"error": "Post not found", "status": 404})
		return
	}
	delete(h.store.posts, id)
	w.WriteHeader(http.StatusNoContent)
}

func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}

// --- Router ---
func main() {
	store := NewPostStore()
	handler := &PostHandler{store: store}
	postIDPattern := regexp.MustCompile(`^/api/posts/(.+)$`)

	mux := http.NewServeMux()

	mux.HandleFunc("/api/posts", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			handler.List(w, r)
		case http.MethodPost:
			handler.Create(w, r)
		default:
			writeJSON(w, 405, map[string]string{"error": "Method not allowed"})
		}
	})

	mux.HandleFunc("/api/posts/", func(w http.ResponseWriter, r *http.Request) {
		m := postIDPattern.FindStringSubmatch(r.URL.Path)
		if m == nil {
			writeJSON(w, 404, map[string]string{"error": "Not found"})
			return
		}
		id := m[1]
		switch r.Method {
		case http.MethodGet:
			handler.Get(w, r, id)
		case http.MethodDelete:
			handler.Delete(w, r, id)
		default:
			writeJSON(w, 405, map[string]string{"error": "Method not allowed"})
		}
	})

	log.Println("API running on http://localhost:3000")
	log.Fatal(http.ListenAndServe(":3000", mux))
}