404 - Page Not Found
The requested resource could not be found.
Go Back to HomeGoFr
GoFr: An Opinionated Microservice Development Framework
================================================
FILE: SECURITY.md
================================================
# Security Policy
## Supported Versions
Following versions are being supported for security updates.
| Version | Supported |
| ------- | ------------------ |
| 1.0.x | :white_check_mark: |
## Reporting a Vulnerability
To report a vulnerability, please file an issue on this repo and add "security" label. Security related issues will be prioritized over others. We strive to triage the issue within a single working day.
================================================
FILE: docs/Dockerfile
================================================
FROM ghcr.io/gofr-dev/website:latest AS builder
WORKDIR /app
COPY docs/quick-start /app/src/app/docs/quick-start
COPY docs/public/ /app/public
COPY docs/advanced-guide /app/src/app/docs/advanced-guide
COPY docs/datasources /app/src/app/docs/datasources
COPY docs/references /app/src/app/docs/references
COPY docs/page.md /app/src/app/docs
COPY docs/navigation.js /app/src/lib
COPY docs/events.json /app/src/app/events
COPY docs/testimonials.json /app/utils
ENV NODE_ENV=production
RUN npm install
RUN npm run build
# Stage 2: Serve with Static Server
FROM zopdev/static-server:v0.0.5
# Copy static files from the builder stage
COPY --from=builder /app/out static
# Expose the port server is running on
EXPOSE 8000
# Start go server
CMD ["/main"]
================================================
FILE: docs/advanced-guide/authentication/page.md
================================================
# Authentication
Authentication is a crucial aspect of web applications, controlling access to resources based on user roles or permissions.
It is the process of verifying a user's identity to grant access to protected resources. It ensures that only authenticated
users can perform actions or access data within an application.
GoFr offers a **Unified Authentication** model, meaning that once you enable an authentication method, it automatically
applies to both your HTTP and gRPC services.
## Exempted Paths
By default, the authentication middleware exempts the following paths from authentication:
- `/.well-known/alive`: Used for liveness probes, should be publicly accessible for health checks.
The health check endpoint `/.well-known/health` is exempted by default, but as it may contain sensitive information about the service and its dependencies, it is recommended to require authentication for it.
## 1. Basic Auth
*Basic Authentication* is a simple authentication scheme where the user's credentials (username and password) are
transmitted in the request header in a Base64-encoded format.
Basic auth is the simplest way to authenticate your APIs. It's built on
{% new-tab-link title="HTTP protocol authentication scheme" href="https://datatracker.ietf.org/doc/html/rfc7617" /%}.
It involves sending the prefix `Basic` trailed by the Base64-encoded `Testing Static File
") createPublicDirectory(t, defaultPublicStaticDir, htmlContent) createPublicDirectory(t, "testdir", htmlContent) app := New() app.AddStaticFiles("gofrTest", "testdir") app.httpServer.port = configs.HTTPPort go app.Run() time.Sleep(100 * time.Millisecond) host = configs.HTTPHost return host, htmlContent } func TestStaticHandler(t *testing.T) { const indexHTML = "indexTest.html" host, htmlContent := setupTestEnvironment(t) defer os.Remove("static/indexTest.html") defer os.RemoveAll("testdir") tests := []struct { desc string method string path string statusCode int expectedBody string expectedBodyLength int expectedResponseHeaderType string }{ { desc: "check file content index.html", method: http.MethodGet, path: "/" + defaultPublicStaticDir + "/" + indexHTML, statusCode: http.StatusOK, expectedBodyLength: len(htmlContent), expectedResponseHeaderType: "text/html; charset=utf-8", expectedBody: string(htmlContent), }, { desc: "check public endpoint", method: http.MethodGet, path: "/" + defaultPublicStaticDir, statusCode: http.StatusNotFound, }, { desc: "check file content index.html in custom dir", method: http.MethodGet, path: "/" + "gofrTest" + "/" + indexHTML, statusCode: http.StatusOK, expectedBodyLength: len(htmlContent), expectedResponseHeaderType: "text/html; charset=utf-8", expectedBody: string(htmlContent), }, { desc: "check public endpoint in custom dir", method: http.MethodGet, path: "/" + "gofrTest", statusCode: http.StatusNotFound, }, } for i, tc := range tests { request, err := http.NewRequestWithContext(t.Context(), tc.method, host+tc.path, http.NoBody) if err != nil { t.Fatalf("TEST[%d], Failed to create request, error: %s", i, err) } request.Header.Set("Content-Type", "application/json") client := http.Client{} resp, err := client.Do(request) if err != nil { t.Fatalf("TEST[%d], Request failed, error: %s", i, err) } bodyBytes, err := io.ReadAll(resp.Body) if err != nil { t.Fatalf("TEST[%d], Failed to read response body, error: %s", i, err) } body := string(bodyBytes) require.NoError(t, err, "TEST[%d], Failed.\n%s", i, tc.desc) assert.Equal(t, tc.statusCode, resp.StatusCode, "TEST[%d], Failed with Status Body.\n%s", i, tc.desc) if tc.expectedBody != "" { assert.Contains(t, body, tc.expectedBody, "TEST[%d], Failed with Expected Body.\n%s", i, tc.desc) } if tc.expectedBodyLength != 0 { contentLength := resp.Header.Get("Content-Length") assert.Equal(t, strconv.Itoa(tc.expectedBodyLength), contentLength, "TEST[%d], Failed at Content-Length.\n%s", i, tc.desc) } if tc.expectedResponseHeaderType != "" { assert.Equal(t, tc.expectedResponseHeaderType, resp.Header.Get("Content-Type"), "TEST[%d], Failed at Expected Content-Type.\n%s", i, tc.desc) } resp.Body.Close() } } func TestStaticHandlerInvalidFilePath(t *testing.T) { // Generating some files for testing logs := testutil.StderrOutputForFunc(func() { testutil.NewServerConfigs(t) app := New() app.AddStaticFiles("gofrTest", ".//,.!@#$%^&") }) assert.Contains(t, logs, "no such file or directory") assert.Contains(t, logs, "error in registering '/gofrTest' static endpoint") } func TestNewSetsHTTPRegisteredWhenStaticDirExists(t *testing.T) { testutil.NewServerConfigs(t) createPublicDirectory(t, defaultPublicStaticDir, []byte("")) defer os.Remove("static/indexTest.html") app := New() assert.True(t, app.httpRegistered, "httpRegistered should be true when ./static directory exists") assert.NotEmpty(t, app.httpServer.staticFiles, "staticFiles map should contain the auto-detected directory") } func createPublicDirectory(t *testing.T, defaultPublicStaticDir string, htmlContent []byte) { t.Helper() const indexHTML = "indexTest.html" directory := "./" + defaultPublicStaticDir if _, err := os.Stat(directory); err != nil { if err = os.Mkdir("./"+defaultPublicStaticDir, os.ModePerm); err != nil { t.Fatalf("Couldn't create a "+defaultPublicStaticDir+" directory, error: %s", err) } } file, err := os.Create(filepath.Join(directory, indexHTML)) if err != nil { t.Fatalf("Couldn't create %s file", indexHTML) } _, err = file.Write(htmlContent) if err != nil { t.Fatalf("Couldn't write to %s file", indexHTML) } file.Close() } func Test_Shutdown(t *testing.T) { logs := testutil.StdoutOutputForFunc(func() { testutil.NewServerConfigs(t) g := New() g.GET("/hello", func(*Context) (any, error) { return helloWorld, nil }) go g.Run() time.Sleep(10 * time.Millisecond) err := g.Shutdown(t.Context()) require.NoError(t, err, "Test_Shutdown Failed!") }) assert.Contains(t, logs, "Application shutdown complete", "Test_Shutdown Failed!") } func TestApp_SubscriberInitialize(t *testing.T) { t.Run("subscriber is initialized", func(t *testing.T) { testutil.NewServerConfigs(t) app := New() mockContainer := container.Container{ Logger: logging.NewLogger(logging.ERROR), PubSub: mockSubscriber{}, } app.container = &mockContainer app.Subscribe("Hello", func(*Context) error { // this is a test subscriber return nil }) _, ok := app.subscriptionManager.subscriptions["Hello"] assert.True(t, ok) }) t.Run("subscriber is not initialized", func(t *testing.T) { testutil.NewServerConfigs(t) app := New() app.Subscribe("Hello", func(*Context) error { // this is a test subscriber return nil }) _, ok := app.subscriptionManager.subscriptions["Hello"] assert.False(t, ok) }) } func TestApp_Subscribe(t *testing.T) { t.Run("topic is empty", func(t *testing.T) { testutil.NewServerConfigs(t) app := New() mockContainer := container.Container{ Logger: logging.NewLogger(logging.ERROR), PubSub: mockSubscriber{}, } app.container = &mockContainer app.Subscribe("", func(*Context) error { return nil }) _, ok := app.subscriptionManager.subscriptions[""] assert.False(t, ok) }) t.Run("handler is nil", func(t *testing.T) { testutil.NewServerConfigs(t) app := New() mockContainer := container.Container{ Logger: logging.NewLogger(logging.ERROR), PubSub: mockSubscriber{}, } app.container = &mockContainer app.Subscribe("Hello", nil) _, ok := app.subscriptionManager.subscriptions["Hello"] assert.False(t, ok) }) } // Define static error for testing. var errHookFailed = errors.New("hook failed") func TestApp_OnStart(t *testing.T) { // Test case 1: Hook executes successfully t.Run("success", func(t *testing.T) { var hookCalled bool app := New() app.OnStart(func(_ *Context) error { hookCalled = true return nil }) err := app.runOnStartHooks(t.Context()) require.NoError(t, err, "Expected no error from runOnStartHooks") assert.True(t, hookCalled, "Expected the OnStart hook to be called") }) // Test case 2: Hook returns an error t.Run("error", func(t *testing.T) { app := New() app.OnStart(func(_ *Context) error { return errHookFailed }) err := app.runOnStartHooks(t.Context()) require.ErrorIs(t, err, errHookFailed, "Expected an error from runOnStartHooks") }) // Test case 4: Verify panic recovery t.Run("panic recovery", func(t *testing.T) { app := New() app.OnStart(func(_ *Context) error { panic("test panic") }) err := app.runOnStartHooks(t.Context()) require.Error(t, err, "Expected error from panicked hook") assert.Contains(t, err.Error(), "panicked", "Expected error message to mention panic") }) } func TestUnifiedAuthenticationRegistration(t *testing.T) { t.Setenv("METRICS_PORT", "0") t.Setenv("HTTP_PORT", strconv.Itoa(testutil.GetFreePort(t))) app := New() // Enable various auth methods app.EnableBasicAuth("user", "pass") app.EnableAPIKeyAuth("key1") app.EnableOAuth("http://jwks", 3600) // Verify HTTP middleware count (approximate check) // We can't easily inspect the router's middleware slice directly without reflection or exposing it, // but we can check if the grpcServer has interceptors added. assert.GreaterOrEqual(t, len(app.grpcServer.interceptors), 2, "gRPC unary interceptors should be registered") assert.GreaterOrEqual(t, len(app.grpcServer.streamInterceptors), 2, "gRPC stream interceptors should be registered") } ================================================ FILE: pkg/gofr/graphql.go ================================================ package gofr import ( "context" "encoding/json" "errors" "fmt" "io" "net/http" "os" "runtime/debug" "strings" "sync" "time" "github.com/graphql-go/graphql" "github.com/vektah/gqlparser/v2" "github.com/vektah/gqlparser/v2/ast" "github.com/vektah/gqlparser/v2/parser" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" "gofr.dev/pkg/gofr/container" ) var ( errSchemaMissing = errors.New("GraphQL schema file missing: ./configs/schema.graphqls") errResolverMissing = errors.New("resolver missing for field") ) const ( graphqlString = "String" graphqlID = "ID" graphqlInt = "Int" graphqlFloat = "Float" graphqlBoolean = "Boolean" graphqlQuery = "query" graphqlMutation = "mutation" graphqlSuccess = "success" graphqlError = "error" graphqlUnknown = "unknown" ) // GraphQLLog represents a logged GraphQL resolver execution. type GraphQLLog struct { Resolver string `json:"resolver"` Type string `json:"type"` Duration int64 `json:"duration"` Error string `json:"error,omitempty"` } func (l *GraphQLLog) PrettyPrint(writer io.Writer) { opType := "GraphQL Query" if l.Type == graphqlMutation { opType = "GraphQL Mutation" } if l.Error != "" { fmt.Fprintf(writer, "\u001B[38;5;202m%-6s\u001B[0m %8d\u001B[38;5;8mµs\u001B[0m %s %s: %s \n", "FAIL", l.Duration, opType, l.Resolver, l.Error) return } fmt.Fprintf(writer, "\u001B[38;5;34m%-6s\u001B[0m %8d\u001B[38;5;8mµs\u001B[0m %s %s \n", "OK", l.Duration, opType, l.Resolver) } type graphQLManager struct { container *container.Container queries map[string]Handler mutations map[string]Handler schema graphql.Schema mu sync.RWMutex tracer trace.Tracer typeCache map[string]graphql.Output enumCache map[string]*graphql.Enum } func newGraphQLManager(c *container.Container) *graphQLManager { // GraphQL metrics are registered here (not in registerFrameworkMetrics) because // GraphQL is an opt-in feature. Metrics are only created when resolvers are registered. c.Metrics().NewCounter("app_graphql_operations_total", "Total number of GraphQL operations received.") c.Metrics().NewCounter("app_graphql_error_total", "Total number of GraphQL operations that returned an error.") c.Metrics().NewHistogram("app_graphql_request_duration", "Response time of GraphQL requests in seconds.", .001, .003, .005, .01, .02, .03, .05, .1, .2, .3, .5, .75, 1, 2, 3, 5, 10, 30) //nolint:mnd // histogram buckets return &graphQLManager{ container: c, queries: make(map[string]Handler), mutations: make(map[string]Handler), tracer: otel.Tracer("gofr-graphql"), typeCache: make(map[string]graphql.Output), enumCache: make(map[string]*graphql.Enum), } } func (m *graphQLManager) RegisterQuery(name string, handler Handler) { m.mu.Lock() defer m.mu.Unlock() m.queries[name] = handler } func (m *graphQLManager) RegisterMutation(name string, handler Handler) { m.mu.Lock() defer m.mu.Unlock() m.mutations[name] = handler } func (m *graphQLManager) buildSchema() error { schemaContent, err := os.ReadFile("./configs/schema.graphqls") if err != nil { if os.IsNotExist(err) { return errSchemaMissing } return err } // Parse SDL using gqlparser src := &ast.Source{ Name: "schema.graphqls", Input: string(schemaContent), } gqlSchema, gqlErr := gqlparser.LoadSchema(src) if gqlErr != nil { return fmt.Errorf("failed to parse schema: %w", gqlErr) } // Bridge gqlparser AST to graphql-go Schema queryFields, err := m.buildFields(gqlSchema.Query, m.queries, gqlSchema) if err != nil { return err } mutationFields, err := m.buildFields(gqlSchema.Mutation, m.mutations, gqlSchema) if err != nil { return err } schemaConfig := graphql.SchemaConfig{ Query: graphql.NewObject(graphql.ObjectConfig{ Name: "Query", Fields: queryFields, }), } if len(mutationFields) > 0 { schemaConfig.Mutation = graphql.NewObject(graphql.ObjectConfig{ Name: "Mutation", Fields: mutationFields, }) } m.schema, err = graphql.NewSchema(schemaConfig) if err != nil { return fmt.Errorf("failed to build graphql-go schema: %w", err) } return nil } func (m *graphQLManager) buildFields(obj *ast.Definition, handlers map[string]Handler, schema *ast.Schema) (graphql.Fields, error) { fields := graphql.Fields{} if obj == nil { return fields, nil } for _, field := range obj.Fields { m.mu.RLock() handler, ok := handlers[field.Name] m.mu.RUnlock() if !ok { if strings.HasPrefix(field.Name, "__") { // Skip internal GraphQL fields like __schema, __type, etc. continue } return nil, fmt.Errorf("%w: %s", errResolverMissing, field.Name) } fields[field.Name] = &graphql.Field{ Type: m.mapType(field.Type, schema), Args: m.mapArgs(field.Arguments, schema), Resolve: m.getResolver(field.Name, handler), } } return fields, nil } func (m *graphQLManager) mapArgs(args ast.ArgumentDefinitionList, schema *ast.Schema) graphql.FieldConfigArgument { res := graphql.FieldConfigArgument{} for _, arg := range args { res[arg.Name] = &graphql.ArgumentConfig{ Type: m.mapInputType(arg.Type, schema), } } return res } func (m *graphQLManager) mapInputType(t *ast.Type, schema *ast.Schema) graphql.Input { var coreType graphql.Input coreType = m.getCoreInputType(t.Name(), schema) if t.Elem != nil { coreType = graphql.NewList(m.mapInputType(t.Elem, schema)) } if t.NonNull { return graphql.NewNonNull(coreType) } return coreType } func (m *graphQLManager) getCoreInputType(name string, schema *ast.Schema) graphql.Input { switch name { case graphqlString, graphqlID: return graphql.String case graphqlInt: return graphql.Int case graphqlFloat: return graphql.Float case graphqlBoolean: return graphql.Boolean default: return m.getCustomInputType(name, schema) } } func (m *graphQLManager) getCustomInputType(name string, schema *ast.Schema) graphql.Input { def, ok := schema.Types[name] if ok && def.Kind == ast.InputObject { fields := graphql.InputObjectConfigFieldMap{} for _, f := range def.Fields { fields[f.Name] = &graphql.InputObjectFieldConfig{ Type: m.mapInputType(f.Type, schema), } } return graphql.NewInputObject(graphql.InputObjectConfig{ Name: name, Fields: fields, }) } if def != nil && def.Kind == ast.Enum { return m.getEnum(def) } m.container.Errorf("unsupported GraphQL input type: %s", name) return graphql.String // Fallback } func (m *graphQLManager) getEnum(def *ast.Definition) *graphql.Enum { if e, ok := m.enumCache[def.Name]; ok { return e } config := graphql.EnumConfig{ Name: def.Name, Values: graphql.EnumValueConfigMap{}, } for _, val := range def.EnumValues { config.Values[val.Name] = &graphql.EnumValueConfig{ Value: val.Name, } } e := graphql.NewEnum(config) m.enumCache[def.Name] = e return e } func (m *graphQLManager) mapType(t *ast.Type, schema *ast.Schema) graphql.Output { var coreType graphql.Output if t.Elem != nil { coreType = graphql.NewList(m.mapType(t.Elem, schema)) } else if gqlType, ok := m.typeCache[t.Name()]; ok { coreType = gqlType } else { coreType = m.getCoreOutputType(t.Name(), schema) } if t.NonNull { return graphql.NewNonNull(coreType) } return coreType } func (m *graphQLManager) getCoreOutputType(name string, schema *ast.Schema) graphql.Output { switch name { case graphqlString, graphqlID: return graphql.String case graphqlInt: return graphql.Int case graphqlFloat: return graphql.Float case graphqlBoolean: return graphql.Boolean default: return m.getCustomOutputType(name, schema) } } func (m *graphQLManager) getCustomOutputType(name string, schema *ast.Schema) graphql.Output { def, ok := schema.Types[name] if def != nil && def.Kind == ast.Enum { return m.getEnum(def) } if !ok || def.Kind != ast.Object { m.container.Errorf("unsupported GraphQL output type: %s, defaulting to String", name) return graphql.String // Fallback } obj := graphql.NewObject(graphql.ObjectConfig{ Name: name, Fields: graphql.Fields{}, }) // Cache it immediately to avoid infinite recursion for circular references m.typeCache[name] = obj for _, f := range def.Fields { obj.AddFieldConfig(f.Name, &graphql.Field{ Type: m.mapType(f.Type, schema), }) } return obj } // getResolver binds a handler of type gofr.Handler to a GraphQL field. // Arguments are accessed inside the handler via c.Bind(). func (m *graphQLManager) getResolver(name string, h Handler) graphql.FieldResolveFn { return func(p graphql.ResolveParams) (any, error) { ctx, span := m.tracer.Start(p.Context, "graphql-resolver-"+name) defer span.End() start := time.Now() gReq := &graphQLRequest{ctx: ctx, params: p.Args} c := newContext(noopResponder{}, gReq, m.container) res, err := h(c) duration := time.Since(start).Microseconds() resolverType := m.getResolverType(name) if err != nil { c.Error(&GraphQLLog{Resolver: name, Type: resolverType, Duration: duration, Error: err.Error()}) return nil, err } c.Debug(&GraphQLLog{Resolver: name, Type: resolverType, Duration: duration}) return res, nil } } func (m *graphQLManager) getResolverType(name string) string { m.mu.RLock() defer m.mu.RUnlock() if _, ok := m.mutations[name]; ok { return graphqlMutation } return graphqlQuery } const maxRequestBodySize = 32 << 20 // 32 MB func (m *graphQLManager) Handle(w http.ResponseWriter, r *http.Request) { // Standard request protection - addressing review point 6 (bypassing middleware benefits) // Apply body size limit (using 32MB default as per GoFr's multipart decoder) r.Body = http.MaxBytesReader(w, r.Body, maxRequestBodySize) // Standard panic recovery for raw HTTP handler defer func() { if re := recover(); re != nil { m.container.Errorf("GraphQL Panic: %v\n%s", re, string(debug.Stack())) m.respondWithErrors(w, http.StatusInternalServerError, "Internal Server Error") } }() m.handleGraphQLRequest(w, r) } func (m *graphQLManager) handleGraphQLRequest(w http.ResponseWriter, r *http.Request) { ct := r.Header.Get("Content-Type") if ct != "" && !strings.HasPrefix(ct, "application/json") { m.respondWithErrors(w, http.StatusUnsupportedMediaType, "Content-Type must be application/json") return } start := time.Now() req, err := m.parseGraphQLRequest(r) if err != nil { m.container.Metrics().IncrementCounter(r.Context(), "app_graphql_error_total", "operation_name", graphqlUnknown, "type", graphqlUnknown) m.respondWithErrors(w, http.StatusBadRequest, "invalid JSON request body") return } opName, opType := m.parseOperation(req.Query, req.OperationName) ctx, span := m.tracer.Start(r.Context(), "graphql-request") span.SetAttributes(attribute.String("graphql.operation_name", opName), attribute.String("graphql.operation_type", opType)) var result *graphql.Result defer func() { status := graphqlSuccess if result != nil && len(result.Errors) > 0 { status = graphqlError } m.container.Metrics().RecordHistogram(ctx, "app_graphql_request_duration", time.Since(start).Seconds(), "operation_name", opName, "type", opType, "status", status) span.End() }() m.container.Metrics().IncrementCounter(ctx, "app_graphql_operations_total", "operation_name", opName, "type", opType) result = graphql.Do(graphql.Params{ Schema: m.schema, RequestString: req.Query, VariableValues: req.Variables, OperationName: req.OperationName, Context: ctx, }) w.Header().Set("Content-Type", "application/json") if len(result.Errors) > 0 { m.container.Metrics().IncrementCounter(ctx, "app_graphql_error_total", "operation_name", opName, "type", opType) } w.WriteHeader(http.StatusOK) err = json.NewEncoder(w).Encode(result) if err != nil { m.container.Errorf("error encoding GraphQL response: %v", err) } } type gqlRequest struct { Query string `json:"query"` OperationName string `json:"operationName"` Variables map[string]any `json:"variables"` } func (*graphQLManager) parseGraphQLRequest(r *http.Request) (gqlRequest, error) { var req gqlRequest err := json.NewDecoder(r.Body).Decode(&req) return req, err } func (*graphQLManager) parseOperation(query, operationName string) (opName, opType string) { opName = operationName opType = graphqlQuery astDoc, err := parser.ParseQuery(&ast.Source{Input: query}) if err != nil || len(astDoc.Operations) == 0 { if opName == "" { opName = graphqlUnknown } return opName, opType } op := astDoc.Operations[0] opType = string(op.Operation) if opName == "" && len(op.SelectionSet) > 0 { if field, ok := op.SelectionSet[0].(*ast.Field); ok { opName = field.Name } } if opName == "" { opName = graphqlUnknown } return opName, opType } func (*graphQLManager) respondWithErrors(w http.ResponseWriter, status int, message string) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(status) _ = json.NewEncoder(w).Encode(map[string]any{ "errors": []map[string]any{ {"message": message}, }, }) } func (m *graphQLManager) GetHandler() http.Handler { return http.HandlerFunc(m.Handle) } // graphQLRequest implements the gofr.Request interface for GraphQL. type graphQLRequest struct { ctx context.Context params map[string]any } func (r *graphQLRequest) Param(name string) string { if v, ok := r.params[name]; ok { return fmt.Sprintf("%v", v) } return "" } func (*graphQLRequest) PathParam(string) string { return "" } func (r *graphQLRequest) Bind(v any) error { b, err := json.Marshal(r.params) if err != nil { return err } return json.Unmarshal(b, v) } func (r *graphQLRequest) Context() context.Context { return r.ctx } func (*graphQLRequest) HostName() string { return "" } func (*graphQLRequest) Params(string) []string { return nil } const graphiqlHTML = `