Golang Simple GraphQL Subscription Handler

Usage

Subscription node:

var rootSubscriptions = graphql.ObjectConfig{
    Name: "RootSubscriptions",
    Fields: graphql.Fields{
        "serverTime": &graphql.Field{
            Type: graphql.Float,
            Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                err := subhandler.Subscribe(p.Context, "serverTime")
                if p.Source != nil {
                    // We received a event data
                    v, ok := p.Source.(map[string]interface{})
                    if ok && v["time"] != nil {
                        return v["time"], nil
                    }
                }
                // We didn't receive a event data, so resolve normally
                return time.Now().String(), err
            },
        },
    },
}
var rootQuery = graphql.ObjectConfig{
    Name: "RootQuery",
    Fields: graphql.Fields{
        "serverTime": &graphql.Field{
            Type: graphql.Float,
            Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                return time.Now().Unix(), nil
            },
        },
    },
}
var schemaConfig = graphql.SchemaConfig{
    Query:        graphql.NewObject(rootQuery),
    Subscription: graphql.NewObject(rootSubscriptions),
}
func GetSchema() (graphql.Schema, error) {
    return graphql.NewSchema(schemaConfig)
}

Main Code:

package main
import (
    "github.com/asaskevich/EventBus"
    "github.com/graphql-go/handler"
    "github.com/racerxdl/go-subscription-handler/subhandler"
    "net/http"
    "time"
    "fmt"
)
// Create a notifier
type BusNotifier struct {
    bus EventBus.Bus // You can use any pub-sub lib for that
}
func MakeBusNotifier(bus EventBus.Bus) *BusNotifier {
    return &BusNotifier{
        bus: bus,
    }
}
func (bn *BusNotifier) Subscribe(topic string, cb func(data map[string]interface{})) {
    bn.bus.Subscribe(topic, cb)
}
func (bn *BusNotifier) Unsubscribe(topic string, cb func(data map[string]interface{})) {
    bn.bus.Unsubscribe(topic, cb)
}
func (bn *BusNotifier) Notify(topic string, data map[string]interface{}) {
    bn.bus.Publish(topic, data)
}
// Initialize a Sub Handler
func main() {
    schema, _ := GetSchema()
    // Create normal mutation / query handlers
    h := handler.New(&handler.Config{
        Schema:     &schema,
        Pretty:     true,
        Playground: true,
    })
    // Initialize our notifier
    notifier := MakeBusNotifier(EventBus.New())
    // Create a goroutine to send notifications through notifier
    go func() {
        for {
            data := map[string]interface{}{
                "time": time.Now().String(),
            }
            notifier.Notify("serverTime", data)
            time.Sleep(time.Second) // Sleep some interval
            // This also works, makes the resolver decide what to do
            notifier.Notify("serverTime", nil)
        }
    }()
    // Create the subscription handler using notifier and schema
    sh := subhandler.MakeSubscriptionHandler(notifier, schema)
    // Optional, check origin of the request
    sh.SetCheckOrigin(func(r *http.Request) bool {
        // Accept any origin
        return true
    })
    // Attach the normal query / mutation handlers
    http.Handle("/", h)
    // Attach the subscription handlers
    http.Handle("/subscriptions", sh)
    fmt.Println("Listening in :8080")
    http.ListenAndServe(":8080", nil)
}