What causes "Internal error" in dgraph-io/dgraph?

Ensure the RequestResolver is constructed and non-nil before calling Resolve

Internal error

Error message

Internal error

What it means

ErrInternal ("Internal error") is returned by Resolve when it is called with a nil RequestResolver. This is a defensive programmer-error guard: the resolver object was never constructed or was zeroed before use. Nothing about the user's request caused it — the embedding application passed a nil resolver into the GraphQL execution path.

Source

Thrown at graphql/resolve/resolver.go:457

func New(s schema.Schema, resolverFactory ResolverFactory) *RequestResolver {
	return &RequestResolver{
		schema:    s,
		resolvers: resolverFactory,
	}
}

// Resolve processes r.GqlReq and returns a GraphQL response.
// r.GqlReq should be set with a request before Resolve is called
// and a schema and backend Dgraph should have been added.
// Resolve records any errors in the response's error field.
func (r *RequestResolver) Resolve(ctx context.Context, gqlReq *schema.Request) (resp *schema.Response) {
	span := trace.SpanFromContext(ctx)
	stop := x.SpanTimer(span, methodResolve)
	defer stop()

	if r == nil {
		glog.Errorf("Call to Resolve with nil RequestResolver")
		return schema.ErrorResponse(errors.New(ErrInternal))
	}

	if r.schema == nil {
		glog.Errorf("Call to Resolve with no schema")
		return schema.ErrorResponse(errors.New(ErrInternal))
	}

	startTime := time.Now()
	resp = &schema.Response{
		Extensions: &schema.Extensions{
			Tracing: &schema.Trace{
				Version:   1,
				StartTime: startTime.Format(time.RFC3339Nano),
			},
		},
	}
	// Panic Handler for mutation. This ensures that the mutation which causes panic
	// gets logged in Alpha logs. This panic handler overrides the default Panic Handler

View on GitHub (pinned to 759e242be6)

Solutions

Ensure the RequestResolver is constructed and non-nil before calling Resolve
Check the error from resolver construction/initialization before use
Add a startup assertion or unit test that the resolver is wired

Example fix

// before
var r *resolve.RequestResolver
resp := r.Resolve(ctx, req) // nil
// after
r := resolve.NewRequestResolver(...)
if r == nil { log.Fatal("resolver init failed") }
resp := r.Resolve(ctx, req)

Defensive patterns

Strategy: validation

Validate before calling

if resolver == nil {
  return errors.New("GraphQL resolver not initialized")
}
if err := resolver.Ready(); err != nil {
  return err
}

Type guard

func resolverReady(r *resolve.RequestResolver) bool { return r != nil }

Try / catch

defer func() {
  if rec := recover(); rec != nil {
    log.Printf("GraphQL resolve panic: %v", rec)
  }
}()
resp := resolver.Resolve(ctx, req)

Prevention

Initialize the resolver in one well-tested constructor path
Check construction errors before storing the resolver
Add a startup health check that resolves a trivial request

When it happens

Trigger: Embedding Dgraph's GraphQL layer in a Go application and calling resolver.Resolve(ctx, req) where the resolver variable is nil (never initialized via the constructor, or a struct field left unset).

Common situations: Custom Go services using dgraph/graphql as a library; wiring errors after refactoring; failing to check an earlier construction error so a nil resolver propagates.

Related errors

AI-assisted analysis of dgraph-io/dgraph@759e242be6 (2026-09-01). Data as JSON: /api/errors/3d813a99ee549340. Report an issue: GitHub.