Layered Architecture #

// domain/employee.go
package domain

import (
	"errors"
	"regexp"
	"time"
)

type EmployeeID string
type DepartmentID string

// Employee is an entity with business rules
// ✓ No imports from databases, HTTP, or any framework
type Employee struct {
	id           EmployeeID
	fullName     string
	email        string
	departmentID DepartmentID
	salary       int64 // in the smallest unit (cents/rupiah)
	joinDate     time.Time
	isActive     bool
}

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

// NewEmployee enforces business invariants at creation
func NewEmployee(fullName, email string, departmentID DepartmentID, salary int64) (*Employee, error) {
	if fullName == "" {
		return nil, errors.New("employee name must not be empty")
	}
	if !emailRegex.MatchString(email) {
		return nil, errors.New("invalid email format")
	}
	if salary < 0 {
		return nil, errors.New("salary must not be negative")
	}

	return &Employee{
		id:           EmployeeID(generateID()),
		fullName:     fullName,
		email:        email,
		departmentID: departmentID,
		salary:       salary,
		joinDate:     time.Now(),
		isActive:     true,
	}, nil
}

// Promote raises the salary with business validation
func (e *Employee) Promote(newSalary int64) error {
	if newSalary <= e.salary {
		return errors.New("new salary must be greater than the current salary")
	}
	e.salary = newSalary
	return nil
}

// Resign deactivates the employee
func (e *Employee) Resign() error {
	if !e.isActive {
		return errors.New("employee is already inactive")
	}
	e.isActive = false
	return nil
}

// Transfer moves the employee to another department
func (e *Employee) Transfer(newDeptID DepartmentID) error {
	if e.departmentID == newDeptID {
		return errors.New("employee is already in that department")
	}
	e.departmentID = newDeptID
	return nil
}

// Getters
func (e *Employee) ID() EmployeeID           { return e.id }
func (e *Employee) FullName() string          { return e.fullName }
func (e *Employee) Email() string             { return e.email }
func (e *Employee) DepartmentID() DepartmentID { return e.departmentID }
func (e *Employee) Salary() int64             { return e.salary }
func (e *Employee) JoinDate() time.Time       { return e.joinDate }
func (e *Employee) IsActive() bool            { return e.isActive }

// EmployeeRepository is the interface defined in the domain
// ✓ The domain defines the needs — infrastructure implements them
type EmployeeRepository interface {
	Save(employee *Employee) error
	FindByID(id EmployeeID) (*Employee, error)
	FindByDepartment(deptID DepartmentID) ([]*Employee, error)
	FindAllActive() ([]*Employee, error)
}

// application/employee_service.go
package application

import (
	"errors"
	"fmt"

	"myapp/domain"
)

// EmployeeService orchestrates employee use cases
// ✓ No HTTP or database details here — only business flows
type EmployeeService struct {
	employeeRepo domain.EmployeeRepository
}

func NewEmployeeService(employeeRepo domain.EmployeeRepository) *EmployeeService {
	return &EmployeeService{employeeRepo: employeeRepo}
}

// CreateEmployeeInput is the input DTO for creating an employee
type CreateEmployeeInput struct {
	FullName     string
	Email        string
	DepartmentID string
	Salary       int64
}

// EmployeeOutput is the output DTO used for all responses
type EmployeeOutput struct {
	ID           string
	FullName     string
	Email        string
	DepartmentID string
	Salary       int64
	JoinDate     string
	IsActive     bool
}

func toOutput(e *domain.Employee) *EmployeeOutput {
	return &EmployeeOutput{
		ID:           string(e.ID()),
		FullName:     e.FullName(),
		Email:        e.Email(),
		DepartmentID: string(e.DepartmentID()),
		Salary:       e.Salary(),
		JoinDate:     e.JoinDate().Format("2006-01-02"),
		IsActive:     e.IsActive(),
	}
}

