MVC Architecture #

// model/article.go — Model: domain entity + business rules
package model

import (
	"context"
	"errors"
	"strings"
	"time"
)

type Article struct {
	ID          int64
	Title       string
	Body        string
	AuthorID    int64
	PublishedAt *time.Time
	CreatedAt   time.Time
}

// Publish publishes the article — business rules live inside the model
func (a *Article) Publish() error {
	if strings.TrimSpace(a.Title) == "" {
		return errors.New("article title must not be empty")
	}
	if strings.TrimSpace(a.Body) == "" {
		return errors.New("article body must not be empty")
	}
	if a.PublishedAt != nil {
		return errors.New("article is already published")
	}
	now := time.Now()
	a.PublishedAt = &now
	return nil
}

func (a *Article) IsPublished() bool {
	return a.PublishedAt != nil
}

// ArticleRepository is the interface for data access
type ArticleRepository interface {
	FindByID(ctx context.Context, id int64) (*Article, error)
	FindAll(ctx context.Context) ([]*Article, error)
	FindPublished(ctx context.Context) ([]*Article, error)
	Save(ctx context.Context, article *Article) error
	Delete(ctx context.Context, id int64) error
}

// service/article_service.go — Service Layer (part of the Model)
// Orchestrates use cases using domain entities
package service

import (
	"context"
	"errors"

	"myapp/model"
)

// ArticleService is the application service — part of the "M" in MVC
type ArticleService struct {
	repo model.ArticleRepository
}

func NewArticleService(repo model.ArticleRepository) *ArticleService {
	return &ArticleService{repo: repo}
}

type CreateArticleInput struct {
	Title    string
	Body     string
	AuthorID int64
	Publish  bool
}

func (s *ArticleService) Create(ctx context.Context, input CreateArticleInput) (*model.Article, error) {
	article := &model.Article{
		Title:    input.Title,
		Body:     input.Body,
		AuthorID: input.AuthorID,
	}

	if input.Publish {
		if err := article.Publish(); err != nil {
			return nil, err
		}
	}

	if err := s.repo.Save(ctx, article); err != nil {
		return nil, err
	}
	return article, nil
}

func (s *ArticleService) FindByID(ctx context.Context, id int64) (*model.Article, error) {
	if id <= 0 {
		return nil, errors.New("invalid ID")
	}
	return s.repo.FindByID(ctx, id)
}

func (s *ArticleService) FindPublished(ctx context.Context) ([]*model.Article, error) {
	return s.repo.FindPublished(ctx)
}

func (s *ArticleService) Publish(ctx context.Context, id int64) (*model.Article, error) {
	article, err := s.repo.FindByID(ctx, id)
	if err != nil {
		return nil, err
	}
	if err := article.Publish(); err != nil {
		return nil, err
	}
	if err := s.repo.Save(ctx, article); err != nil {
		return nil, err
	}
	return article, nil
}

// controller/article_controller.go — Controller: coordinator between Model and View
package controller

import (
	"html/template"
	"net/http"
	"strconv"

	"myapp/service"
)

// ArticleController handles all HTTP requests related to articles
// ✓ Thin — only parses input, delegates to the service, renders views
type ArticleController struct {
	articleSvc *service.ArticleService
	templates  *template.Template
}

func NewArticleController(svc *service.ArticleService, tmpl *template.Template) *ArticleController {
	return &ArticleController{articleSvc: svc, templates: tmpl}
}

// Index displays all published articles
func (c *ArticleController) Index(w http.ResponseWriter, r *http.Request) {
	articles, err := c.articleSvc.FindPublished(r.Context())
	if err != nil {
		http.Error(w, "failed to fetch articles", http.StatusInternalServerError)
		return
	}

	// Render the view with data from the model
	if err := c.templates.ExecuteTemplate(w, "articles/index.html", map[string]interface{}{
		"Articles": articles,
		"Title":    "All Articles",
	}); err != nil {
		http.Error(w, "failed to render page", http.StatusInternalServerError)
	}
}

// Show displays one article by ID
func (c *ArticleController) Show(w http.ResponseWriter, r *http.Request) {
	// Parse the ID from the URL path
	idStr := r.PathValue("id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		http.Error(w, "invalid ID", http.StatusBadRequest)
		return
	}

	article, err := c.articleSvc.FindByID(r.Context(), id)
	if err != nil {
		http.Error(w, "article not found", http.StatusNotFound)
		return
	}

	c.templates.ExecuteTemplate(w, "articles/show.html", map[string]interface{}{
		"Article": article,
		"Title":   article.Title,
	})
}

