Desain Request dan Response API
yang Konsisten

Satu bentuk JSON yang sama di seluruh endpoint

Di React atau mobile client, API yang konsisten terasa seperti komponen dengan props yang jelas: gampang dipakai, gampang dites, dan jarang memaksa kamu menebak.

Di modul sebelumnya kita sudah membuat handler net/http lalu merapikan routing dengan chi. Pada modul routing, response sengaja kita tulis lewat helper sederhana writeJSON dan writeError yang menghasilkan {"error":"pesan"}. Sekarang fokusnya bergeser dari “route apa yang dipanggil” ke “bentuk data apa yang selalu dikirim dan diterima”. Endpoint katalog, cart, checkout, dan admin produk harus memakai pola response yang sama, sehingga frontend cukup menulis satu lapis data fetching dan satu lapis error handling.

Modul ini adalah modul kontrak. Apa yang kita putuskan di sini, mulai dari nama field data, meta, error sampai tipe Meta dan FieldError, akan dipakai ulang oleh modul middleware, validasi, autentikasi, dan peta API final. Jadi anggap ini sebagai menulis konstitusi kecil untuk seluruh API skincare.

Empat bentuk JSON: sukses tunggal, sukses list, error, dan validation

Envelope adalah amplop yang membungkus payload. Isinya berbeda tiap endpoint, tetapi amplopnya selalu sama, sehingga client tahu di mana mencari data dan di mana mencari error.

Kita sepakati empat bentuk untuk seluruh proyek skincare. Hafalkan keempatnya, karena ini kontrak yang dipakai dari modul ini sampai modul peta API final.

Sukses tunggal (GET /v1/products/{id})Salin
{
  "data": {
    "id": 101,
    "name": "Hydrating Toner",
    "category": "toner",
    "price": 129000,
    "stock": 42,
    "status": "active"
  }
}

Sukses list (GET /v1/products?page=1)Salin
{
  "data": [
    { "id": 101, "name": "Hydrating Toner", "price": 129000 },
    { "id": 102, "name": "Niacinamide Serum", "price": 189000 }
  ],
  "meta": { "page": 1, "per_page": 20, "total": 135, "total_pages": 7 }
}

Error biasa (404 Not Found)Salin
{
  "error": { "code": "product_not_found", "message": "Produk tidak ditemukan." }
}

Error validasi (422 Unprocessable Entity)Salin
{
  "error": {
    "code": "validation_error",
    "message": "Validasi gagal",
    "fields": [
      { "field": "price", "message": "harga harus lebih dari 0" }
    ]
  }
}

Inilah peta endpoint yang akan memakai envelope ini sepanjang proyek.

Gerbang masuk: bentuk JSON yang boleh dikirim client

Request DTO mendeskripsikan JSON yang boleh client kirim ke API. Ia tipis, eksplisit, dan sengaja terpisah dari model domain.

Di Go, field struct yang ingin diakses package lain harus exported, artinya diawali huruf kapital. JSON API biasanya memakai snake_case atau nama domain seperti price. JSON tag adalah jembatan antara PriceRupiah di Go dan price di JSON. Package standard library encoding/json menyediakan NewDecoder, Decode, NewEncoder, dan Encode untuk proses ini.

internal/product/dto.goSalin
package product

// CreateProductRequest adalah bentuk JSON saat admin membuat produk baru.
type CreateProductRequest struct {
	Name        string `json:"name"`
	Slug        string `json:"slug"`
	Category    string `json:"category"`
	PriceRupiah int64  `json:"price"`
	Stock       int    `json:"stock"`
	Description string `json:"description"`
}

// AddCartItemRequest dipakai customer untuk menambah item ke keranjang.
type AddCartItemRequest struct {
	ProductID int64 `json:"product_id"`
	Quantity  int   `json:"quantity"`
}

Untuk endpoint update parsial (PATCH), kita butuh membedakan “field ini sengaja dikosongkan” dari “field ini tidak disebut sama sekali”. Di sinilah pointer berguna.

internal/product/dto.goSalin
// UpdateProductRequest dipakai PATCH /v1/admin/products/{id}.
// Pointer membuat kita bisa membedakan field absent (nil) dari field nol.
type UpdateProductRequest struct {
	Name        *string `json:"name"`
	Category    *string `json:"category"`
	PriceRupiah *int64  `json:"price"`
	Stock       *int    `json:"stock"`
	Status      *string `json:"status"`
}

