Layered Architecture #

// domain/employee.go
package domain

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

type EmployeeID string
type DepartmentID string

// Employee adalah entity dengan business rules
// ✓ Tidak ada import dari database, HTTP, atau framework apapun
type Employee struct {
	id           EmployeeID
	fullName     string
	email        string
	departmentID DepartmentID
	salary       int64 // dalam satuan terkecil (sen/rupiah)
	joinDate     time.Time
	isActive     bool
}

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

// NewEmployee menegakkan invariant bisnis saat pembuatan
func NewEmployee(fullName, email string, departmentID DepartmentID, salary int64) (*Employee, error) {
	if fullName == "" {
		return nil, errors.New("nama karyawan tidak boleh kosong")
	}
	if !emailRegex.MatchString(email) {
		return nil, errors.New("format email tidak valid")
	}
	if salary < 0 {
		return nil, errors.New("gaji tidak boleh negatif")
	}

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

// Promote menaikkan gaji dengan validasi bisnis
func (e *Employee) Promote(newSalary int64) error {
	if newSalary <= e.salary {
		return errors.New("gaji baru harus lebih besar dari gaji saat ini")
	}
	e.salary = newSalary
	return nil
}

// Resign menonaktifkan karyawan
func (e *Employee) Resign() error {
	if !e.isActive {
		return errors.New("karyawan sudah tidak aktif")
	}
	e.isActive = false
	return nil
}

// Transfer memindahkan karyawan ke departemen lain
func (e *Employee) Transfer(newDeptID DepartmentID) error {
	if e.departmentID == newDeptID {
		return errors.New("karyawan sudah berada di departemen tersebut")
	}
	e.departmentID = newDeptID
	return nil
}

// Getter
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 adalah interface yang didefinisikan di domain
// ✓ Domain mendefinisikan kebutuhan — infrastructure mengimplementasikan
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 mengorkestrasikan use case karyawan
// ✓ Tidak ada detail HTTP atau database di sini — hanya alur bisnis
type EmployeeService struct {
	employeeRepo domain.EmployeeRepository
}

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

// CreateEmployeeInput adalah DTO input untuk pembuatan karyawan
type CreateEmployeeInput struct {
	FullName     string
	Email        string
	DepartmentID string
	Salary       int64
}

// EmployeeOutput adalah DTO output yang digunakan untuk semua response
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 membuat karyawan baru
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("gagal menyimpan karyawan: %w", err)
	}

	return toOutput(employee), nil
}

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

	// Delegasikan ke domain entity — service tidak mengandung business logic
	if err := employee.Promote(newSalary); err != nil {
		return nil, err
	}

	if err := s.employeeRepo.Save(employee); err != nil {
		return nil, fmt.Errorf("gagal menyimpan perubahan: %w", err)
	}

	return toOutput(employee), nil
}

// ResignEmployee memproses pengunduran diri karyawan
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 memindahkan karyawan ke departemen lain
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 mengambil semua karyawan di satu departemen
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 adalah HTTP handler — presentation layer
// ✓ Hanya menangani parse request, delegate ke service, format response
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, "request tidak valid")
		return
	}

	// Validasi format ada di sini — bukan business validation
	if req.FullName == "" || req.Email == "" || req.DepartmentID == "" {
		writeError(w, http.StatusBadRequest, "semua field wajib diisi")
		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, "request tidak valid")
		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, "gagal mengambil data karyawan")
		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 mengimplementasikan domain.EmployeeRepository
type PostgresEmployeeRepository struct {
	db *sql.DB
}

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

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

// employeeRow adalah model database — terpisah dari 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("gagal menyimpan 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("karyawan tidak ditemukan: %s", id)
	}
	if err != nil {
		return nil, fmt.Errorf("gagal membaca 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("gagal 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) {
	// implementasi serupa FindByDepartment...
	return nil, nil
}

// ✗ Anemic Domain Model — entity hanya data, semua logic di service
type Employee struct { // hanya getter/setter
    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)
    // ✗ validasi bisnis bocor ke service layer
    if newSalary <= emp.Salary {
        return errors.New("gaji baru harus lebih besar")
    }
    emp.Salary = newSalary // ✗ mutasi langsung dari luar entity
    return s.repo.Save(emp)
}

// ✓ Rich Domain Model — business rules ada di dalam entity
type Employee struct {
    id     EmployeeID
    salary int64
    // ... field lain
}

func (e *Employee) Promote(newSalary int64) error {
    // ✓ validasi bisnis di dalam entity
    if newSalary <= e.salary {
        return errors.New("gaji baru harus lebih besar dari gaji saat ini")
    }
    e.salary = newSalary // ✓ entity yang mengontrol state-nya sendiri
    return nil
}

// Service hanya mengorkestrasikan
func (s *EmployeeService) PromoteEmployee(id string, newSalary int64) error {
    emp, _ := s.repo.FindByID(EmployeeID(id))
    if err := emp.Promote(newSalary); err != nil { // ✓ delegate ke entity
        return err
    }
    return s.repo.Save(emp)
}

// ✗ Business logic di presentation layer
func (h *EmployeeHandler) Promote(w http.ResponseWriter, r *http.Request) {
	emp := getEmployee(r)
	// ✗ validasi bisnis di HTTP handler
	if emp.Salary >= 10000000 {
		writeError(w, 400, "gaji sudah mencapai batas maksimum")
		return
	}
	emp.Salary += 1000000 // ✗ mutasi langsung di handler
	saveEmployee(emp)
}

// ✓ Handler hanya parse dan delegate
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)
}

// ✗ Skip layer — presentation langsung ke infrastructure
func (h *EmployeeHandler) GetEmployee(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	// ✗ handler langsung query database — skip application dan domain
	var emp employeeRow
	db.QueryRow("SELECT * FROM employees WHERE id = $1", id).Scan(&emp)
	json.NewEncoder(w).Encode(emp)
}

// ✓ Alur selalu melalui layer yang benar
func (h *EmployeeHandler) GetEmployee(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	output, err := h.svc.GetEmployee(id) // ✓ lewat application service
	if err != nil { writeError(w, 404, err.Error()); return }
	writeJSON(w, 200, output)
}

// ✗ Circular dependency — domain mengimport dari application
package domain // ✗

import "myapp/application" // JANGAN — dependency cycle!

// ✓ Dependency selalu satu arah ke bawah
// presentation imports application
// application imports domain
// domain tidak import apapun dari layer atas