6 Inisialisasi Proyek Go untuk GraphQL

GraphQL semakin banyak digunakan sebagai solusi API modern berkat fleksibilitas dan efisiensinya dalam pengambilan data. Go (Golang), dengan performanya yang impresif dan ekosistem tooling yang matang, menjadi salah satu bahasa favorit untuk membangun server GraphQL berskala produksi.

Namun, seperti banyak stack baru, memulai proyek GraphQL dengan Go bisa terasa overkill jika kita tidak tahu ekosistem tooling, konvensi struktur direktori, atau teknik dependency management yang tepat. Artikel ini akan membedah 6 langkah inisialisasi proyek Go untuk GraphQL—mulai dari setup project hingga API siap diuji.

1. Proyek Scaffolding dan Dependency Management

Langkah pertama adalah membuat struktur direktorium yang rapi dan menginisialisasi dependency management.

Struktur Direktori Dasar

my-graphql-app/
├── cmd/
│   └── server/
│       └── main.go
├── internal/
│   ├── graphql/
│   └── model/
├── go.mod
└── go.sum

Inisialisasi Proyek dengan Go Modules

go mod init github.com/username/my-graphql-app

Menambah Dependency Minimum

Library populer untuk GraphQL di Go adalah 99designs/gqlgen:

go get github.com/99designs/gqlgen

Gqlgen menyediakan generator schema dan sangat memudahkan pembuatan resolvers maupun model.

Tabel: Perbandingan Library GraphQL di Go

2. Definisikan Skema GraphQL (schema.graphqls)

GraphQL bersifat “schema-first”, jadi mulailah dengan mendefinisikan skema:

Contoh schema.graphqls

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

type Query {
  users: [User!]!
  user(id: ID!): User
}

Struktur File:

internal/graphql/
└── schema.graphqls

Dalam desain nyata, skema sebaiknya modular agar mudah scaling: misal user.graphqls, product.graphqls, dst.

3. Generate Model & Resolver dengan Gqlgen

Setelah schema siap, jalankan generator gqlgen yang akan membuat file blueprint dasar Go:

go run github.com/99designs/gqlgen generate

Hasilnya:

internal/graphql/
├── generated.go
├── models_gen.go
├── resolver.go
└── schema.resolvers.go

• generated.go: kode auto-generate yang merepresentasikan semua operasi GraphQL.
• models_gen.go: struct Go hasil kompilasi dari definisi di schema.
• resolver.go dan schema.resolvers.go: tempat implementasi business logic.

4. Implementasi Resolver

Resolver adalah “jantung” server GraphQL—tempat setiap query, mutation, dan subscription dieksekusi.

Contoh Implementasi Query Resolver

// internal/graphql/resolver.go
package graphql

type Resolver struct {
    users []*model.User
}

// internal/graphql/schema.resolvers.go
func (r *queryResolver) Users(ctx context.Context) ([]*model.User, error) {
    return r.Resolver.users, nil
}

func (r *queryResolver) User(ctx context.Context, id string) (*model.User, error) {
    for _, user := range r.Resolver.users {
        if user.ID == id {
            return user, nil
        }
    }
    return nil, nil
}

Simulasi Response Request

• Query:

  {
    users {
      id
      name
      email
    }
  }
  

• Response:

  {
    "data": {
      "users": [
        {"id": "1", "name": "Andi", "email": "andi@domain.com"},
        {"id": "2", "name": "Budi", "email": "budi@domain.com"}
      ]
    }
  }
  

5. Setup Server dan Routing

Agar server bisa diakses, setup HTTP handler. Biasanya, mux populer seperti net/http atau chi digunakan.

Contoh Minimal Server

// cmd/server/main.go
package main

import (
    "log"
    "net/http"
    "github.com/99designs/gqlgen/graphql/handler"
    "github.com/99designs/gqlgen/graphql/playground"
    "github.com/username/my-graphql-app/internal/graphql"
)

func main() {
    srv := handler.NewDefaultServer(graphql.NewExecutableSchema(graphql.Config{Resolvers: &graphql.Resolver{}}))
    
    http.Handle("/graphql", srv)
    http.Handle("/", playground.Handler("GraphQL playground", "/graphql"))

    log.Println("Server started at http://localhost:8080/")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Akses ke GraphQL Playground dapat dicapai pada http://localhost:8080/.

6. Menyiapkan Konfigurasi dan Environment

Pemisahan konfigurasi membuat sistem lebih scalable dan mudah deployment ke berbagai environment (dev, staging, prod).

Standard: Gunakan .env untuk environment variable

Install package loader seperti godotenv:

go get github.com/joho/godotenv

Contoh Penggunaan

import "github.com/joho/godotenv"

func init() {
    godotenv.Load() // akan membaca file .env pada root project
}

.env Example

PORT=8080
DATABASE_URL=postgres://user:pass@localhost:5432/dbname

Alur Inisialisasi Proyek GraphQL Go

Mari kita visualisasikan dengan diagram mermaid:

flowchart TD
    A[Mulai] --> B[Inisialisasi Go Modules]
    B --> C[Buat struktur direktori]
    C --> D[Definisikan schema GraphQL]
    D --> E[Generate code dengan gqlgen]
    E --> F[Implementasi resolver]
    F --> G[Setup server HTTP]
    G --> H[Konfigurasi environment]
    H --> I[Selesai]

Kesimpulan

Inisialisasi proyek Go untuk GraphQL sangat straightforward bila mengikuti 6 langkah berikut:

1. Scaffolding & Dependency: Menyusun struktur folder dan install dependency.
2. Schema: Mendesain schema awal sesuai kebutuhan aplikasi.
3. Auto Generate Model & Resolver: Menggunakan gqlgen untuk men-generate kode boilerplate.
4. Implementasi Resolver: Mengkodekan logic query/mutation sesuai kebutuhan.
5. Server: Setup router dan server HTTP agar GraphQL terexpose.
6. Konfigurasi: Manage konfigurasi lingkungan lewat environment variables.

Dengan runtime Go yang efisien, schema statis yang type-safe, deployment mudah, serta tooling mature, stack ini menjadi salah satu pilihan andalan untuk backend modern berbasis GraphQL.

Sudah siap mencoba stack ini di proyek Anda berikutnya?

Referensi Tambahan

• gqlgen documentation
• Praktik terbaik struktur folder Go - Go Blog
• GraphQL official docs

Jika ada pertanyaan atau pengalaman lain seputar inisialisasi proyek GraphQL dengan Go, jangan ragu untuk berbagi di komentar!