MaxBytesReader, DisallowUnknownFields, dan satu error JSON yang stabil

Sebelum membahas response, kita rapikan dulu cara membaca request. Decode body adalah titik masuk paling rawan, jadi kita bungkus dalam satu helper yang konsisten.

Ada tiga pertahanan kecil yang hampir selalu kita pasang saat membaca JSON dari client: batasi ukuran body, tolak field tak dikenal, dan kembalikan satu error stabil saat JSON rusak.

Kita taruh helper decode di package httpx agar semua handler memakainya tanpa mengulang boilerplate.

internal/httpx/decode.goSalin
package httpx

import (
	"encoding/json"
	"errors"
	"io"
	"net/http"
)

// maxBodyBytes membatasi ukuran request body menjadi 1 MB.
const maxBodyBytes = 1 << 20

// ErrInvalidJSON adalah satu-satunya error decode yang kita ekspos ke handler.
// Detail teknis (syntax error, EOF, tipe salah) sengaja tidak dibocorkan.
var ErrInvalidJSON = errors.New("invalid json")

// DecodeJSON membaca body JSON ke dst dengan tiga pertahanan:
// batas ukuran, tolak field tak dikenal, dan tolak body kosong atau ganda.
func DecodeJSON(w http.ResponseWriter, r *http.Request, dst any) error {
	r.Body = http.MaxBytesReader(w, r.Body, maxBodyBytes)

	dec := json.NewDecoder(r.Body)
	dec.DisallowUnknownFields()

	if err := dec.Decode(dst); err != nil {
		return ErrInvalidJSON
	}

	// Pastikan tidak ada JSON kedua menempel setelah object pertama.
	if err := dec.Decode(&struct{}{}); err != io.EOF {
		return ErrInvalidJSON
	}

	return nil
}

Pemakaian di handler menjadi ringkas, dan error JSON selalu dipetakan ke satu kode stabil.

internal/product/handler.goSalin
var req CreateProductRequest
if err := httpx.DecodeJSON(w, r, &req); err != nil {
	httpx.Error(w, http.StatusBadRequest, "invalid_json", "Body JSON tidak valid.")
	return
}

Tampilkan hanya field yang aman, jangan bocorkan isi database

Response DTO adalah bentuk data yang sengaja kita tampilkan ke client, bukan seluruh isi domain atau baris database.

Domain model sering punya field internal seperti CostRupiah, SupplierID, DeletedAt, atau, paling berbahaya, PasswordHash di model user. Field seperti itu tidak boleh bocor ke client. Karena itu response dipetakan eksplisit dari domain ke DTO, mirip API Resource di Laravel atau serialization DTO di NestJS, tetapi di Go biasanya cukup struct plus satu fungsi mapper kecil.

internal/product/model.goSalin
package product

import "time"

// Product adalah model domain. Tidak semua field di sini boleh tampil di API.
type Product struct {
	ID          int64
	Name        string
	Slug        string
	Category    string
	PriceRupiah int64
	CostRupiah  int64 // harga modal, internal, JANGAN bocor ke client
	SupplierID  int64 // internal
	Stock       int
	Description string
	Status      string
	CreatedAt   time.Time
	DeletedAt   *time.Time // soft delete, internal
}

internal/product/dto.goSalin
package product

// ProductResponse hanya memuat field yang aman dan stabil untuk client.
type ProductResponse struct {
	ID          int64  `json:"id"`
	Name        string `json:"name"`
	Slug        string `json:"slug"`
	Category    string `json:"category"`
	PriceRupiah int64  `json:"price"`
	Stock       int    `json:"stock"`
	Description string `json:"description,omitempty"`
	Status      string `json:"status"`
	CreatedAt   string `json:"created_at"`
}

internal/product/mapper.goSalin
package product

import "time"

// NewProductResponse memetakan domain Product ke ProductResponse.
// Hanya field aman yang ikut; CostRupiah, SupplierID, DeletedAt ditinggalkan.
func NewProductResponse(p Product) ProductResponse {
	return ProductResponse{
		ID:          p.ID,
		Name:        p.Name,
		Slug:        p.Slug,
		Category:    p.Category,
		PriceRupiah: p.PriceRupiah,
		Stock:       p.Stock,
		Description: p.Description,
		Status:      p.Status,
		CreatedAt:   p.CreatedAt.UTC().Format(time.RFC3339),
	}
}