// CreateEmployee creates a new employee
func (s *EmployeeService) CreateEmployee(input CreateEmployeeInput) (*EmployeeOutput, error) {
	employee, err := domain.NewEmployee(
		input.FullName,
		input.Email,
		domain.DepartmentID(input.DepartmentID),
		input.Salary,
	)
	if err != nil {
		return nil, err
	}

	if err := s.employeeRepo.Save(employee); err != nil {
		return nil, fmt.Errorf("failed to save employee: %w", err)
	}

	return toOutput(employee), nil
}

// PromoteEmployee raises an employee's salary
func (s *EmployeeService) PromoteEmployee(employeeID string, newSalary int64) (*EmployeeOutput, error) {
	employee, err := s.employeeRepo.FindByID(domain.EmployeeID(employeeID))
	if err != nil {
		return nil, err
	}

	// Delegate to the domain entity — the service contains no business logic
	if err := employee.Promote(newSalary); err != nil {
		return nil, err
	}

	if err := s.employeeRepo.Save(employee); err != nil {
		return nil, fmt.Errorf("failed to save changes: %w", err)
	}

	return toOutput(employee), nil
}

// ResignEmployee processes an employee's resignation
func (s *EmployeeService) ResignEmployee(employeeID string) error {
	employee, err := s.employeeRepo.FindByID(domain.EmployeeID(employeeID))
	if err != nil {
		return err
	}

	if err := employee.Resign(); err != nil {
		return err
	}

	return s.employeeRepo.Save(employee)
}

// TransferEmployee moves an employee to another department
func (s *EmployeeService) TransferEmployee(employeeID, newDeptID string) (*EmployeeOutput, error) {
	employee, err := s.employeeRepo.FindByID(domain.EmployeeID(employeeID))
	if err != nil {
		return nil, err
	}

	if err := employee.Transfer(domain.DepartmentID(newDeptID)); err != nil {
		return nil, err
	}

	if err := s.employeeRepo.Save(employee); err != nil {
		return nil, err
	}

	return toOutput(employee), nil
}

// GetDepartmentEmployees fetches all employees in one department
func (s *EmployeeService) GetDepartmentEmployees(deptID string) ([]*EmployeeOutput, error) {
	employees, err := s.employeeRepo.FindByDepartment(domain.DepartmentID(deptID))
	if err != nil {
		return nil, err
	}

	outputs := make([]*EmployeeOutput, len(employees))
	for i, emp := range employees {
		outputs[i] = toOutput(emp)
	}
	return outputs, nil
}

// presentation/employee_handler.go
package presentation

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

	"myapp/application"
)

// EmployeeHandler is an HTTP handler — the presentation layer
// ✓ Only handles request parsing, delegation to services, and response formatting
type EmployeeHandler struct {
	employeeService *application.EmployeeService
}

func NewEmployeeHandler(svc *application.EmployeeService) *EmployeeHandler {
	return &EmployeeHandler{employeeService: svc}
}

type createEmployeeRequest struct {
	FullName     string `json:"full_name"`
	Email        string `json:"email"`
	DepartmentID string `json:"department_id"`
	Salary       int64  `json:"salary"`
}

func (h *EmployeeHandler) CreateEmployee(w http.ResponseWriter, r *http.Request) {
	var req createEmployeeRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request")
		return
	}

	// Format validation belongs here — not business validation
	if req.FullName == "" || req.Email == "" || req.DepartmentID == "" {
		writeError(w, http.StatusBadRequest, "all fields are required")
		return
	}

	output, err := h.employeeService.CreateEmployee(application.CreateEmployeeInput{
		FullName:     req.FullName,
		Email:        req.Email,
		DepartmentID: req.DepartmentID,
		Salary:       req.Salary,
	})
	if err != nil {
		writeError(w, http.StatusUnprocessableEntity, err.Error())
		return
	}

	writeJSON(w, http.StatusCreated, output)
}

