Koneksi Go ke PostgreSQL
dengan pgxpool

Backend bukan script sekali jalan, ia melayani ribuan request

Backend API berbeda dari script sekali jalan. Ia melayani banyak request bersamaan dan setiap request bisa butuh query ke database. Kunci pertama supaya hal itu hemat dan aman adalah connection pool.

Di React atau Next.js, kamu sering memanggil fetch() berkali-kali dari browser. Di sisi backend, setiap panggilan itu bisa berubah menjadi query PostgreSQL. Kalau setiap request membuka koneksi PostgreSQL baru dari nol, API membayar biaya TCP handshake, autentikasi, negosiasi TLS, dan setup session berulang-ulang. Untuk satu query yang menghasilkan beberapa milidetik kerja nyata, biaya membuka koneksi bisa berkali lipat lebih mahal.

Connection pool menyimpan sejumlah koneksi yang sudah terbuka dan siap pakai. Saat handler produk butuh data, repository meminjam (acquire) koneksi dari pool, menjalankan query, lalu mengembalikannya (release) untuk request lain. Koneksi fisik ke PostgreSQL dipakai ulang, bukan dibuang setelah satu query.

Sepanjang modul ini kita memakai paket github.com/jackc/pgx/v5 dan sub-paket pgxpool. Versi yang dipakai proyek adalah pgx v5 (seri v5.10.x per Juni 2026) dengan Go 1.26 dan PostgreSQL 18. Outcome akhir: backend skincare punya file internal/database/postgres.go yang membuat pool, endpoint /healthz yang memastikan database benar-benar siap, dan shutdown yang menutup pool dengan rapi.

Satu koneksi untuk script, pool untuk API

pgx.Connect membuka satu koneksi tunggal, cocok untuk script sederhana. API production hampir selalu memakai pgxpool karena harus melayani banyak request paralel.

Paket utama yang kita pakai adalah github.com/jackc/pgx/v5/pgxpool. Dokumentasi resminya menyebut pgxpool sebagai connection pool yang concurrency-safe, artinya aman dipanggil dari banyak goroutine sekaligus. Sebuah *pgxpool.Pool punya method yang mirip koneksi pgx biasa (Query, QueryRow, Exec, Begin), jadi repository bisa langsung memakainya tanpa repot mengurus koneksi fisik.

Contoh pgxpool paling sederhana: buat pool dari connection string, ping untuk memastikan database hidup, lalu jangan lupa tutup saat selesai. Perhatikan defer pool.Close() yang menjamin pool dilepas walau fungsi keluar lebih awal.

contoh-sederhana/main.goSalin
package main

import (
	"context"
	"log"
	"os"

	"github.com/jackc/pgx/v5/pgxpool"
)

func main() {
	ctx := context.Background()

	pool, err := pgxpool.New(ctx, os.Getenv("DATABASE_URL"))
	if err != nil {
		log.Fatalf("create pool: %v", err)
	}
	defer pool.Close()

	if err := pool.Ping(ctx); err != nil {
		log.Fatalf("ping database: %v", err)
	}

	log.Println("database is ready")
}

Alamat lengkap database plus batas waktu yang masuk akal

Connection string adalah alamat lengkap yang memberi tahu aplikasi cara masuk ke PostgreSQL. Connection timeout adalah batas berapa lama kita rela menunggu sebelum menyerah.

Format URL yang umum dipakai oleh pgx adalah postgres://user:pass@host:port/dbname?sslmode=.... Di local development, sslmode=disable sering dipakai. Di staging dan production, terutama saat memakai managed database seperti Amazon RDS, gunakan sslmode=require atau lebih ketat sesuai konfigurasi environment.

Format connection string (URL)Salin
postgres://user:password@host:5432/dbname?sslmode=disable

TerminalSalin
export DATABASE_URL='postgres://skincare:secret@localhost:5432/skincare_dev?sslmode=disable'

Parameter pool di dalam connection string

Selain parameter PostgreSQL standar, pgxpool.ParseConfig juga membaca parameter pool langsung dari connection string. Contoh berikut membatasi pool maksimum 10 koneksi, minimum 2, dan lifetime koneksi 1 jam 30 menit. Durasi memakai sintaks Go (1h30m, 30s).

DATABASE_URL dengan parameter poolSalin
postgres://skincare:secret@localhost:5432/skincare_dev?sslmode=disable&pool_max_conns=10&pool_min_conns=2&pool_max_conn_lifetime=1h30m