// NewProductResponseList memetakan slice domain menjadi slice DTO.
func NewProductResponseList(items []Product) []ProductResponse {
	out := make([]ProductResponse, 0, len(items))
	for _, p := range items {
		out = append(out, NewProductResponse(p))
	}
	return out
}

JSON, Data, List, Error, ValidationFailed

Daripada mengulang set header, status, dan encode di setiap handler, kita pusatkan semuanya di satu package kecil bernama httpx. Inilah inti modul ini.

Package internal/httpx adalah kontrak teknis envelope. Lima helper publiknya menutup semua kebutuhan response API skincare. Mari bangun dari bawah ke atas.

internal/httpx/response.goSalin
package httpx

import (
	"encoding/json"
	"log/slog"
	"net/http"
)

// JSON adalah primitif terendah: set header, tulis status, encode payload.
// Semua helper lain memanggil JSON di akhir.
func JSON(w http.ResponseWriter, status int, payload any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(payload); err != nil {
		// Status sudah terkirim, jadi kita hanya bisa mencatat, bukan membalas.
		slog.Error("encode response", "error", err)
	}
}

// dataEnvelope membungkus payload sukses tunggal menjadi {"data": ...}.
type dataEnvelope struct {
	Data any `json:"data"`
}

// Data menulis response sukses tunggal: {"data": <obj>}.
func Data(w http.ResponseWriter, status int, data any) {
	JSON(w, status, dataEnvelope{Data: data})
}

// listEnvelope membungkus list menjadi {"data": [...], "meta": {...}}.
type listEnvelope struct {
	Data any  `json:"data"`
	Meta Meta `json:"meta"`
}

// List menulis response sukses list dengan meta pagination.
func List(w http.ResponseWriter, status int, data any, meta Meta) {
	JSON(w, status, listEnvelope{Data: data, Meta: meta})
}

Sekarang sisi error. Kita definisikan Meta dan FieldError di sini karena keduanya dipakai lintas modul (pagination dan validasi).

internal/httpx/response.goSalin
// Meta adalah informasi pagination untuk response list.
type Meta struct {
	Page       int   `json:"page"`
	PerPage    int   `json:"per_page"`
	Total      int64 `json:"total"`
	TotalPages int   `json:"total_pages"`
}

// FieldError menjelaskan satu field yang gagal validasi.
type FieldError struct {
	Field   string `json:"field"`
	Message string `json:"message"`
}

Pemakaian helper sukses di handler menjadi sangat ringkas, dan bentuk JSON dijamin konsisten.

internal/product/handler.goSalin
// Detail produk: satu object.
httpx.Data(w, http.StatusOK, NewProductResponse(p))

// Produk baru dibuat: 201 dengan object.
httpx.Data(w, http.StatusCreated, NewProductResponse(created))

// List produk: array plus meta pagination.
httpx.List(w, http.StatusOK, NewProductResponseList(items), meta)

code machine-readable, message untuk manusia

Error response yang stabil membuat frontend bisa membedakan salah input, belum login, data tidak ditemukan, dan konflik bisnis tanpa parsing teks bebas.

Jangan kirim sekadar {"error":"bad request"}. Client butuh code yang machine-readable (untuk logic) dan message yang aman ditampilkan ke pengguna. Kita pakai code snake_case agar stabil dan mudah dicocokkan.

internal/httpx/errors.goSalin
package httpx

import "net/http"

// errBody adalah isi dari {"error": {...}}.
type errBody struct {
	Code    string       `json:"code"`
	Message string       `json:"message"`
	Fields  []FieldError `json:"fields,omitempty"`
}

// errEnvelope membungkus error menjadi {"error": {...}}.
type errEnvelope struct {
	Error errBody `json:"error"`
}

// Error menulis response error biasa: {"error": {"code": ..., "message": ...}}.
func Error(w http.ResponseWriter, status int, code, message string) {
	JSON(w, status, errEnvelope{
		Error: errBody{Code: code, Message: message},
	})
}

// ValidationFailed menulis 422 dengan daftar field bermasalah.
func ValidationFailed(w http.ResponseWriter, fields []FieldError) {
	JSON(w, http.StatusUnprocessableEntity, errEnvelope{
		Error: errBody{
			Code:    "validation_error",
			Message: "Validasi gagal",
			Fields:  fields,
		},
	})
}

Kode error dipakai konsisten di seluruh proyek. Hafalkan daftar pendek ini.

