Errors #

package main

import (
    "errors"
    "fmt"
)

// Sentinel errors — variabel error yang didefinisikan di level package
// Konvensi: nama dimulai dengan "Err"
var (
    ErrTidakDitemukan  = errors.New("tidak ditemukan")
    ErrTidakDiizinkan  = errors.New("tidak diizinkan")
    ErrInputTidakValid = errors.New("input tidak valid")
    ErrKoneksiBermasalah = errors.New("koneksi bermasalah")
)

func cariPengguna(id int) (*Pengguna, error) {
    if id <= 0 {
        return nil, ErrInputTidakValid
    }
    if id > 1000 {
        return nil, ErrTidakDitemukan
    }
    return &Pengguna{ID: id, Nama: "Budi"}, nil
}

func main() {
    _, err := cariPengguna(-1)

    // Bandingkan dengan == — ANTI-PATTERN untuk error yang di-wrap
    if err == ErrInputTidakValid {
        fmt.Println("input salah") // bekerja tapi tidak robust
    }

    // BENAR: gunakan errors.Is — bekerja bahkan jika error di-wrap
    if errors.Is(err, ErrInputTidakValid) {
        fmt.Println("input salah") // selalu benar
    }
}

var ErrTidakDitemukan = errors.New("tidak ditemukan")

// Layer repository
func repoCariBuku(id int) error {
    return ErrTidakDitemukan
}

// Layer service — menambahkan konteks
func serviceCariBuku(id int) error {
    if err := repoCariBuku(id); err != nil {
        return fmt.Errorf("serviceCariBuku %d: %w", id, err)
        // Error sekarang: "serviceCariBuku 42: tidak ditemukan"
    }
    return nil
}

// Layer handler
func handlerCariBuku(id int) {
    err := serviceCariBuku(id)

    // == tidak bekerja karena error sudah dibungkus
    fmt.Println(err == ErrTidakDitemukan) // false

    // errors.Is membuka semua lapisan wrapping
    fmt.Println(errors.Is(err, ErrTidakDitemukan)) // true ✓
}

// Perbandingan %v vs %w
var ErrDB = errors.New("database error")

// Dengan %v — error lama jadi string, tidak bisa di-unwrap
err1 := fmt.Errorf("operasi gagal: %v", ErrDB)
fmt.Println(errors.Is(err1, ErrDB)) // false ❌

// Dengan %w — error lama terbungkus, bisa di-unwrap
err2 := fmt.Errorf("operasi gagal: %w", ErrDB)
fmt.Println(errors.Is(err2, ErrDB)) // true ✓

// Konvensi penamaan dalam pesan error
// Format: "namaFungsi argumen: pesan" atau "namaFungsi: pesan"
func muatKonfigurasi(path string) error {
    data, err := os.ReadFile(path)
    if err != nil {
        // Sertakan path sebagai konteks — sangat berguna saat debug
        return fmt.Errorf("muatKonfigurasi %s: %w", path, err)
    }
    _ = data
    return nil
}

func inisialisasiApp(configPath string) error {
    if err := muatKonfigurasi(configPath); err != nil {
        return fmt.Errorf("inisialisasiApp: %w", err)
    }
    return nil
}

// Error yang terbentuk saat dipanggil dengan path yang salah:
// "inisialisasiApp: muatKonfigurasi /etc/app.yaml:
//  open /etc/app.yaml: no such file or directory"

var (
    ErrValidasi = errors.New("validasi gagal")
    ErrDB       = errors.New("database error")
)

// Wrap dua error sekaligus dengan dua %w
err := fmt.Errorf("simpanData: %w dan %w", ErrValidasi, ErrDB)
fmt.Println(err)
// simpanData: validasi gagal dan database error

fmt.Println(errors.Is(err, ErrValidasi)) // true
fmt.Println(errors.Is(err, ErrDB))       // true

// errors.Join — cara lain untuk menggabungkan beberapa error (Go 1.20+)
errs := []error{ErrValidasi, ErrDB}
gabungan := errors.Join(errs...)
fmt.Println(gabungan)
// validasi gagal
// database error

fmt.Println(errors.Is(gabungan, ErrValidasi)) // true
fmt.Println(errors.Is(gabungan, ErrDB))       // true

