문서가격블로그
문의하기
로그인무료로 가입하기
Back to Tech Articles

Building a Type-Safe Schema-First GraphQL Server in Go with gqlgen

7월 01, 2025
# Misc

Emily Parker

Product Engineer · Leapcell

이 게시물은 日本語, 한국어 및 Deutsch에서도 볼 수 있습니다.
Cover of "Building a Type-Safe Schema-First GraphQL Server in Go with gqlgen"

Building a robust and maintainable API is a cornerstone of modern software development. As applications grow in complexity, the need for efficient data fetching, clear contracts between client and server, and simplified development workflows becomes paramount. Traditionally, REST APIs have been a popular choice, but they often present challenges such as over-fetching, under-fetching, and the complexity of managing multiple endpoints. This is where GraphQL shines, offering a flexible and powerful alternative. However, simply using GraphQL isn't enough; to truly leverage its benefits, especially in a strongly typed language like Go, embracing a type-safe, schema-first approach is crucial. This article will guide you through the process of building such a server using gqlgen, a powerful tool that brings the best of GraphQL to the Go ecosystem.

Understanding the Core Concepts

Before diving into the implementation, let's establish a clear understanding of the fundamental concepts that underpin our server development.

GraphQL: At its heart, GraphQL is a query language for your API and a runtime for fulfilling those queries with your existing data. Unlike REST, where you typically hit multiple endpoints to gather data, GraphQL allows clients to request exactly the data they need in a single query, structured hierarchically. This minimizes network requests and over-fetching.

Schema-First Development: This paradigm emphasizes defining your GraphQL schema as the single source of truth for your API. You write the schema in GraphQL's Schema Definition Language (SDL) first, specifying all the types, fields, and operations (queries, mutations, subscriptions) your API supports. Tools like gqlgen then use this schema to generate significant portions of your server-side code, ensuring that your implementation adheres strictly to the defined contract. This approach fosters clear communication between frontend and backend teams and simplifies API evolution.

Type Safety: In strongly typed languages like Go, type safety is about ensuring that variables and expressions have a well-defined type at compile time, preventing type-related errors and making code more predictable and maintainable. When combined with schema-first development, gqlgen leverages the GraphQL schema's type definitions to generate Go structs and interfaces, effectively mapping your GraphQL types to Go types. This provides end-to-end type safety, from the client's query to your Go resolver functions, catching potential issues early in the development cycle.

gqlgen: This is a Go library that generates a GraphQL server from a GraphQL schema. It's highly opinionated towards schema-first development and focuses on providing a powerful and flexible code generation engine, allowing developers to concentrate on implementing business logic rather than boilerplate.

Building Your GraphQL Server with gqlgen

Let's walk through building a simple GraphQL API for managing a list of Todo items.

Setting Up Your Project

First, ensure you have Go installed. Then, create a new Go module:

mkdir todo-graphql-server
cd todo-graphql-server
go mod init todo-graphql-server

Next, install gqlgen and its dependencies:

go get github.com/99designs/gqlgen
go get github.com/99designs/gqlgen/cmd@latest

Now, initialize gqlgen within your project. This will create essential files: gqlgen.yml, graph/schema.resolvers.go, graph/schema.graphqls, and graph/generated.go.

go run github.com/99designs/gqlgen init

Defining the GraphQL Schema

Open graph/schema.graphqls. This file will contain our GraphQL schema definition. Let's define a Todo type and the basic queries and mutations:

# graph/schema.graphqls

type Todo {
  id: ID!
  text: String!
  done: Boolean!
  user: User!
}

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

type Query {
  todos: [Todo!]!
}

type Mutation {
  createTodo(text: String!, userId: ID!): Todo!
  markTodoDone(id: ID!): Todo
}

After updating the schema, run gqlgen generate to update the generated Go code:

go run github.com/99designs/gqlgen generate

This command will update graph/generated.go and graph/model/models_gen.go. models_gen.go will now contain Go structs representing our Todo and User types, and input types if defined. For instance:

// graph/model/models_gen.go

package model

type NewTodo struct {
	Text   string `json:"text"`
	UserID string `json:"userId"`
}

type Todo struct {
	ID   string `json:"id"`
	Text string `json:"text"`
	Done bool   `json:"done"`
	User *User  `json:"user"`
}

type User struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

Notice how gqlgen automatically infers the NewTodo input type for our createTodo mutation based on its arguments.

Implementing Resolvers

The generated graph/schema.resolvers.go file contains a basic skeleton for our resolvers. Resolvers are functions responsible for fetching the data for a specific field in the schema.

Let's modify graph/schema.resolvers.go to implement the logic for createTodo, todos, and markTodoDone. For simplicity, we'll use an in-memory store for our data.

First, define our data store and a way to generate unique IDs, typically in graph/resolver.go:

// graph/resolver.go
package graph

import (
	"context"
	"fmt"
	"math/rand"
	"sync"
	"time"

	"todo-graphql-server/graph/model"
)

// This file will not be regenerated automatically.
//
// It serves as dependency injection for your app, add any dependencies you require here.

type Resolver struct {
	mu    sync.Mutex
	todos []*model.Todo
	users []*model.User
}

func init() {
	rand.Seed(time.Now().UnixNano())
}

var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func randString(n int) string {
	b := make([]rune, n)
	for i := range b {
		b[i] = letterRunes[rand.Intn(len(letterRunes))]
	}
	return string(b)
}

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