internal/product/handler.goSalin
// Produk tidak ditemukan.
httpx.Error(w, http.StatusNotFound, "product_not_found", "Produk tidak ditemukan.")

// Slug bentrok saat create.
httpx.Error(w, http.StatusConflict, "conflict", "Slug produk sudah dipakai.")

Kumpulkan semua kesalahan, jangan berhenti di yang pertama

Validation error harus menandai field mana yang bermasalah, bukan hanya bilang request gagal. Frontend butuh ini untuk menaruh pesan tepat di bawah input form.

Pada modul ini kita validasi secara manual agar polanya jelas. Hasil validasi adalah []httpx.FieldError, lalu diteruskan ke httpx.ValidationFailed. Modul Validasi API berikutnya akan memperdalam ini dengan aturan panjang string, format email, dan opsi library validator, tetapi bentuk outputnya tetap []httpx.FieldError yang sama.

internal/product/validation.goSalin
package product

import (
	"strings"

	"github.com/kamu/skincare-backend/internal/httpx"
)

// ValidateCreateProduct mengumpulkan SEMUA error, bukan berhenti di yang pertama.
func ValidateCreateProduct(req CreateProductRequest) []httpx.FieldError {
	var fields []httpx.FieldError

	if strings.TrimSpace(req.Name) == "" {
		fields = append(fields, httpx.FieldError{
			Field: "name", Message: "nama produk wajib diisi",
		})
	}
	if strings.TrimSpace(req.Slug) == "" {
		fields = append(fields, httpx.FieldError{
			Field: "slug", Message: "slug produk wajib diisi",
		})
	}
	if strings.TrimSpace(req.Category) == "" {
		fields = append(fields, httpx.FieldError{
			Field: "category", Message: "kategori produk wajib dipilih",
		})
	}
	if req.PriceRupiah <= 0 {
		fields = append(fields, httpx.FieldError{
			Field: "price", Message: "harga harus lebih dari 0",
		})
	}
	if req.Stock < 0 {
		fields = append(fields, httpx.FieldError{
			Field: "stock", Message: "stok tidak boleh negatif",
		})
	}

	return fields
}

internal/product/handler.goSalin
func (h *Handler) CreateProduct(w http.ResponseWriter, r *http.Request) {
	var req CreateProductRequest
	if err := httpx.DecodeJSON(w, r, &req); err != nil {
		httpx.Error(w, http.StatusBadRequest, "invalid_json", "Body JSON tidak valid.")
		return
	}

	if fields := ValidateCreateProduct(req); len(fields) > 0 {
		httpx.ValidationFailed(w, fields)
		return
	}

	created, err := h.service.CreateProduct(r.Context(), CreateProductInput{
		Name:        strings.TrimSpace(req.Name),
		Slug:        strings.TrimSpace(req.Slug),
		Category:    strings.TrimSpace(req.Category),
		PriceRupiah: req.PriceRupiah,
		Stock:       req.Stock,
		Description: strings.TrimSpace(req.Description),
	})
	if err != nil {
		httpx.Error(w, http.StatusInternalServerError, "internal_error", "Produk gagal dibuat.")
		return
	}

	httpx.Data(w, http.StatusCreated, NewProductResponse(created))
}

Clamp input, hitung total_pages, kembalikan meta yang jujur

Endpoint list hampir selalu butuh pagination agar response tetap ringan dan predictable. Kuncinya: jangan percaya angka dari client mentah-mentah, clamp dulu.

Client mengirim page dan per_page lewat query string, dan keduanya bisa berisi apa saja: nol, negatif, ribuan, atau bukan angka. Kita clamp ke rentang aman, lalu hitung total_pages dari total yang diberikan repository. Helper ini hidup di httpx agar dipakai semua endpoint list.

internal/httpx/pagination.goSalin
package httpx

import (
	"net/http"
	"strconv"
)

const (
	defaultPerPage = 20
	maxPerPage     = 100
)

// PageParams membaca page dan per_page dari query lalu meng-clamp ke rentang aman.
// page minimal 1; per_page antara 1 dan maxPerPage, default 20.
func PageParams(r *http.Request) (page, perPage int) {
	page = atoiDefault(r.URL.Query().Get("page"), 1)
	if page < 1 {
		page = 1
	}

	perPage = atoiDefault(r.URL.Query().Get("per_page"), defaultPerPage)
	if perPage < 1 {
		perPage = defaultPerPage
	}
	if perPage > maxPerPage {
		perPage = maxPerPage
	}

	return page, perPage
}