import (
    "errors"
    "io"
    "io/fs"
    "os"
)

// Contoh dengan berbagai jenis error dari stdlib
func contohErrorsIs() {
    // Error dari os package
    _, err := os.Open("tidak-ada.txt")

    // Periksa dengan sentinel error dari io/fs
    if errors.Is(err, fs.ErrNotExist) {
        fmt.Println("file tidak ada")
    }
    if errors.Is(err, fs.ErrPermission) {
        fmt.Println("tidak ada izin")
    }

    // EOF — sentinel error dari io
    _, err2 := fmt.Sscan("", new(int))
    if errors.Is(err2, io.EOF) {
        fmt.Println("tidak ada data")
    }

    // errors.Is juga bekerja dengan nil
    var errNil error = nil
    fmt.Println(errors.Is(errNil, nil)) // true
}

// Custom Is method — untuk perbandingan yang lebih fleksibel
type ErrHTTP struct {
    StatusCode int
    Pesan      string
}

func (e *ErrHTTP) Error() string {
    return fmt.Sprintf("HTTP %d: %s", e.StatusCode, e.Pesan)
}

// Implementasikan Is agar errors.Is bekerja berdasarkan status code
func (e *ErrHTTP) Is(target error) bool {
    t, ok := target.(*ErrHTTP)
    if !ok {
        return false
    }
    // Cocok jika status code sama (abaikan pesan)
    return e.StatusCode == t.StatusCode
}

var ErrNotFound = &ErrHTTP{StatusCode: 404}
var ErrUnauthorized = &ErrHTTP{StatusCode: 401}

func periksaResponse(err error) {
    if errors.Is(err, ErrNotFound) {
        fmt.Println("resource tidak ditemukan")
    }
    if errors.Is(err, ErrUnauthorized) {
        fmt.Println("perlu autentikasi")
    }
}

// errors.As memungkinkan akses ke detail error
type ErrValidasi struct {
    Field   string
    Pesan   string
    Nilai   any
}

func (e *ErrValidasi) Error() string {
    return fmt.Sprintf("validasi gagal untuk field %q: %s (nilai: %v)",
        e.Field, e.Pesan, e.Nilai)
}

func validasiUmur(umur int) error {
    if umur < 0 {
        return &ErrValidasi{
            Field: "umur",
            Pesan: "tidak boleh negatif",
            Nilai: umur,
        }
    }
    if umur > 150 {
        return &ErrValidasi{
            Field: "umur",
            Pesan: "tidak realistis",
            Nilai: umur,
        }
    }
    return nil
}

func prosesRegistrasi(umur int) error {
    if err := validasiUmur(umur); err != nil {
        return fmt.Errorf("prosesRegistrasi: %w", err)
    }
    return nil
}

func main() {
    err := prosesRegistrasi(-5)

    // errors.Is tidak cukup — kita butuh detail field dan nilai
    // errors.As mengekstrak *ErrValidasi dari dalam rantai wrapping
    var errVal *ErrValidasi
    if errors.As(err, &errVal) {
        // Sekarang bisa akses field dari ErrValidasi
        fmt.Printf("Field bermasalah: %s\n", errVal.Field)
        fmt.Printf("Pesan: %s\n", errVal.Pesan)
        fmt.Printf("Nilai yang dikirim: %v\n", errVal.Nilai)

        // Bisa membuat response HTTP yang tepat
        // http.Error(w, errVal.Pesan, http.StatusBadRequest)
    }
}

// Contoh nyata: HTTP handler dengan error handling lengkap
func handlerCariBuku(w http.ResponseWriter, r *http.Request) {
    idStr := r.URL.Query().Get("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        http.Error(w, "ID tidak valid", http.StatusBadRequest)
        return
    }

    buku, err := serviceCariBuku(id)
    if err != nil {
        // Periksa jenis error untuk response yang tepat
        switch {
        case errors.Is(err, ErrTidakDitemukan):
            http.Error(w, "Buku tidak ditemukan", http.StatusNotFound)

        case errors.Is(err, ErrTidakDiizinkan):
            http.Error(w, "Akses ditolak", http.StatusForbidden)

        default:
            // Periksa apakah ada detail error validasi
            var errVal *ErrValidasi
            if errors.As(err, &errVal) {
                http.Error(w,
                    fmt.Sprintf("Input tidak valid: %s", errVal.Pesan),
                    http.StatusBadRequest)
                return
            }

            // Error yang tidak dikenal — log dan return 500
            log.Printf("error tidak terduga: %v", err)
            http.Error(w, "Terjadi kesalahan internal", http.StatusInternalServerError)
        }
        return
    }

    json.NewEncoder(w).Encode(buku)
}