// New displays the form for creating a new article
func (c *ArticleController) New(w http.ResponseWriter, r *http.Request) {
	c.templates.ExecuteTemplate(w, "articles/new.html", map[string]interface{}{
		"Title": "New Article",
	})
}

// Create processes the form submission to create an article
func (c *ArticleController) Create(w http.ResponseWriter, r *http.Request) {
	if err := r.ParseForm(); err != nil {
		http.Error(w, "invalid form", http.StatusBadRequest)
		return
	}

	// Parse input from the form
	title := r.FormValue("title")
	body := r.FormValue("body")
	publish := r.FormValue("publish") == "true"

	// Minimal input validation in the controller (format, not business rules)
	if title == "" || body == "" {
		c.templates.ExecuteTemplate(w, "articles/new.html", map[string]interface{}{
			"Title":  "New Article",
			"Error":  "Title and body are required",
			"Values": map[string]string{"title": title, "body": body},
		})
		return
	}

	// Delegate to the service — business validation lives there
	article, err := c.articleSvc.Create(r.Context(), service.CreateArticleInput{
		Title:    title,
		Body:     body,
		AuthorID: getUserIDFromSession(r),
		Publish:  publish,
	})
	if err != nil {
		c.templates.ExecuteTemplate(w, "articles/new.html", map[string]interface{}{
			"Title":  "New Article",
			"Error":  err.Error(),
			"Values": map[string]string{"title": title, "body": body},
		})
		return
	}

	// Redirect to the newly created article page
	http.Redirect(w, r, "/articles/"+strconv.FormatInt(article.ID, 10), http.StatusSeeOther)
}

// router/router.go — routing connecting URLs to Controller methods
package router

import (
	"net/http"

	"myapp/controller"
)

func Setup(articleCtrl *controller.ArticleController) http.Handler {
	mux := http.NewServeMux()

	// Article routes
	mux.HandleFunc("GET /articles", articleCtrl.Index)
	mux.HandleFunc("GET /articles/new", articleCtrl.New)
	mux.HandleFunc("POST /articles", articleCtrl.Create)
	mux.HandleFunc("GET /articles/{id}", articleCtrl.Show)

	return mux
}

// controller/api/article_api_controller.go — Controller for the JSON API
package api

import (
	"encoding/json"
	"net/http"
	"strconv"
	"time"

	"myapp/service"
)

// ArticleResponse is the View Model — a DTO optimized for JSON responses
// ✓ Different from the domain entity — only fields relevant to the client
type ArticleResponse struct {
	ID          int64      `json:"id"`
	Title       string     `json:"title"`
	Body        string     `json:"body"`
	IsPublished bool       `json:"is_published"`
	PublishedAt *time.Time `json:"published_at,omitempty"`
	CreatedAt   time.Time  `json:"created_at"`
}

// ArticleListResponse is the wrapper for list responses
type ArticleListResponse struct {
	Data  []*ArticleResponse `json:"data"`
	Total int                `json:"total"`
}

type ArticleAPIController struct {
	articleSvc *service.ArticleService
}

func NewArticleAPIController(svc *service.ArticleService) *ArticleAPIController {
	return &ArticleAPIController{articleSvc: svc}
}

func (c *ArticleAPIController) Index(w http.ResponseWriter, r *http.Request) {
	articles, err := c.articleSvc.FindPublished(r.Context())
	if err != nil {
		writeError(w, http.StatusInternalServerError, "failed to fetch articles")
		return
	}

	// Map domain objects to View Models (response DTOs)
	responses := make([]*ArticleResponse, len(articles))
	for i, a := range articles {
		responses[i] = toArticleResponse(a)
	}

	writeJSON(w, http.StatusOK, ArticleListResponse{
		Data:  responses,
		Total: len(responses),
	})
}

func (c *ArticleAPIController) Show(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		writeError(w, http.StatusBadRequest, "invalid ID")
		return
	}

	article, err := c.articleSvc.FindByID(r.Context(), id)
	if err != nil {
		writeError(w, http.StatusNotFound, "article not found")
		return
	}

	writeJSON(w, http.StatusOK, toArticleResponse(article))
}

type CreateArticleRequestBody struct {
	Title   string `json:"title"`
	Body    string `json:"body"`
	Publish bool   `json:"publish"`
}