// Offset menghitung jumlah baris yang dilewati untuk LIMIT/OFFSET di SQL nanti.
func Offset(page, perPage int) int {
	return (page - 1) * perPage
}

// NewMeta membangun Meta lengkap dengan total_pages yang dihitung dari total.
func NewMeta(page, perPage int, total int64) Meta {
	totalPages := 0
	if perPage > 0 {
		// Pembulatan ke atas: ceil(total / perPage).
		totalPages = int((total + int64(perPage) - 1) / int64(perPage))
	}
	return Meta{
		Page:       page,
		PerPage:    perPage,
		Total:      total,
		TotalPages: totalPages,
	}
}

func atoiDefault(raw string, fallback int) int {
	n, err := strconv.Atoi(raw)
	if err != nil {
		return fallback
	}
	return n
}

Perhitungan total_pages memakai trik pembulatan ke atas tanpa float: (total + perPage - 1) / perPage. Untuk 135 produk dengan per_page 20, hasilnya (135 + 19) / 20 = 7 halaman, sesuai harapan.

internal/product/handler.goSalin
func (h *Handler) ListProducts(w http.ResponseWriter, r *http.Request) {
	page, perPage := httpx.PageParams(r)
	category := strings.TrimSpace(r.URL.Query().Get("category"))
	q := strings.TrimSpace(r.URL.Query().Get("q"))

	items, total, err := h.service.ListProducts(r.Context(), ListProductFilter{
		Category: category,
		Query:    q,
		Limit:    perPage,
		Offset:   httpx.Offset(page, perPage),
	})
	if err != nil {
		httpx.Error(w, http.StatusInternalServerError, "internal_error", "Gagal memuat produk.")
		return
	}

	meta := httpx.NewMeta(page, perPage, total)
	httpx.List(w, http.StatusOK, NewProductResponseList(items), meta)
}

GET /v1/products?page=1&per_page=20Salin
{
  "data": [
    { "id": 101, "name": "Hydrating Toner", "category": "toner", "price": 129000, "stock": 42, "status": "active", "created_at": "2026-06-06T02:15:00Z" }
  ],
  "meta": { "page": 1, "per_page": 20, "total": 135, "total_pages": 7 }
}

Jalur yang sama untuk setiap endpoint

Handler yang rapi punya alur yang mudah dibaca dan selalu sama: decode, validate, panggil service, map ke response DTO, lalu encode lewat httpx.

flowchart LR
  REQ([HTTP Request]) --> DEC["httpx.DecodeJSON<br/>(MaxBytes + DisallowUnknown)"]
  DEC -->|invalid_json 400| ERR1([httpx.Error])
  DEC -->|ok| VAL["Validate<br/>[]FieldError"]
  VAL -->|gagal 422| ERR2([httpx.ValidationFailed])
  VAL -->|lolos| SVC["Service<br/>(business logic)"]
  SVC -->|error| ERR3([httpx.Error])
  SVC -->|domain| MAP["Mapper<br/>domain to DTO"]
  MAP --> ENC["httpx.Data / httpx.List"]
  ENC --> RESP([JSON Response])

Gambar 1. Setiap handler melewati jalur yang sama. Cabang error selalu lewat httpx, sehingga bentuk error JSON konsisten di seluruh API.

Diagram berikut menunjukkan urutan waktu satu request create produk, dari frontend sampai response kembali.

sequenceDiagram
  participant FE as Frontend React / Mobile
  participant H as Go Handler
  participant V as Validator
  participant SVC as Product Service
  participant HX as httpx
  FE->>H: POST /v1/admin/products dengan JSON
  H->>H: httpx.DecodeJSON ke CreateProductRequest
  H->>V: ValidateCreateProduct(req)
  V-->>H: []FieldError (kosong jika valid)
  H->>SVC: CreateProduct(ctx, input)
  SVC-->>H: Product domain
  H->>HX: Data(w, 201, NewProductResponse(p))
  HX-->>FE: 201 Created {"data": {...}}

Gambar 2. Handler menjaga batas antara JSON contract, validasi, service layer, dan response DTO. Context request (r.Context()) diteruskan ke service sebagai parameter pertama.

internal/product/handler.goSalin
package product

import (
	"context"
	"net/http"

	"github.com/kamu/skincare-backend/internal/httpx"
)

