14 Menghubungkan Skema dan Resolver ke HTTP Handler

title: 14 Menghubungkan Skema dan Resolver ke HTTP Handler date: 2024-06-15 author: Gede Eka Pradipta

Pada artikel-artikel sebelumnya, kita telah membahas bagaimana mendesain schema dan membangun resolver untuk aplikasi GraphQL. Kini, saatnya melangkah ke langkah krusial yang berikutnya: menghubungkan schema dan resolver ke HTTP handler, sehingga dapat diakses lewat request klien seperti Apollo, Postman, atau bahkan browser.

Ini adalah tahap di mana kode backend Anda bisa mulai “bicara” dengan dunia luar melalui HTTP. Artikel ini akan membahas skema koneksi antara schema, resolver, sampai ke lapisan handler. Kita juga akan melakukan simulasi request-response, melihat kode nyata, tabel komponen, serta diagram alur data menggunakan mermaid.

Apa Itu HTTP Handler dalam Konteks GraphQL?

Pada aplikasi web berbasis GraphQL, HTTP handler adalah pintu gerbang utama yang menerima permintaan masuk dari klien dalam bentuk query/mutation, kemudian meneruskan permintaan tersebut ke schema untuk diproses oleh resolver, sebelum akhirnya mengirimkan respon kembali ke klien.

Jika Anda sudah terbiasa dengan REST, analog HTTP handler di REST adalah controller atau routing handler. Namun, dalam GraphQL, handler biasanya hanya satu endpoint (misal /graphql), di mana seluruh query/mutation diparsing dan dijalankan berdasarkan skema dan resolver.

Alur Data: Diagram Skema ke HTTP Handler

Mari kita lihat dulu diagram flow berikut:

flowchart TD
    subgraph Client
        A[GraphQL Request] 
    end
    subgraph Server
        B[HTTP Handler / Endpoint ("/graphql")]
        C[Parse Query]
        D[Validasi ke Schema]
        E[Resolver]
        F[Generate Response]
    end
    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> A

Penjelasan alur:

1. Client mengirim query/mutation ke HTTP handler /graphql.
2. Handler menerima dan memparsing query.
3. Query divalidasi terhadap schema yang sudah didaftarkan.
4. Setiap field pada query dieksekusi resolver-nya.
5. Data hasil resolver dikumpulkan, diformat (biasanya ke JSON), dan dikirim balik ke client.

Komponen yang Diperlukan

Contoh Praktis: Go, gqlgen, dan net/http

Mari kita terapkan pada lingkungan Go menggunakan gqlgen, salah satu library GraphQL populer. Skema di bawah akan sangat mirip dengan implementasi pada bahasa lain dengan penyesuaian kecil.

1. Definisikan Schema (schema.graphqls)

type Query {
    hello: String!
    user(id: ID!): User
}

type User {
    id: ID!
    name: String!
    email: String!
}

2. Buat Resolver

Misalkan kita sudah punya resolver sederhana:

type Resolver struct{}

func (r *queryResolver) Hello(ctx context.Context) (string, error) {
    return "Hello, World!", nil
}

func (r *queryResolver) User(ctx context.Context, id string) (*model.User, error) {
    // Simulasi: hardcode user
    if id == "1" {
        return &model.User{ID: "1", Name: "Eka", Email: "eka@mail.com"}, nil
    }
    return nil, errors.New("user not found")
}

3. Hubungkan ke HTTP Handler

Nah, di sinilah “penyambungan” antara schema, resolver, dan handler HTTP dilakukan.

package main

import (
    "log"
    "net/http"
    "github.com/99designs/gqlgen/graphql/handler"
    "github.com/99designs/gqlgen/graphql/playground"
    "github.com/yourrepo/yourproject/graph"
    "github.com/yourrepo/yourproject/graph/generated"
)

func main() {
    srv := handler.NewDefaultServer(generated.NewExecutableSchema(
        generated.Config{Resolvers: &graph.Resolver{}},
    ))

    http.Handle("/graphql", srv)
    http.Handle("/", playground.Handler("GraphQL playground", "/graphql"))

    log.Fatal(http.ListenAndServe(":8080", nil))
}

Penjelasan:

• handler.NewDefaultServer: Membuat GraphQL handler yang sudah terhubung ke schema & resolver.
• Config Resolvers: Mendaftarkan implementasi fungsi resolver ke server.
• http.Handle: Satu endpoint untuk playground, satu lagi untuk handler sesungguhnya.

Simulasi Request & Response

Mari simulasikan request dari client:

Request

POST /graphql
{
  "query": "{ user(id: \"1\") { id name email } }"
}

Handler Flow

• Menerima POST /graphql.
• Payload di-parse.
• Menemukan root field user.
• Mencari resolver User.
• Mengeksekusi function dengan argumen id="1".
• Mendapat data, format ke JSON.

Response

{
  "data": {
    "user": {
      "id": "1",
      "name": "Eka",
      "email": "eka@mail.com"
    }
  }
}

Tabel: Keterkaitan Komponen

Checklist Konektivitas Skema & Handler

Best Practice

• Validasi schema dan resolver: Gqlgen melakukan binding schema ke resolver saat build, menghindari mismatch.
• Context-aware handler: Handler bisa inject context (auth/session) untuk setiap request.
• Middleware: Layer auth/logging/metrics bisa diintersep sebelum handler memanggil resolver.

Penutup

Menghubungkan schema dan resolver ke HTTP handler adalah fondasi arsitektur aplikasi GraphQL, baik di Go, Node.js, atau platform lain. Proses ini mengintegrasikan seluruh layer logika back-end menjadi sebuah endpoint terpusat, memudahkan maintainability, debugging, maupun pengujian.

Setelah paham prinsip dasar ini, Anda bisa mengeksplorasi berbagai pattern seperti custom middleware, batching, dan error handling yang efisien—semuanya berawal dari satu titik: koneksi antara schema, resolver, dan HTTP handler.

Happy coding! 🚀