Parameter pool yang dipahami pgxpool antara lain pool_max_conns, pool_min_conns, pool_max_conn_lifetime, pool_max_conn_idle_time, dan pool_health_check_period. Sisi libpq seperti connect_timeout dan application_name juga ikut terbaca, jadi satu string bisa menampung banyak pengaturan.

Connection timeout: gagal cepat, bukan menggantung

Saat startup, kita tidak ingin aplikasi menggantung selamanya menunggu database yang tidak pernah merespons. Solusinya adalah membungkus proses pembuatan pool dan Ping dengan context.WithTimeout. Jika dalam batas waktu (misalnya 10 detik) database belum siap, context dibatalkan, Ping mengembalikan error, dan aplikasi gagal cepat dengan pesan yang jelas.

cmd/api/main.go (potongan startup)Salin
// Batas waktu khusus untuk fase startup, bukan untuk seluruh hidup aplikasi.
startupCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

pool, err := database.NewPostgresPool(startupCtx, cfg)
if err != nil {
	log.Fatalf("database: %v", err)
}

Satu package kecil agar main.go tetap fokus

Kita pisahkan setup database ke package kecil agar main.go tetap fokus pada wiring aplikasi, dan supaya logika pembuatan pool bisa diuji terpisah.

File internal/database/postgres.go berikut menerima Config, mem-parse connection string menjadi pgxpool.Config, mengatur opsi pool, menjalankan Ping, lalu mengembalikan *pgxpool.Pool yang siap dipakai repository. Pola “parse config dulu, override angka, baru buat pool” lebih fleksibel daripada pgxpool.New polos, karena memberi kita kendali penuh atas setiap opsi.

internal/database/postgres.goSalin
package database

import (
	"context"
	"fmt"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"
)

// Config memisahkan connection string (dari secret) dari angka pool
// (dari konfigurasi aplikasi), sehingga keduanya bisa di-review terpisah.
type Config struct {
	ConnString        string
	MaxConns          int32
	MinConns          int32
	MaxConnLifetime   time.Duration
	MaxConnIdleTime   time.Duration
	HealthCheckPeriod time.Duration
}

// NewPostgresPool membuat pool, mengatur opsi, lalu memastikan database
// benar-benar siap lewat Ping. Jika Ping gagal, pool ditutup agar tidak bocor.
func NewPostgresPool(ctx context.Context, cfg Config) (*pgxpool.Pool, error) {
	poolConfig, err := pgxpool.ParseConfig(cfg.ConnString)
	if err != nil {
		return nil, fmt.Errorf("parse postgres config: %w", err)
	}

	if cfg.MaxConns > 0 {
		poolConfig.MaxConns = cfg.MaxConns
	}
	if cfg.MinConns > 0 {
		poolConfig.MinConns = cfg.MinConns
	}
	if cfg.MaxConnLifetime > 0 {
		poolConfig.MaxConnLifetime = cfg.MaxConnLifetime
	}
	if cfg.MaxConnIdleTime > 0 {
		poolConfig.MaxConnIdleTime = cfg.MaxConnIdleTime
	}
	if cfg.HealthCheckPeriod > 0 {
		poolConfig.HealthCheckPeriod = cfg.HealthCheckPeriod
	}

	pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
	if err != nil {
		return nil, fmt.Errorf("create postgres pool: %w", err)
	}

	if err := pool.Ping(ctx); err != nil {
		pool.Close()
		return nil, fmt.Errorf("ping postgres: %w", err)
	}

	return pool, nil
}

Dipanggil dari main.go

main.go membaca environment variable, membuat context dengan timeout untuk startup, membuat pool, lalu menjadwalkan penutupannya. Di sinilah composition root berada: satu tempat yang tahu cara merakit semua dependency.

cmd/api/main.goSalin
package main