err1 := errors.New("error dasar")
err2 := fmt.Errorf("lapisan 2: %w", err1)
err3 := fmt.Errorf("lapisan 3: %w", err2)

fmt.Println(err3)                    // lapisan 3: lapisan 2: error dasar
fmt.Println(errors.Unwrap(err3))     // lapisan 2: error dasar
fmt.Println(errors.Unwrap(errors.Unwrap(err3))) // error dasar
fmt.Println(errors.Unwrap(err1))     // nil — tidak ada lapisan lagi

// Menelusuri seluruh rantai error secara manual
func telusuriError(err error) {
    fmt.Println("=== Rantai Error ===")
    for err != nil {
        fmt.Printf("  %T: %v\n", err, err)
        err = errors.Unwrap(err)
    }
}

telusuriError(err3)
// === Rantai Error ===
//   *fmt.wrapError: lapisan 3: lapisan 2: error dasar
//   *fmt.wrapError: lapisan 2: error dasar
//   *errors.errorString: error dasar

import "errors"

// Validasi form — kumpulkan semua error sekaligus
type FormRegistrasi struct {
    Nama     string
    Email    string
    Password string
    Umur     int
}

func validasiForm(form FormRegistrasi) error {
    var errs []error

    if form.Nama == "" {
        errs = append(errs, errors.New("nama tidak boleh kosong"))
    } else if len(form.Nama) < 2 {
        errs = append(errs, errors.New("nama minimal 2 karakter"))
    }

    if form.Email == "" {
        errs = append(errs, errors.New("email tidak boleh kosong"))
    } else if !strings.Contains(form.Email, "@") {
        errs = append(errs, errors.New("format email tidak valid"))
    }

    if len(form.Password) < 8 {
        errs = append(errs, errors.New("password minimal 8 karakter"))
    }

    if form.Umur < 18 {
        errs = append(errs, errors.New("umur minimal 18 tahun"))
    }

    // errors.Join menggabungkan semua error
    // mengembalikan nil jika slice kosong
    return errors.Join(errs...)
}

func main() {
    form := FormRegistrasi{
        Nama:     "A",
        Email:    "bukan-email",
        Password: "123",
        Umur:     15,
    }

    if err := validasiForm(form); err != nil {
        fmt.Println("Validasi gagal:")
        fmt.Println(err)
        // Validasi gagal:
        // nama minimal 2 karakter
        // format email tidak valid
        // password minimal 8 karakter
        // umur minimal 18 tahun
    }
}

import (
    "errors"
    "sync"
)

func jalankanParalel(tugas []func() error) error {
    var (
        mu   sync.Mutex
        errs []error
        wg   sync.WaitGroup
    )

    for _, t := range tugas {
        wg.Add(1)
        go func(fn func() error) {
            defer wg.Done()
            if err := fn(); err != nil {
                mu.Lock()
                errs = append(errs, err)
                mu.Unlock()
            }
        }(t)
    }

    wg.Wait()
    return errors.Join(errs...)
}

// Penggunaan
err := jalankanParalel([]func() error{
    func() error { return kirimEmail("[email protected]") },
    func() error { return kirimNotifikasi(123) },
    func() error { return updateCache("key") },
})

if err != nil {
    fmt.Println("Beberapa operasi gagal:", err)
}

// Custom error type dengan Unwrap untuk kompatibilitas wrapping
type ErrDB struct {
    Operasi string
    Query   string
    Err     error // underlying error
}

func (e *ErrDB) Error() string {
    return fmt.Sprintf("db error saat %s: %v", e.Operasi, e.Err)
}