func (c *ArticleAPIController) Create(w http.ResponseWriter, r *http.Request) {
	var req CreateArticleRequestBody
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body")
		return
	}

	// Minimal format validation in the controller
	if req.Title == "" {
		writeError(w, http.StatusBadRequest, "title is required")
		return
	}

	article, err := c.articleSvc.Create(r.Context(), service.CreateArticleInput{
		Title:    req.Title,
		Body:     req.Body,
		AuthorID: getAuthorIDFromToken(r),
		Publish:  req.Publish,
	})
	if err != nil {
		writeError(w, http.StatusUnprocessableEntity, err.Error())
		return
	}

	writeJSON(w, http.StatusCreated, toArticleResponse(article))
}

// Helper functions — the "View" in a JSON API
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 writeError(w http.ResponseWriter, status int, message string) {
	writeJSON(w, status, map[string]string{"error": message})
}

// ✗ Fat Controller — business logic in the handler
func (c *ArticleController) Publish(w http.ResponseWriter, r *http.Request) {
	id, _ := strconv.ParseInt(r.PathValue("id"), 10, 64)

	// ✗ Business logic in the controller
	article, _ := c.db.QueryRow("SELECT * FROM articles WHERE id = $1", id)

	if article.PublishedAt != nil { // ✗ business rule in the controller
		http.Error(w, "article is already published", 400)
		return
	}
	if article.Title == "" { // ✗ business validation in the controller
		http.Error(w, "title is missing", 400)
		return
	}

	now := time.Now()
	article.PublishedAt = &now
	c.db.Exec("UPDATE articles SET published_at = $1 WHERE id = $2", now, id)

	// ✗ side effect (email) in the controller
	c.mailer.Send(article.AuthorEmail, "Article Published", "...")

	writeJSON(w, 200, article)
}

// ✓ Thin Controller — delegate to the service
func (c *ArticleController) Publish(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		writeError(w, 400, "invalid ID") // ✓ only format validation
		return
	}

	// ✓ delegate all business logic to the service
	article, err := c.articleSvc.Publish(r.Context(), id)
	if err != nil {
		writeError(w, 422, err.Error())
		return
	}

	writeJSON(w, 200, toArticleResponse(article))
}

// ✗ God Controller — one controller for everything
type AppController struct{}

func (c *AppController) HandleEverything(w http.ResponseWriter, r *http.Request) {
	// ✗ switch on the path for all endpoints
	switch r.URL.Path {
	case "/users":
		// handle users...
	case "/articles":
		// handle articles + business logic here
	case "/payments":
		// handle payments + calculations here
	}
}

// ✓ One controller per domain
type UserController struct{ userSvc *service.UserService }
type ArticleController struct{ articleSvc *service.ArticleService }
type PaymentController struct{ paymentSvc *service.PaymentService }

// ✗ Business logic in the View (template)
// articles/show.html
// {{ if gt (len .Article.Body) 100 }} ... {{ end }} — business rule in the template

// ✓ Calculate in the controller/service, send a flag to the view
// Controller:
// data["IsLongArticle"] = len(article.Body) > 100
// Template:
// {{ if .IsLongArticle }} ... {{ end }}

// ✗ View accessing the database directly (Active Record anti-pattern in templates)
// articles/show.html
// {{ range .Article.GetComments }} ... {{ end }}
// — GetComments() in the model runs DB queries while the template renders

// ✓ The controller fetches all needed data before rendering
func (c *ArticleController) Show(w http.ResponseWriter, r *http.Request) {
	article, _ := c.articleSvc.FindByID(r.Context(), id)
	comments, _ := c.commentSvc.FindByArticle(r.Context(), id) // ✓ fetch in the controller
	c.templates.ExecuteTemplate(w, "articles/show.html", map[string]interface{}{
		"Article":  article,
		"Comments": comments, // ✓ all data ready, the template only renders
	})
}

// ✗ The Model knowing about HTTP or the View
type Article struct{}

func (a *Article) ToHTML() string { // ✗ the Model must not know about HTML
	return "<h1>" + a.Title + "</h1>"
}

func (a *Article) GetHTTPStatusCode() int { // ✗ the Model must not know about HTTP
	if a.IsPublished() {
		return 200
	}
	return 404
}

// ✓ The Model only contains data and business rules
type Article struct {
	Title string
	Body  string
}

func (a *Article) IsPublished() bool { return a.PublishedAt != nil } // ✓
func (a *Article) Publish() error    { /* business rule */ return nil } // ✓