import (
	"context"
	"log"
	"os"
	"time"

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

func main() {
	startupCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	pool, err := database.NewPostgresPool(startupCtx, database.Config{
		ConnString:        os.Getenv("DATABASE_URL"),
		MaxConns:          10,
		MinConns:          2,
		MaxConnLifetime:   time.Hour,
		MaxConnIdleTime:   30 * time.Minute,
		HealthCheckPeriod: time.Minute,
	})
	if err != nil {
		log.Fatalf("database: %v", err)
	}
	defer pool.Close()

	log.Println("postgres pool is ready")

	// router := router.New(pool)
	// srv := &http.Server{Addr: ":8080", Handler: router}
	// log.Fatal(srv.ListenAndServe())
}

Angka pool menentukan throughput, latency, dan keamanan database

Pool bukan sekadar hidup atau mati. Angka pool menentukan bagaimana API menjaga throughput, latency, dan keamanan database di bawah beban nyata.

Selain tiga di atas, ada MaxConnIdleTime (berapa lama koneksi boleh nganggur sebelum ditutup) dan HealthCheckPeriod (seberapa sering pool memeriksa kesehatan koneksi idle). Kombinasi lifetime dan idle time membuat pool tidak menyimpan koneksi basi yang sudah ditolak server.

internal/config/database.go (contoh nilai baseline)Salin
cfg := database.Config{
	ConnString:        os.Getenv("DATABASE_URL"),
	MaxConns:          10,
	MinConns:          2,
	MaxConnLifetime:   time.Hour,
	MaxConnIdleTime:   30 * time.Minute,
	HealthCheckPeriod: time.Minute,
}

Baseline angka untuk proyek skincare

Untuk tahap belajar dan staging kecil, mulai dari MaxConns=10 dan MinConns=2. Jangan buru-buru menaikkan. Saat traffic naik, ukur dulu empat hal sebelum mengubah angka: query lambat, penggunaan CPU database, jumlah koneksi aktif di server, dan waktu tunggu acquire pool (EmptyAcquireWaitTime dari pool.Stat()).

Pinjam koneksi fisik, lalu wajib kembalikan

Untuk query biasa, pool meminjam dan mengembalikan koneksi otomatis di balik Query, QueryRow, dan Exec. Tetapi kadang kamu butuh memegang satu koneksi fisik secara eksplisit, dan di situlah Acquire dan Release masuk.

Kapan tidak perlu Acquire

Sebagian besar repository tidak perlu menyentuh Acquire sama sekali. Saat kamu memanggil pool.QueryRow(ctx, ...), pool sudah otomatis acquire sebuah koneksi, menjalankan query, dan release koneksi itu begitu hasil selesai dibaca. Inilah jalur normal yang dipakai 95 persen kode kita.

internal/product/repository.go (jalur normal, tanpa Acquire manual)Salin
// Pool meng-acquire dan me-release koneksi sendiri di balik QueryRow.
var p Product
err := r.pool.QueryRow(ctx, query, slug).Scan(&p.ID, &p.Name, &p.PriceRupiah)

Kapan benar-benar perlu Acquire

Acquire baru kamu butuhkan ketika beberapa operasi harus berjalan di koneksi fisik yang sama. Tiga kasus khas: menjalankan beberapa statement yang bergantung pada session state yang sama, memakai LISTEN/NOTIFY, atau menjalankan perintah SET lalu beberapa query yang harus melihat efeknya. Untuk transaksi, kamu tidak perlu Acquire manual karena pool.Begin(ctx) sudah memegang satu koneksi sepanjang transaksi (dibahas tuntas di modul transaksi).

internal/inventory/repository.go (Acquire eksplisit untuk session state)Salin
func (r *Repository) ReadAvailableWithTimeout(ctx context.Context, variantID int64) (int, error) {
	conn, err := r.pool.Acquire(ctx)
	if err != nil {
		return 0, fmt.Errorf("acquire conn: %w", err)
	}
	defer conn.Release() // WAJIB: kembalikan koneksi apa pun yang terjadi

	// SET berlaku pada koneksi ini saja (session state), jadi query berikutnya
	// harus jalan di koneksi yang sama agar melihat efek SET. Pakai SET biasa,
	// bukan SET LOCAL, karena SET LOCAL hanya hidup di dalam satu transaksi.
	if _, err := conn.Exec(ctx, "SET statement_timeout = '3s'"); err != nil {
		return 0, fmt.Errorf("set timeout: %w", err)
	}

	var available int
	err = conn.QueryRow(ctx,
		`SELECT quantity_available FROM inventories WHERE variant_id = $1`,
		variantID,
	).Scan(&available)
	if err != nil {
		return 0, fmt.Errorf("read inventory: %w", err)
	}

	return available, nil
}

Constructor injection, bukan global magic

Setelah pool dibuat di startup, repository menerima pool lewat constructor, bukan membuat koneksi sendiri atau membaca environment sendiri.

Di Go, dependency injection sering sesederhana menerima dependency lewat parameter constructor. Tidak perlu container besar seperti sebagian ekosistem PHP. Tujuannya sama: dependency terlihat jelas, mudah diuji, dan lifecycle tetap dipegang oleh main.go. Perhatikan struct Product memakai PriceRupiah int64 dengan kolom price_rupiah, sesuai konvensi uang proyek (selalu integer rupiah, tidak pernah float).

internal/product/repository.goSalin
package product

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"
)