Now, let's fill in the resolver logic in graph/schema.resolvers.go:

// graph/schema.resolvers.go
package graph

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.45

import (
	"context"
	"fmt"

	"todo-graphql-server/graph/model"
)

// CreateTodo is the resolver for the createTodo field.
func (r *mutationResolver) CreateTodo(ctx context.Context, text string, userID string) (*model.Todo, error) {
	r.mu.Lock()
	defer r.mu.Unlock()

	user := r.GetUserByID(userID)
	if user == nil {
		return nil, fmt.Errorf("user with ID %s not found", userID)
	}

	newTodo := &model.Todo{
		ID:   randString(8), // Generate a unique ID
		Text: text,
		Done: false,
		User: user,
	}
	r.todos = append(r.todos, newTodo)
	return newTodo, nil
}

// MarkTodoDone is the resolver for the markTodoDone field.
func (r *mutationResolver) MarkTodoDone(ctx context.Context, id string) (*model.Todo, error) {
	r.mu.Lock()
	defer r.mu.Unlock()

	for _, todo := range r.todos {
		if todo.ID == id {
			todo.Done = true
			return todo, nil
		}
	}
	return nil, fmt.Errorf("todo with ID %s not found", id)
}

// Todos is the resolver for the todos field.
func (r *queryResolver) Todos(ctx context.Context) ([]*model.Todo, error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	return r.todos, nil
}

// User is the resolver for the user field.
func (r *todoResolver) User(ctx context.Context, obj *model.Todo) (*model.User, error) {
	// The user is already embedded in the Todo model, so we just return it.
	// In a real application, you might fetch the user from a database here if it's not eager-loaded.
	return obj.User, nil
}

// Mutation returns MutationResolver implementation.
func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }

// Query returns QueryResolver implementation.
func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }

// Todo returns TodoResolver implementation.
func (r *Resolver) Todo() TodoResolver { return &todoResolver{r} }

type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }
type todoResolver struct{ *Resolver }

Notice the generated Todo() resolver for the User field within Todo. This is a field resolver, allowing you to customize how a specific field of a type is resolved. Since our Todo already contains the User object, we simply return it. If the user was stored as just an ID in the Todo struct, we'd fetch the User object from our data store based on that ID here. This flexibility is a key strength of GraphQL.

Setting Up the Server

Finally, we need to set up an HTTP server to expose our GraphQL API. Create a server.go file in the root of your project:

// server.go
package main

import (
	"log"
	"net/http"
	"os"

	"github.com/99designs/gqlgen/graphql/handler"
	"github.com/99designs/gqlgen/graphql/playground"
	"todo-graphql-server/graph"
	"todo-graphql-server/graph/model"
)

const defaultPort = "8080"

func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = defaultPort
	}

	// Initialize our resolver with some dummy data
	resolver := &graph.Resolver{
		todos: []*model.Todo{},
		users: []*model.User{
			{ID: "U1", Name: "Alice"},
			{ID: "U2", Name: "Bob"},
		},
	}

	srv := handler.NewDefaultServer(graph.NewExecutableSchema(graph.Config{Resolvers: resolver}))

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

	log.Printf("Connect to http://localhost:%s/ for GraphQL playground", port)
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

In server.go, we initialize our graph.Resolver and inject it into gqlgen's executable schema. We then set up two HTTP handlers: one for the GraphQL playground (a useful GUI for testing your API) and another for the actual GraphQL endpoint.

Running the Server and Testing

Run your server:

go run server.go

Open your browser to http://localhost:8080/. You'll see the GraphQL Playground.

Let's perform some operations:

Create a Todo:

mutation CreateTodo {
  createTodo(text: "Learn gqlgen", userId: "U1") {
    id
    text
    done
    user {
      name
    }
  }
}

Fetch all Todos:

query GetTodos {
  todos {
    id
    text
    done
    user {
      id
      name
    }
  }
}

Mark a Todo as done (replace TODO_ID with the ID from the createTodo mutation):

mutation MarkTodoDone {
  markTodoDone(id: "TODO_ID") {
    id
    text
    done
    user {
      name
    }
  }
}

You'll observe that the responses are strongly typed and match the structure requested in your queries. gqlgen ensures that your Go resolver functions receive arguments and return values that conform precisely to your GraphQL schema, providing excellent type safety throughout the development process.

Application Scenarios

This type-safe, schema-first approach with gqlgen is ideal for:

  • Large, collaborative teams: The schema acts as a clear contract, helping frontend and backend teams work in parallel and reduce miscommunications.
  • Complex APIs: As your API surface grows, the generated code and type safety help manage complexity and prevent subtle errors.
  • Microservices architectures: GraphQL can act as an API gateway, aggregating data from various microservices. gqlgen makes it straightforward to define a unified schema for this gateway.
  • Public APIs: A well-defined and type-safe schema simplifies client library generation and improves developer experience for API consumers.

Conclusion

Building a type-safe, schema-first GraphQL server in Go with gqlgen offers a powerful combination of development efficiency, robust type checking, and maintainable code. By beginning with your GraphQL schema as the definitive contract, gqlgen eliminates boilerplate and ensures that your Go resolvers are precisely aligned with your API's specifications, leading to fewer bugs and a smoother development experience. This approach provides a solid foundation for any evolving API, bridging the gap between flexible data fetching and inherent Go type safety.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts