How It Works Features Pricing Blog Error Guides
Log In Start Free Trial
Rails · Ruby

Fix GraphQL::ExecutionError: Field 'user' doesn't accept argument 'id' of type 'String' (expected 'ID!'|) in Rails

This error occurs when a GraphQL query passes an argument with the wrong type. The schema expects a specific type like ID! but receives a String. Review your GraphQL type definitions and ensure arguments match the expected types. Use proper type coercion in your resolvers and validate input types in your schema.

Reading the Stack Trace

GraphQL::ExecutionError (Field 'user' doesn't accept argument 'id' of type 'String'): graphql (2.2.5) lib/graphql/schema/argument.rb:182:in `coerce_input' graphql (2.2.5) lib/graphql/execution/interpreter/runtime.rb:456:in `call' graphql (2.2.5) lib/graphql/schema/resolver.rb:98:in `resolve_with_support' app/graphql/types/query_type.rb:12:in `resolve' graphql (2.2.5) lib/graphql/execution/interpreter/runtime.rb:302:in `evaluate_selections' app/controllers/graphql_controller.rb:18:in `execute'

Here's what each line means:

Common Causes

1. Wrong argument type in query

The client sends a String where the schema expects an ID type.

# Client query:
# query { user(id: "abc") { name } }

# Schema expects:
field :user, Types::UserType, null: true do
  argument :id, ID, required: true
end

2. Missing type definition

A custom type is not properly defined, causing type resolution to fail.

module Types
  class QueryType < Types::BaseObject
    field :user, Types::UserType, null: true do
      argument :id, ID, required: true
    end

    def user(id:)
      User.find(id)  # May raise if ID coercion fails
    end
  end
end

3. Null passed for required argument

A required argument receives null or is omitted in the query.

# query { user { name } }  # Missing required 'id' argument

The Fix

Use find_by instead of find to handle missing records gracefully, and raise a GraphQL::ExecutionError with a helpful message. The ID type accepts both strings and integers and coerces them appropriately.

Before (broken)
module Types
  class QueryType < Types::BaseObject
    field :user, Types::UserType, null: true do
      argument :id, ID, required: true
    end

    def user(id:)
      User.find(id)
    end
  end
end
After (fixed)
module Types
  class QueryType < Types::BaseObject
    field :user, Types::UserType, null: true do
      argument :id, ID, required: true
    end

    def user(id:)
      User.find_by(id: id)
    rescue ActiveRecord::RecordNotFound
      raise GraphQL::ExecutionError, "User not found with id: #{id}"
    end
  end
end

Testing the Fix

require 'rails_helper'

RSpec.describe Types::QueryType do
  describe 'user field' do
    let(:user) { create(:user, name: 'Alice') }

    it 'returns user by ID' do
      result = MyAppSchema.execute(
        '{ user(id: "' + user.id.to_s + '") { name } }'
      )
      expect(result['data']['user']['name']).to eq('Alice')
    end

    it 'returns error for missing user' do
      result = MyAppSchema.execute('{ user(id: "999999") { name } }')
      expect(result['errors'].first['message']).to include('User not found')
    end
  end
end

Run your tests:

bundle exec rspec spec/graphql/types/query_type_spec.rb

Pushing Through CI/CD

git checkout -b fix/rails-graphql-type,git add app/graphql/types/query_type.rb,git commit -m "fix: handle GraphQL ID type coercion and missing records",git push origin fix/rails-graphql-type

Your CI config should look something like this:

name: CI
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_PASSWORD: postgres
        ports: ['5432:5432']
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true
      - run: bin/rails db:setup
      - run: bundle exec rspec

The Full Manual Process: 18 Steps

Here's every step you just went through to fix this one bug:

  1. Notice the error alert or see it in your monitoring tool
  2. Open the error dashboard and read the stack trace
  3. Identify the file and line number from the stack trace
  4. Open your IDE and navigate to the file
  5. Read the surrounding code to understand context
  6. Reproduce the error locally
  7. Identify the root cause
  8. Write the fix
  9. Run the test suite locally
  10. Fix any failing tests
  11. Write new tests covering the edge case
  12. Run the full test suite again
  13. Create a new git branch
  14. Commit and push your changes
  15. Open a pull request
  16. Wait for code review
  17. Merge and deploy to production
  18. Monitor production to confirm the error is resolved

Total time: 30-60 minutes. For one bug.

Or Let bugstack Fix It in Under 2 minutes

Every step above? bugstack does it automatically.

Step 1: Install the SDK

gem install bugstack

Step 2: Initialize

require 'bugstack'

Bugstack.init(api_key: ENV['BUGSTACK_API_KEY'])

Step 3: There is no step 3.

bugstack handles everything from here:

  1. Captures the stack trace and request context
  2. Pulls the relevant source files from your GitHub repo
  3. Analyzes the error and understands the code context
  4. Generates a minimal, verified fix
  5. Runs your existing test suite
  6. Pushes through your CI/CD pipeline
  7. Deploys to production (or opens a PR for review)

Time from error to fix deployed: Under 2 minutes.

Human involvement: zero.

Try bugstack Free →

No credit card. 5-minute setup. Cancel anytime.

Deploying the Fix (Manual Path)

  1. Fix type definitions in your GraphQL schema.
  2. Add error handling for missing records in resolvers.
  3. Write GraphQL query specs.
  4. Open a pull request.
  5. Merge and verify queries work in staging.

Frequently Asked Questions

BugStack runs the fix through your existing test suite, generates additional edge-case tests, and validates that no other components are affected before marking it safe to deploy.

BugStack never pushes directly to production. Every fix goes through a pull request with full CI checks, so your team can review it before merging.

graphql-ruby is the standard for GraphQL APIs. Graphiti is for JSON:API REST APIs. Choose based on whether your clients prefer GraphQL or REST.

Use graphql-batch or dataloader (built into graphql-ruby 2.0+) to batch and cache database queries across resolver calls.