type Product struct {
	ID          int64     `json:"id"`
	Slug        string    `json:"slug"`
	Name        string    `json:"name"`
	PriceRupiah int64     `json:"price"`
	Status      string    `json:"status"`
	CreatedAt   time.Time `json:"created_at"`
}

type Repository struct {
	pool *pgxpool.Pool
}

func NewRepository(pool *pgxpool.Pool) *Repository {
	return &Repository{pool: pool}
}

func (r *Repository) FindActiveBySlug(ctx context.Context, slug string) (*Product, error) {
	const query = `
		SELECT pv.id, p.slug, p.name, pv.price_rupiah, p.status, p.created_at
		FROM products p
		JOIN product_variants pv ON pv.product_id = p.id
		WHERE p.slug = $1 AND p.status = 'active' AND pv.is_active = true
		ORDER BY pv.price_rupiah ASC
		LIMIT 1
	`

	var prod Product
	err := r.pool.QueryRow(ctx, query, slug).Scan(
		&prod.ID,
		&prod.Slug,
		&prod.Name,
		&prod.PriceRupiah,
		&prod.Status,
		&prod.CreatedAt,
	)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil, nil
		}
		return nil, fmt.Errorf("find active product by slug: %w", err)
	}

	return &prod, nil
}

Pool jadi batas antara kode Go dan koneksi fisik

Repository tidak perlu memilih koneksi manual untuk query sederhana. pgxpool akan meminjam dan mengembalikan koneksi di balik method seperti QueryRow dan Exec, sambil membawa ctx agar pembatalan tetap mengalir.

sequenceDiagram
  participant FE as React Client
  participant API as Go Handler
  participant SVC as Product Service
  participant REPO as Product Repository
  participant POOL as pgxpool
  participant DB as PostgreSQL
  FE->>API: GET /v1/products/serum-niacinamide
  API->>SVC: GetProduct(ctx, slug)
  SVC->>REPO: FindActiveBySlug(ctx, slug)
  REPO->>POOL: QueryRow(ctx, sql, slug)
  POOL->>POOL: acquire koneksi idle
  POOL->>DB: kirim query lewat koneksi pinjaman
  DB-->>POOL: row produk
  POOL->>POOL: release koneksi setelah Scan
  POOL-->>REPO: hasil Scan
  REPO-->>SVC: *Product
  SVC-->>API: ProductResponse
  API-->>FE: 200 JSON

Gambar 1. Pool menjadi batas antara kode Go dan koneksi fisik PostgreSQL. Acquire dan release terjadi otomatis di dalam satu pemanggilan QueryRow.

Untuk query sederhana, pakai pool.QueryRow, pool.Query, atau pool.Exec. Untuk transaksi checkout, kita akan memakai pool.Begin atau pool.BeginTx di modul transaksi, karena seluruh operasi order, payment, dan inventory harus berada dalam satu transaction boundary dan satu koneksi.

Pool punya state internal yang berputar

Setiap koneksi di dalam pool berpindah antara beberapa keadaan. Memahami siklus ini membantu kamu membaca angka pool.Stat() nanti dan mengerti apa yang terjadi saat pool penuh.

stateDiagram-v2
  [*] --> idle: pool dibuat, MinConns dipanaskan
  idle --> acquired: Acquire (query masuk)
  acquired --> idle: Release (query selesai)
  idle --> closed: lifetime / idle time habis
  acquired --> closing: pool.Close() dipanggil
  idle --> closing: pool.Close() dipanggil
  closing --> [*]: semua koneksi dilepas
  closed --> [*]
  note right of acquired: Saat semua koneksi acquired dan jumlahnya MaxConns,<br/>Acquire berikutnya menunggu sampai ada yang Release.

Gambar 2. Lifecycle koneksi pool. Koneksi idle dipinjam menjadi acquired, dikembalikan menjadi idle, dan akhirnya ditutup karena lifetime habis atau pool ditutup.

Buktikan database benar-benar siap, bukan sekadar proses hidup

Proses Go yang hidup belum tentu siap melayani. Endpoint /healthz yang melakukan Ping membuktikan bahwa database benar-benar terjangkau, dan pool.Stat() membuka isi pool untuk monitoring.

