# graphql-go — Full GraphQL Implementation for Go

> A complete implementation of the GraphQL specification in Go, enabling developers to build type-safe GraphQL servers with idiomatic Go patterns and strong concurrency support.

## Install

Save in your project root:

# graphql-go — Full GraphQL Implementation for Go

## Quick Use
```bash
go get github.com/graphql-go/graphql
```
```go
package main

import (
    "encoding/json"
    "fmt"
    "github.com/graphql-go/graphql"
)

func main() {
    fields := graphql.Fields{
        "hello": &graphql.Field{
            Type: graphql.String,
            Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                return "Hello, world!", nil
            },
        },
    }
    rootQuery := graphql.ObjectConfig{Name: "Query", Fields: fields}
    schema, _ := graphql.NewSchema(graphql.SchemaConfig{Query: graphql.NewObject(rootQuery)})
    result := graphql.Do(graphql.Params{Schema: schema, RequestString: "{ hello }"})
    j, _ := json.Marshal(result)
    fmt.Println(string(j))
}
```

## Introduction
graphql-go is a full implementation of the GraphQL specification written in pure Go, providing the core engine for building GraphQL servers in the Go ecosystem. It follows an approach similar to graphql-js, offering a programmatic API for defining schemas, resolving fields, and executing queries. Its design prioritizes compatibility with the official GraphQL spec while embracing Go idioms for concurrency and type safety.

## What graphql-go Does
- Implements the complete GraphQL specification including queries, mutations, subscriptions, and introspection
- Provides a code-first schema definition API using Go structs and functions
- Executes queries with automatic concurrent field resolution leveraging Go goroutines
- Validates incoming queries against the schema before execution
- Supports custom scalar types, enums, interfaces, unions, and input objects

## Architecture Overview
graphql-go mirrors the architecture of the reference JavaScript implementation. The type system is defined programmatically using Go structs like `graphql.ObjectConfig` and `graphql.Field`. Schema construction validates type consistency at startup. The execution engine traverses the parsed query AST, invoking resolver functions for each field. Resolvers run concurrently by default — sibling fields at the same level execute in parallel goroutines, making efficient use of Go's concurrency model. The parser and validator follow the GraphQL specification rules, and introspection is built in.

## Self-Hosting & Configuration
- Add to your project with `go get github.com/graphql-go/graphql`
- Define your schema using Go types and resolver functions — no schema files or code generation required
- Pair with `graphql-go/handler` for a ready-made HTTP handler compatible with net/http, Chi, Gorilla, or Gin
- Configure custom error formatting and extensions through the handler middleware
- No external dependencies or configuration files — everything is defined in Go code

## Key Features
- Pure Go implementation with zero CGo dependencies for easy cross-compilation
- Concurrent field resolution out of the box, executing sibling resolvers in parallel goroutines
- Full introspection support enabling integration with GraphiQL, GraphQL Voyager, and other tools
- Comprehensive type system supporting all GraphQL types including custom scalars and directives
- Active maintenance with spec compliance tracked against the official GraphQL test suite

## Comparison with Similar Tools
- **gqlgen** — a code-generation-based Go GraphQL library that generates resolvers from schema files; graphql-go uses a runtime-defined schema approach without code generation
- **graphql-js** — the JavaScript reference implementation; graphql-go provides the same specification coverage for the Go ecosystem
- **99designs/gqlgen** — emphasizes schema-first development with generated Go types; graphql-go is code-first with manual schema construction
- **graph-gophers/graphql-go** — another Go implementation focused on struct-based resolvers and type safety; graphql-go/graphql follows a more flexible resolver-function pattern
- **Juniper** — the Rust GraphQL library; graphql-go offers a comparable feature set in Go's simpler type system

## FAQ
**Q: Should I use graphql-go or gqlgen?**
A: graphql-go is a good fit if you prefer code-first schema definition and runtime flexibility. gqlgen is better if you want schema-first development with compile-time type checking via code generation. Both are production-ready.

**Q: How does graphql-go handle N+1 query problems?**
A: You can integrate a DataLoader library (such as graph-gophers/dataloader) in your resolvers to batch and cache database calls, preventing the N+1 problem common in GraphQL APIs.

**Q: Does graphql-go support subscriptions?**
A: The core library supports the subscription type in schemas. For real-time transport, you pair it with a WebSocket handler that manages subscription lifecycle and pushes results.

**Q: Is graphql-go production-ready?**
A: Yes. It is used in production by multiple organizations and maintains spec compliance with the official GraphQL specification. Its concurrent resolver execution makes it efficient for high-throughput services.

## Sources
- https://github.com/graphql-go/graphql
- https://pkg.go.dev/github.com/graphql-go/graphql

---
Source: https://tokrepo.com/en/workflows/asset-b3094293
Author: AI Open Source