How to connect between Graphql and GORM in Golang?

In Go, integrating GraphQL and GORM involves several steps. The primary goal is to leverage GORM as an ORM for database interactions and GraphQL as a query language for building APIs. Here are the detailed steps to achieve this goal:

Step 1: Install Required Packages

First, ensure you have the Go environment installed. Then, install the necessary Go packages for GraphQL and GORM. You can use Go's package manager go get to install these packages:

bash
 go get -u github.com/99designs/gqlgen
 go get -u gorm.io/gorm
 go get -u gorm.io/driver/sqlite

Here, gqlgen is a popular Go GraphQL library, GORM is an object-relational mapping library for Go, and SQLite is used as an example for database setup.

Step 2: Configure GORM

Next, configure GORM to connect to your database. For example, with SQLite, you can configure it as follows:

go
package main

import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

func initDB() *gorm.DB {
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    // Auto-migration mode
    db.AutoMigrate(&Product{})
    return db
}

type Product struct {
    gorm.Model
    Code  string
    Price uint
}

Step 3: Set Up GraphQL

Use gqlgen to generate GraphQL configuration and template files. Run the following command in your project directory:

bash
 go run github.com/99designs/gqlgen init

This generates basic files, including the GraphQL schema definition (schema) and corresponding Go code.

Step 4: Define GraphQL Schema

Define your GraphQL schema in the generated graph/schema.graphqls file. For example:

graphql
type Product {
    id: ID!
    code: String!
    price: Int!
}

 type Query {
    products: [Product!]
}

Step 5: Implement Resolvers

Implement GraphQL resolvers to handle API requests. gqlgen generates the basic resolver structure in graph/schema.resolvers.go.

go
package graph

// This file is generated by gqlgen; fill in the resolver methods.

import (
    "context"
    "your/app/path"
)

 type Resolver struct{
    DB *gorm.DB
}

func (r *queryResolver) Products(ctx context.Context) ([]*model.Product, error) {
    var products []*model.Product
    result := r.DB.Find(&products)
    if result.Error != nil {
        return nil, result.Error
    }
    return products, nil
}

Pass the database connection to the resolver, typically set up during server initialization.

Step 6: Start the Service

Finally, set up and start the GraphQL service using the http package:

go
package main

import (
    "net/http"
    "your/app/path/graph"
    "your/app/path/graph/generated"
)

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

    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(:"8080", nil))
}

These steps demonstrate how to set up a basic API service in Go using GORM and GraphQL. This enables the frontend to leverage GraphQL's powerful features while the backend efficiently interacts with the database through GORM.