// Unwrap memungkinkan errors.Is dan errors.As menembus ke underlying error
func (e *ErrDB) Unwrap() error {
    return e.Err
}

// Penggunaan
var ErrKoneksiBermasalah = errors.New("koneksi database bermasalah")

func queryDB(query string) error {
    // Simulasi error koneksi
    return &ErrDB{
        Operasi: "SELECT",
        Query:   query,
        Err:     ErrKoneksiBermasalah,
    }
}

func main() {
    err := queryDB("SELECT * FROM users WHERE id = 1")

    // errors.As untuk mengakses detail ErrDB
    var errDB *ErrDB
    if errors.As(err, &errDB) {
        fmt.Printf("Operasi: %s\n", errDB.Operasi)
        fmt.Printf("Query: %s\n", errDB.Query)
    }

    // errors.Is masih bisa menemukan ErrKoneksiBermasalah
    // karena ErrDB mengimplementasikan Unwrap
    if errors.Is(err, ErrKoneksiBermasalah) {
        fmt.Println("Koneksi database bermasalah — coba reconnect")
    }
}

// Error yang membawa HTTP status code dan kode error untuk API
type AppError struct {
    Code       string // kode untuk client: "USER_NOT_FOUND", "INVALID_INPUT"
    Pesan      string // pesan yang bisa ditampilkan ke user
    StatusHTTP int    // HTTP status code yang sesuai
    Err        error  // underlying error (untuk logging, tidak dikirim ke client)
}

func (e *AppError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("[%s] %s: %v", e.Code, e.Pesan, e.Err)
    }
    return fmt.Sprintf("[%s] %s", e.Code, e.Pesan)
}

func (e *AppError) Unwrap() error {
    return e.Err
}

// Konstruktor untuk error yang umum
func ErrUserTidakDitemukan(id int) *AppError {
    return &AppError{
        Code:       "USER_NOT_FOUND",
        Pesan:      fmt.Sprintf("pengguna dengan ID %d tidak ditemukan", id),
        StatusHTTP: 404,
    }
}

func ErrInputTidakValidApp(field, pesan string) *AppError {
    return &AppError{
        Code:       "INVALID_INPUT",
        Pesan:      fmt.Sprintf("field %s: %s", field, pesan),
        StatusHTTP: 400,
    }
}

// Handler yang menggunakan AppError
func handlerGeneral(w http.ResponseWriter, r *http.Request, err error) {
    var appErr *AppError
    if errors.As(err, &appErr) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(appErr.StatusHTTP)
        json.NewEncoder(w).Encode(map[string]string{
            "error": appErr.Code,
            "pesan": appErr.Pesan,
        })
        return
    }

    // Error yang tidak dikenal
    log.Printf("unexpected error: %v", err)
    http.Error(w, "internal server error", 500)
}

// ✗ ANTI-PATTERN 1: Abaikan error
data, _ := os.ReadFile("config.yaml") // data bisa nil!
// Jika ReadFile gagal, data adalah nil dan penggunaan berikutnya akan panik

// ✓ BENAR: selalu periksa error
data, err := os.ReadFile("config.yaml")
if err != nil {
    return fmt.Errorf("muatConfig: %w", err)
}

// ✗ ANTI-PATTERN 2: Hanya log error tapi tetap lanjut
data, err = os.ReadFile("config.yaml")
if err != nil {
    log.Println("error:", err) // log tapi tidak return!
}
// Kode di bawah ini menggunakan data yang mungkin nil

// ✓ BENAR: log DAN return (atau tangani dengan benar)
data, err = os.ReadFile("config.yaml")
if err != nil {
    log.Printf("gagal baca config: %v", err)
    return err // atau gunakan default, atau exit
}

// ✗ ANTI-PATTERN 3: Wrap tanpa nilai tambah
func cariPengguna2(id int) error {
    err := db.Query(id)
    if err != nil {
        return fmt.Errorf("error: %w", err) // "error:" tidak menambahkan konteks apapun!
    }
    return nil
}

// ✓ BENAR: wrap dengan konteks yang bermakna
func cariPengguna3(id int) error {
    err := db.Query(id)
    if err != nil {
        return fmt.Errorf("cariPengguna id=%d: %w", id, err) // nama fungsi + argumen
    }
    return nil
}