type promoteRequest struct {
	NewSalary int64 `json:"new_salary"`
}

func (h *EmployeeHandler) PromoteEmployee(w http.ResponseWriter, r *http.Request) {
	employeeID := r.PathValue("id")

	var req promoteRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request")
		return
	}

	output, err := h.employeeService.PromoteEmployee(employeeID, req.NewSalary)
	if err != nil {
		writeError(w, http.StatusUnprocessableEntity, err.Error())
		return
	}

	writeJSON(w, http.StatusOK, output)
}

func (h *EmployeeHandler) ResignEmployee(w http.ResponseWriter, r *http.Request) {
	employeeID := r.PathValue("id")

	if err := h.employeeService.ResignEmployee(employeeID); err != nil {
		writeError(w, http.StatusUnprocessableEntity, err.Error())
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

func (h *EmployeeHandler) GetDepartmentEmployees(w http.ResponseWriter, r *http.Request) {
	deptID := r.PathValue("dept_id")

	outputs, err := h.employeeService.GetDepartmentEmployees(deptID)
	if err != nil {
		writeError(w, http.StatusInternalServerError, "failed to fetch employee data")
		return
	}

	writeJSON(w, http.StatusOK, outputs)
}

func writeJSON(w http.ResponseWriter, status int, data any) {
	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})
}

// infrastructure/postgres_employee_repository.go
package infrastructure

import (
	"database/sql"
	"fmt"
	"time"

	"myapp/domain"
)

// PostgresEmployeeRepository implements domain.EmployeeRepository
type PostgresEmployeeRepository struct {
	db *sql.DB
}

var _ domain.EmployeeRepository = (*PostgresEmployeeRepository)(nil)

func NewPostgresEmployeeRepository(db *sql.DB) *PostgresEmployeeRepository {
	return &PostgresEmployeeRepository{db: db}
}

// employeeRow is the database model — separated from the domain entity
type employeeRow struct {
	ID           string
	FullName     string
	Email        string
	DepartmentID string
	Salary       int64
	JoinDate     time.Time
	IsActive     bool
}

func (r *employeeRow) toDomain() *domain.Employee {
	return domain.ReconstructEmployee(
		domain.EmployeeID(r.ID),
		r.FullName,
		r.Email,
		domain.DepartmentID(r.DepartmentID),
		r.Salary,
		r.JoinDate,
		r.IsActive,
	)
}

func (r *PostgresEmployeeRepository) Save(emp *domain.Employee) error {
	_, err := r.db.Exec(
		`INSERT INTO employees (id, full_name, email, department_id, salary, join_date, is_active)
		 VALUES ($1, $2, $3, $4, $5, $6, $7)
		 ON CONFLICT (id) DO UPDATE
		 SET full_name = $2, email = $3, department_id = $4,
		     salary = $5, is_active = $7`,
		string(emp.ID()), emp.FullName(), emp.Email(),
		string(emp.DepartmentID()), emp.Salary(),
		emp.JoinDate(), emp.IsActive(),
	)
	if err != nil {
		return fmt.Errorf("failed to save employee: %w", err)
	}
	return nil
}

func (r *PostgresEmployeeRepository) FindByID(id domain.EmployeeID) (*domain.Employee, error) {
	row := &employeeRow{}
	err := r.db.QueryRow(
		`SELECT id, full_name, email, department_id, salary, join_date, is_active
		 FROM employees WHERE id = $1`,
		string(id),
	).Scan(
		&row.ID, &row.FullName, &row.Email,
		&row.DepartmentID, &row.Salary,
		&row.JoinDate, &row.IsActive,
	)
	if err == sql.ErrNoRows {
		return nil, fmt.Errorf("employee not found: %s", id)
	}
	if err != nil {
		return nil, fmt.Errorf("failed to read employee: %w", err)
	}
	return row.toDomain(), nil
}

