Index of every page on this site: llms.txt
All skills
apollographql avatar

/rover

@9dda139 official
by Apollo GraphQLapollographql/skills134 stars
14
Run it yourself

Guide for using Apollo Rover CLI to manage GraphQL schemas and federation. Use this skill when: (1) publishing or fetching subgraph/graph schemas, (2) composing supergraph schemas locally or via GraphOS, (3) running local supergraph development with rover dev, (4) validating schemas with check and lint commands, (5) configuring Rover authentication and environment, (6) exploring or searching a graph's schema for agent-driven discovery (rover schema describe / rover schema search), (7) initializing a new graph project or MCP server with rover init, (8) working with Apollo Connectors, contracts, persisted queries, or client operations, (9) managing API keys, plugins, templates, or graph artifacts.

Use this Skill: https://skilld.dev/gh/apollographql/skills/rover

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

referencesclient.md

≈863 tokens on demand. Your agent reads this file only when SKILL.md points to it.

Rover Client Commands

Commands for validating client-side GraphQL operations against a graph's published schema in Apollo GraphOS.

client check

Validate that all GraphQL operations in .graphql files are valid against a graph's published schema.

# Basic check against a graph variant
rover client check my-graph@production --include "src/**/*.graphql"

# Multiple include patterns
rover client check my-graph@staging \
  --include "src/**/*.graphql" \
  --include "lib/**/*.graphql"

# Exclude generated files
rover client check my-graph@production \
  --include "src/**/*.graphql" \
  --exclude "src/__generated__/**"

What it validates:

  • Every operation's fields, arguments, and types exist in the published schema
  • Required arguments are provided
  • Fragment references resolve correctly
  • Variable types match their usage

Requirements:

  • All operations must have names. Anonymous operations are rejected with an error.
  • Run the command from your client application's root directory.
  • Requires authentication (APOLLO_KEY or rover config auth).

Options:

Option Description
--include <GLOB> Glob pattern(s) for .graphql files to scan (required, repeatable)
--exclude <GLOB> Glob pattern(s) to exclude from scanning (repeatable)

Example output:

Validated 4 operations (3 files scanned)
GetTeamGrid: src/components/TeamGrid.graphql:4:1
  FAILURE Field "league" must not have a selection since type "SportsLeague" has no subfields.

4 total operations validated
1 failure

Exit codes:

  • 0 - All operations passed validation
  • Non-zero - One or more operations failed validation

client extract

Extract GraphQL operations from TypeScript source files (tagged template literals) into standalone .graphql files.

# Extract operations to a directory
rover client extract --out-dir graphql

Use this when your operations are embedded in TypeScript source files as gql tagged template literals rather than stored in separate .graphql files. After extraction, run rover client check against the output directory.

Options:

Option Description
--out-dir <DIR> Directory to write extracted .graphql files to

Workflow: TypeScript Projects

For projects that embed operations in TypeScript with gql tags:

# 1. Extract operations from source files
rover client extract --out-dir graphql

# 2. Validate extracted operations against the schema
rover client check my-graph@staging --include "graphql/**/*.graphql"

CI/CD Integration

Incorporate rover client check into your continuous delivery pipeline to validate operations before they go live.

GitHub Actions

# .github/workflows/check.yml
- name: Validate client operations
  run: |
    rover client check my-graph@production \
      --include "src/**/*.graphql"
  env:
    APOLLO_KEY: ${{ secrets.APOLLO_KEY }}

Check Against the Right Variant

Always check operations against the schema variant for the environment you deploy to:

# Check against production schema before deploying to production
rover client check my-graph@production --include "src/**/*.graphql"

# Check against staging schema during development
rover client check my-graph@staging --include "src/**/*.graphql"

If you omit the variant from the graph ref, Rover uses the default variant named current.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning24d5 checks · Risk SAFE
  • Gen Agent Trust Hub24d

    This skill provides a comprehensive guide for managing GraphQL schemas using the Apollo Rover CLI. While it includes commands for remote installation and schema ingestion, these are standard operations targeting official Apollo GraphQL infrastructure and follow security best practices.

  • Socket24d

    No alerts

  • Snyk24d

    Risk: LOW · No issues

  • Runlayer9mo

    6/6 files flagged

  • ZeroLeaks7mo

    1 finding · Score: 82/100

Signed by skilld at 9dda139. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 3 weeks ago.

Activeupdated 4 weeks ago
What it can do
Runs commands
compatibility
Node.js v18+, Linux/macOS/Windows
metadata
{
  "author": "apollographql",
  "version": "1.2.0"
}
All 1 allowed tools
Bash(rover:*) Bash(npm:*) Bash(npx:*) Read Write Edit Glob Grep
  • CLI
  • graphql
  • apollo
  • rover
  • federation
  • schema
  • supergraph
  • graphos
  • subgraph

README badge

README badge for apollographql/skills/rover

Manages GraphQL schemas and federation via the Apollo Rover CLI, including publishing subgraphs, composing supergraphs, and validating schemas with check and lint commands. Designed for local schema exploration via piped commands (rover schema describe/search) and GraphOS integration workflows, with built-in support for federated and monograph architectures.

Generated from the current SKILL.md.

Does Rover work with both federated and non-federated GraphQL graphs?
Yes. Use `rover subgraph` commands for federated graphs and `rover graph` commands for monographs (non-federated graphs). Both workflows are supported.
How do I explore a large GraphQL schema without loading the entire SDL into context?
Pipe `rover graph fetch` into `rover schema describe` or `rover schema search` — these commands read the schema via stdin and return only a compact overview or search results, keeping context manageable.
What's the difference between `rover graph fetch` and `rover supergraph fetch`?
`rover graph fetch` returns the API schema (what you can query), while `rover supergraph fetch` returns the composed supergraph SDL with federation internals like `join__` and `link__`. Use the former for schema exploration and the latter for composition/router work.
Can Rover execute GraphQL queries, or does it only manage schemas?
Rover only manages and inspects schemas. To run a generated query, you must send it to the graph's endpoint separately using curl or another HTTP client.
Does this skill require a GraphOS account, or can I use Rover offline?
Most Rover commands (publish, fetch, check) require authentication with a GraphOS API key. Local composition with `rover supergraph compose` and schema exploration of local files work offline.

Generated from the current SKILL.md. These answers refresh after source changes.