// ✗ ANTI-PATTERN 4: Wrap error yang sudah punya konteks cukup
func cariPengguna4(id int) (*Pengguna, error) {
    p, err := cariPengguna3(id)
    if err != nil {
        // cariPengguna3 sudah menambahkan konteks yang bagus
        // wrap lagi hanya menambahkan noise
        return nil, fmt.Errorf("cariPengguna4 dipanggil dengan id %d dan gagal karena: %w", id, err)
    }
    return p, nil
}

// ✓ BENAR: wrap singkat atau langsung return jika konteks sudah cukup
func cariPengguna5(id int) (*Pengguna, error) {
    p, err := cariPengguna3(id)
    if err != nil {
        return nil, fmt.Errorf("cariPengguna5: %w", err) // ringkas, tidak redundan
    }
    return p, nil
}

// ✗ ANTI-PATTERN 5: Gunakan panic untuk error yang bisa ditangani
func bagi(a, b int) int {
    if b == 0 {
        panic("dibagi nol") // jangan panic untuk kondisi yang bisa diprediksi!
    }
    return a / b
}

// ✓ BENAR: kembalikan error untuk kondisi yang bisa terjadi
func bagiBaik(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("tidak bisa dibagi nol")
    }
    return a / b, nil
}

// errors.go — satu file untuk semua sentinel error dalam package
package app

import "errors"

// Error autentikasi
var (
    ErrTokenKadaluarsa  = errors.New("token kadaluarsa")
    ErrTokenTidakValid  = errors.New("token tidak valid")
    ErrSesiTidakDitemukan = errors.New("sesi tidak ditemukan")
)

// Error data
var (
    ErrPenggunaTidakDitemukan = errors.New("pengguna tidak ditemukan")
    ErrProdukTidakDitemukan   = errors.New("produk tidak ditemukan")
    ErrStokKosong             = errors.New("stok kosong")
    ErrDuplikatEmail          = errors.New("email sudah terdaftar")
)

// Error sistem
var (
    ErrDatabase    = errors.New("database tidak tersedia")
    ErrCache       = errors.New("cache tidak tersedia")
    ErrLayananLuar = errors.New("layanan eksternal tidak tersedia")
)

// Middleware yang mengubah AppError menjadi respons JSON yang konsisten
type ErrorResponse struct {
    Kode    string `json:"kode"`
    Pesan   string `json:"pesan"`
    Detail  any    `json:"detail,omitempty"`
}

func errorHandler(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // Gunakan panic recovery untuk menangkap panic yang tidak terduga
        defer func() {
            if rec := recover(); rec != nil {
                log.Printf("panic: %v\n%s", rec, debug.Stack())
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(500)
                json.NewEncoder(w).Encode(ErrorResponse{
                    Kode:  "INTERNAL_ERROR",
                    Pesan: "terjadi kesalahan internal",
                })
            }
        }()

        next(w, r)
    }
}

func kirimError(w http.ResponseWriter, err error) {
    var appErr *AppError
    if errors.As(err, &appErr) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(appErr.StatusHTTP)
        json.NewEncoder(w).Encode(ErrorResponse{
            Kode:  appErr.Code,
            Pesan: appErr.Pesan,
        })
        return
    }

    // Cek sentinel errors umum
    switch {
    case errors.Is(err, ErrPenggunaTidakDitemukan):
        w.WriteHeader(404)
        json.NewEncoder(w).Encode(ErrorResponse{
            Kode:  "NOT_FOUND",
            Pesan: "data tidak ditemukan",
        })
    case errors.Is(err, ErrTokenTidakValid),
        errors.Is(err, ErrTokenKadaluarsa):
        w.WriteHeader(401)
        json.NewEncoder(w).Encode(ErrorResponse{
            Kode:  "UNAUTHORIZED",
            Pesan: "autentikasi diperlukan",
        })
    default:
        log.Printf("unhandled error: %v", err)
        w.WriteHeader(500)
        json.NewEncoder(w).Encode(ErrorResponse{
            Kode:  "INTERNAL_ERROR",
            Pesan: "terjadi kesalahan internal",
        })
    }
}