func (r *PostgresEmployeeRepository) FindByDepartment(deptID domain.DepartmentID) ([]*domain.Employee, error) {
	rows, err := r.db.Query(
		`SELECT id, full_name, email, department_id, salary, join_date, is_active
		 FROM employees WHERE department_id = $1 AND is_active = TRUE`,
		string(deptID),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to query employees: %w", err)
	}
	defer rows.Close()

	var employees []*domain.Employee
	for rows.Next() {
		row := &employeeRow{}
		if err := rows.Scan(
			&row.ID, &row.FullName, &row.Email,
			&row.DepartmentID, &row.Salary,
			&row.JoinDate, &row.IsActive,
		); err != nil {
			return nil, err
		}
		employees = append(employees, row.toDomain())
	}
	return employees, nil
}

func (r *PostgresEmployeeRepository) FindAllActive() ([]*domain.Employee, error) {
	// implementation similar to FindByDepartment...
	return nil, nil
}

// ✗ Anemic Domain Model — entity is only data, all logic in services
type Employee struct { // only getters/setters
    ID       string
    FullName string
    Salary   int64
    IsActive bool
}

type EmployeeService struct {
    repo EmployeeRepository
}

func (s *EmployeeService) Promote(id string, newSalary int64) error {
    emp, _ := s.repo.FindByID(id)
    // ✗ business validation leaking into the service layer
    if newSalary <= emp.Salary {
        return errors.New("new salary must be greater")
    }
    emp.Salary = newSalary // ✗ direct mutation from outside the entity
    return s.repo.Save(emp)
}

// ✓ Rich Domain Model — business rules live inside the entity
type Employee struct {
    id     EmployeeID
    salary int64
    // ... other fields
}

func (e *Employee) Promote(newSalary int64) error {
    // ✓ business validation inside the entity
    if newSalary <= e.salary {
        return errors.New("new salary must be greater than the current salary")
    }
    e.salary = newSalary // ✓ the entity controls its own state
    return nil
}

// The service only orchestrates
func (s *EmployeeService) PromoteEmployee(id string, newSalary int64) error {
    emp, _ := s.repo.FindByID(EmployeeID(id))
    if err := emp.Promote(newSalary); err != nil { // ✓ delegate to the entity
        return err
    }
    return s.repo.Save(emp)
}

// ✗ Business logic in the presentation layer
func (h *EmployeeHandler) Promote(w http.ResponseWriter, r *http.Request) {
	emp := getEmployee(r)
	// ✗ business validation in the HTTP handler
	if emp.Salary >= 10000000 {
		writeError(w, 400, "salary has reached the maximum limit")
		return
	}
	emp.Salary += 1000000 // ✗ direct mutation in the handler
	saveEmployee(emp)
}

// ✓ The handler only parses and delegates
func (h *EmployeeHandler) Promote(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req promoteRequest
	json.NewDecoder(r.Body).Decode(&req)
	output, err := h.svc.PromoteEmployee(id, req.NewSalary) // ✓ delegate
	if err != nil { writeError(w, 422, err.Error()); return }
	writeJSON(w, 200, output)
}

// ✗ Skipping layers — presentation straight to infrastructure
func (h *EmployeeHandler) GetEmployee(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	// ✗ the handler queries the database directly — skipping application and domain
	var emp employeeRow
	db.QueryRow("SELECT * FROM employees WHERE id = $1", id).Scan(&emp)
	json.NewEncoder(w).Encode(emp)
}

// ✓ The flow always goes through the right layers
func (h *EmployeeHandler) GetEmployee(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	output, err := h.svc.GetEmployee(id) // ✓ through the application service
	if err != nil { writeError(w, 404, err.Error()); return }
	writeJSON(w, 200, output)
}

// ✗ Circular dependency — domain importing from application
package domain // ✗

import "myapp/application" // DON'T — dependency cycle!

// ✓ Dependencies are always one-way downward
// presentation imports application
// application imports domain
// domain imports nothing from upper layers