// ProductService adalah interface yang dibutuhkan handler.
// Handler menerima interface (accept interfaces), bukan implementasi konkret.
type ProductService interface {
	CreateProduct(ctx context.Context, in CreateProductInput) (Product, error)
	ListProducts(ctx context.Context, f ListProductFilter) ([]Product, int64, error)
}

type Handler struct {
	service ProductService
}

func NewHandler(service ProductService) *Handler {
	return &Handler{service: service}
}

DTO dekat fiturnya, helper response di httpx

DTO sebaiknya hidup dekat fitur yang memakainya, sementara helper response umum tinggal di package kecil internal/httpx.

go.modSalin
module github.com/kamu/skincare-backend

go 1.26

require github.com/go-chi/chi/v5 v5.3.0

internal/router/router.goSalin
package router

import (
	"github.com/go-chi/chi/v5"

	"github.com/kamu/skincare-backend/internal/product"
)

func New(productHandler *product.Handler) chi.Router {
	r := chi.NewRouter()

	r.Route("/v1", func(r chi.Router) {
		r.Get("/products", productHandler.ListProducts)
		r.Get("/products/{id}", productHandler.GetProduct)
		// Route admin produk akan dilindungi middleware auth di modul berikutnya.
		r.Post("/admin/products", productHandler.CreateProduct)
	})

	return r
}

Bangun envelope lalu uji sukses, validasi, dan pagination

Latihan ini merakit kontrak create dan list produk lengkap, dari request, validasi, sampai response sukses, error, dan pagination.

Kirim produk valid dan amati 201 Created dengan amplop data.

TerminalSalin
curl -i -X POST http://localhost:8080/v1/admin/products \
  -H 'Content-Type: application/json' \
  -d '{"name":"Hydrating Toner","slug":"hydrating-toner","category":"toner","price":129000,"stock":42,"description":"Toner pelembap harian"}'

Expected 201 CreatedSalin
{
  "data": {
    "id": 101,
    "name": "Hydrating Toner",
    "slug": "hydrating-toner",
    "category": "toner",
    "price": 129000,
    "stock": 42,
    "description": "Toner pelembap harian",
    "status": "active",
    "created_at": "2026-06-06T02:15:00Z"
  }
}

Kirim produk tidak valid dan amati 422 dengan daftar fields.

TerminalSalin
curl -i -X POST http://localhost:8080/v1/admin/products \
  -H 'Content-Type: application/json' \
  -d '{"name":"","slug":"","category":"","price":0,"stock":-1}'

Expected 422 Unprocessable EntitySalin
{
  "error": {
    "code": "validation_error",
    "message": "Validasi gagal",
    "fields": [
      { "field": "name", "message": "nama produk wajib diisi" },
      { "field": "slug", "message": "slug produk wajib diisi" },
      { "field": "category", "message": "kategori produk wajib dipilih" },
      { "field": "price", "message": "harga harus lebih dari 0" },
      { "field": "stock", "message": "stok tidak boleh negatif" }
    ]
  }
}

Ambil daftar produk dengan pagination dan amati amplop data plus meta.

TerminalSalin
curl -i "http://localhost:8080/v1/products?page=1&per_page=20&category=toner"

Expected 200 OKSalin
{
  "data": [
    { "id": 101, "name": "Hydrating Toner", "category": "toner", "price": 129000, "stock": 42, "status": "active", "created_at": "2026-06-06T02:15:00Z" }
  ],
  "meta": { "page": 1, "per_page": 20, "total": 1, "total_pages": 1 }
}

Bug kontrak yang sering terbawa dari Express atau Laravel

Sebagian bug API Go bukan karena sintaks sulit, tetapi karena kontrak JSON tidak sengaja berubah atau terlalu dekat dengan database.

Desain request dan response adalah fondasi kontrak publik API skincare. Package internal/httpx yang kita bangun di sini akan dipakai ulang di modul middleware, validasi, autentikasi, sampai peta API final.

Untuk proyek online shop skincare, modul ini menetapkan konstitusi response API. Langkah berikutnya adalah modul Middleware, tempat kita memasang logging, recoverer, request ID, dan CORS di sekitar handler ini, lalu modul Validasi API yang memperdalam ValidateCreateProduct dengan aturan panjang string dan format email, tetap menghasilkan []httpx.FieldError yang sama. Saat contoh masih in-memory, ingat bahwa repository PostgreSQL dengan pgx akan datang di Roadmap 3, dan httpx akan tetap menjadi lapisan response yang tidak berubah.