Di production (Docker, ECS, Kubernetes), platform memanggil endpoint readiness secara berkala untuk memutuskan apakah sebuah instance layak menerima trafik. Endpoint itu harus benar-benar menyentuh database, bukan sekadar membalas 200 karena proses hidup. Jika database mati, instance harus jujur melaporkan dirinya tidak siap agar load balancer berhenti mengirim request ke sana.

internal/database/postgres.go (tambahan helper)Salin
// Ping membungkus pool.Ping dengan timeout pendek khusus health check,
// agar probe tidak ikut menggantung saat database lambat.
func Ping(ctx context.Context, pool *pgxpool.Pool) error {
	pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
	defer cancel()
	return pool.Ping(pingCtx)
}

internal/health/handler.goSalin
package health

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

	"github.com/jackc/pgx/v5/pgxpool"

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

type Handler struct {
	pool *pgxpool.Pool
}

func NewHandler(pool *pgxpool.Pool) *Handler {
	return &Handler{pool: pool}
}

// Readiness memastikan database benar-benar terjangkau sebelum membalas 200.
func (h *Handler) Readiness(w http.ResponseWriter, r *http.Request) {
	if err := database.Ping(r.Context(), h.pool); err != nil {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusServiceUnavailable)
		_ = json.NewEncoder(w).Encode(map[string]string{
			"status": "unavailable",
			"db":     "down",
		})
		return
	}

	stat := h.pool.Stat()
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	_ = json.NewEncoder(w).Encode(map[string]any{
		"status":         "ok",
		"db":             "up",
		"total_conns":    stat.TotalConns(),
		"acquired_conns": stat.AcquiredConns(),
		"idle_conns":     stat.IdleConns(),
		"max_conns":      stat.MaxConns(),
	})
}

Route-nya dipasang di luar grup auth, karena probe platform tidak membawa JWT. Bentuk /healthz ini juga yang dipakai stub curl -i http://localhost:8080/healthz di modul sebelumnya, sekarang dengan isi yang nyata.

internal/router/router.go (potongan)Salin
health := health.NewHandler(pool)
r.Get("/healthz", health.Readiness)

Membaca pool.Stat untuk monitoring

pool.Stat() mengembalikan snapshot keadaan pool. Beberapa angka yang paling berguna untuk memutuskan apakah pool kekecilan atau bocor:

Selesaikan request yang sedang jalan, lalu tutup pool dengan rapi

Saat aplikasi di-deploy ulang atau di-scale down, platform mengirim sinyal berhenti. Graceful shutdown menyelesaikan request yang sedang berjalan dulu, baru menutup pool, agar tidak ada request yang terpotong di tengah.

Kebalikan dari graceful shutdown adalah aplikasi yang langsung mati saat menerima SIGTERM. Request yang sedang menulis order ke database bisa terpotong, koneksi tidak dilepas rapi, dan client menerima error koneksi terputus. Go punya pola standar untuk ini: tangkap sinyal lewat signal.NotifyContext, lalu srv.Shutdown(ctx) dan pool.Close().

cmd/api/main.go (versi lengkap dengan graceful shutdown)Salin
package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/kamu/skincare-backend/internal/database"
	"github.com/kamu/skincare-backend/internal/router"
)

func main() {
	// 1. Context yang dibatalkan saat menerima SIGINT (Ctrl+C) atau SIGTERM (deploy).
	rootCtx, stop := signal.NotifyContext(context.Background(),
		syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	// 2. Pool dibuat dengan timeout startup terpisah.
	startupCtx, cancel := context.WithTimeout(rootCtx, 10*time.Second)
	defer cancel()

	pool, err := database.NewPostgresPool(startupCtx, database.Config{
		ConnString:      os.Getenv("DATABASE_URL"),
		MaxConns:        10,
		MinConns:        2,
		MaxConnLifetime: time.Hour,
	})
	if err != nil {
		log.Fatalf("database: %v", err)
	}
	defer pool.Close() // jaring pengaman terakhir kalau jalur shutdown gagal

	srv := &http.Server{
		Addr:    ":8080",
		Handler: router.New(pool),
	}

	// 3. Jalankan server di goroutine agar main bisa menunggu sinyal.
	go func() {
		log.Println("server listening on :8080")
		if err := srv.ListenAndServe(); err != nil &&
			!errors.Is(err, http.ErrServerClosed) {
			log.Fatalf("listen: %v", err)
		}
	}()

	// 4. Blok di sini sampai sinyal datang, lalu rootCtx.Done() tertutup.
	<-rootCtx.Done()
	log.Println("shutdown signal received")

	// 5. Beri request yang sedang jalan waktu menyelesaikan diri.
	shutdownCtx, cancelShutdown := context.WithTimeout(
		context.Background(), 15*time.Second)
	defer cancelShutdown()

	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Printf("graceful shutdown failed: %v", err)
	}

	// 6. Setelah server berhenti menerima request, baru tutup pool.
	pool.Close()
	log.Println("postgres pool closed, bye")
}

sequenceDiagram
  participant OS as OS / Platform
  participant APP as main goroutine
  participant SRV as http.Server
  participant POOL as pgxpool
  OS->>APP: SIGTERM (deploy / scale down)
  APP->>APP: rootCtx.Done() tertutup
  APP->>SRV: srv.Shutdown(ctx)
  SRV->>SRV: tolak request baru, selesaikan yang sedang jalan
  SRV-->>APP: semua handler selesai
  APP->>POOL: pool.Close()
  POOL->>POOL: lepas semua koneksi
  POOL-->>APP: selesai
  APP-->>OS: exit 0

Gambar 3. Urutan graceful shutdown. Server berhenti dan menuntaskan request lebih dulu, baru pool ditutup, sehingga tidak ada query yang terpotong.

Buat pool, ping, query pertama, dan readiness yang nyata

Latihan ini memastikan kamu bisa membuat pool, ping database, menjalankan query pertama, dan membuktikan kesiapan lewat /healthz.

TerminalSalin
go get github.com/jackc/pgx/v5
export DATABASE_URL='postgres://skincare:secret@localhost:5432/skincare_dev?sslmode=disable'
go run ./cmd/api

Seed satu produk untuk dicoba

Kalau tabel katalog dari modul migrasi sudah ada, isi satu brand, satu produk, dan satu varian dengan harga. Ingat, harga ada di product_variants.price_rupiah, bukan di products.

seed-product.sqlSalin
INSERT INTO brands (slug, name)
VALUES ('glow-lab', 'Glow Lab')
ON CONFLICT (slug) DO NOTHING;

INSERT INTO products (brand_id, slug, name, status)
VALUES (
	(SELECT id FROM brands WHERE slug = 'glow-lab'),
	'serum-niacinamide',
	'Serum Niacinamide 10%',
	'active'
)
ON CONFLICT (slug) DO NOTHING;

INSERT INTO product_variants (product_id, sku, variant_name, price_rupiah, is_active)
VALUES (
	(SELECT id FROM products WHERE slug = 'serum-niacinamide'),
	'GLOW-NIA-30',
	'30 ml',
	129000,
	true
)
ON CONFLICT (sku) DO NOTHING;

Cek kesiapan dan query pertama

Setelah aplikasi jalan, panggil /healthz. Jika database hidup, kamu akan melihat angka pool yang nyata dari pool.Stat().

TerminalSalin
curl -i http://localhost:8080/healthz

Contoh respons /healthz saat siapSalin
{
  "status": "ok",
  "db": "up",
  "total_conns": 2,
  "acquired_conns": 0,
  "idle_conns": 2,
  "max_conns": 10
}

Kalau query repository mengembalikan nil karena ErrNoRows, itu bukan error fatal, melainkan kondisi produk tidak ditemukan. Pola if errors.Is(err, pgx.ErrNoRows) inilah yang membedakan “data tidak ada” dari “query gagal”.

Bug koneksi sering soal lifecycle, bukan SQL

Banyak bug koneksi database di Go bukan karena SQL salah, tetapi karena lifecycle pool tidak dipahami. Ini daftar jebakan yang paling sering terbawa dari kebiasaan Node atau Laravel.

Koneksi database yang benar adalah fondasi semua fitur berikutnya: katalog produk, cart, checkout, payment, dan admin inventory. Pool yang hemat, teramati, dan mati dengan rapi membuat sisa Roadmap 3 berdiri di atas tanah yang kokoh.

Di proyek online shop skincare, pool ini akan dipakai oleh repository products, product_variants, carts, orders, payments, dan shipments. Setelah koneksi siap dan teramati, langkah berikutnya adalah menjalankan query baca dengan pgx: Query, QueryRow, Scan ke struct, menangani ErrNoRows, lalu memetakan banyak row menjadi slice dengan pgx.CollectRows. Setelah itu kita masuk ke write, transaksi checkout, dan repository penuh.