AST Extraction and Analysis

/**
 * Extract operation definition from GraphQL document
 * @param doc - GraphQL document to analyze
 * @returns Operation definition if found, undefined otherwise
 */
function getOperationDefinition(doc: DocumentNode): OperationDefinitionNode | undefined;

import { getOperationDefinition } from "apollo-utilities";
import { parse } from "graphql";

const query = parse(`
  query GetUser($id: ID!) {
    user(id: $id) {
      name
      email
    }
  }
`);

const operation = getOperationDefinition(query);
console.log(operation?.operation); // "query"
console.log(operation?.name?.value); // "GetUser"

/**
 * Extract operation definition from document or throw error
 * @param document - GraphQL document to analyze
 * @returns Operation definition
 * @throws Error if no operation definition is found
 */
function getOperationDefinitionOrDie(document: DocumentNode): OperationDefinitionNode;

/**
 * Extract query definition from GraphQL document
 * @param doc - GraphQL document to analyze
 * @returns Query operation definition
 * @throws Error if no query operation is found
 */
function getQueryDefinition(doc: DocumentNode): OperationDefinitionNode;

/**
 * Extract mutation definition from GraphQL document
 * @param doc - GraphQL document to analyze
 * @returns Mutation operation definition
 * @throws Error if no mutation operation is found
 */
function getMutationDefinition(doc: DocumentNode): OperationDefinitionNode;

/**
 * Get operation name from GraphQL document
 * @param doc - GraphQL document to analyze
 * @returns Operation name if present, null otherwise
 */
function getOperationName(doc: DocumentNode): string | null;

import { getOperationName } from "apollo-utilities";
import { parse } from "graphql";

const namedQuery = parse(`
  query GetUserProfile($id: ID!) {
    user(id: $id) { name }
  }
`);

const anonymousQuery = parse(`
  query {
    users { name }
  }
`);

console.log(getOperationName(namedQuery)); // "GetUserProfile"
console.log(getOperationName(anonymousQuery)); // null

/**
 * Get all fragment definitions from GraphQL document
 * @param doc - GraphQL document to analyze
 * @returns Array of fragment definitions
 */
function getFragmentDefinitions(doc: DocumentNode): FragmentDefinitionNode[];

import { getFragmentDefinitions } from "apollo-utilities";
import { parse } from "graphql";

const doc = parse(`
  query GetUser {
    user {
      ...UserInfo
      ...ContactInfo
    }
  }
  
  fragment UserInfo on User {
    id
    name
  }
  
  fragment ContactInfo on User {
    email
    phone
  }
`);

const fragments = getFragmentDefinitions(doc);
console.log(fragments.length); // 2
console.log(fragments.map(f => f.name.value)); // ["UserInfo", "ContactInfo"]

/**
 * Extract single fragment definition from document
 * @param doc - GraphQL document containing exactly one fragment
 * @returns Fragment definition
 * @throws Error if document doesn't contain exactly one fragment
 */
function getFragmentDefinition(doc: DocumentNode): FragmentDefinitionNode;

/**
 * Get the main definition from a GraphQL document
 * @param queryDoc - GraphQL document to analyze
 * @returns First operation definition found, or first fragment definition if no operations
 * @throws Error if no valid definitions are found
 */
function getMainDefinition(
  queryDoc: DocumentNode
): OperationDefinitionNode | FragmentDefinitionNode;

import { getMainDefinition } from "apollo-utilities";
import { parse } from "graphql";

// Document with operation - returns the operation
const queryDoc = parse(`
  query GetUser { user { name } }
  fragment UserInfo on User { id }
`);

const mainDef1 = getMainDefinition(queryDoc);
console.log(mainDef1.kind); // "OperationDefinition"

// Document with only fragments - returns first fragment
const fragmentDoc = parse(`
  fragment UserInfo on User { id name }
  fragment PostInfo on Post { title }
`);

const mainDef2 = getMainDefinition(fragmentDoc);
console.log(mainDef2.kind); // "FragmentDefinition"
console.log(mainDef2.name.value); // "UserInfo"

/**
 * Create a map from fragment names to fragment definitions
 * @param fragments - Array of fragment definitions (optional)
 * @returns Object mapping fragment names to definitions
 */
function createFragmentMap(fragments?: FragmentDefinitionNode[]): FragmentMap;

import { createFragmentMap, getFragmentDefinitions } from "apollo-utilities";
import { parse } from "graphql";

const doc = parse(`
  fragment UserInfo on User {
    id
    name
    email
  }
  
  fragment PostInfo on Post {
    id
    title
    content
  }
`);

const fragments = getFragmentDefinitions(doc);
const fragmentMap = createFragmentMap(fragments);

console.log(fragmentMap["UserInfo"]?.name.value); // "UserInfo"
console.log(fragmentMap["PostInfo"]?.name.value); // "PostInfo"
console.log(fragmentMap["NonExistent"]); // undefined

/**
 * Validate GraphQL document structure
 * @param doc - GraphQL document to validate
 * @returns The document if valid
 * @throws Error if document is invalid or has multiple operations
 */
function checkDocument(doc: DocumentNode): DocumentNode;

/**
 * Extract default values from operation variable definitions
 * @param definition - Operation definition to analyze
 * @returns Object mapping variable names to their default values
 */
function getDefaultValues(
  definition: OperationDefinitionNode | undefined
): { [key: string]: JsonValue };

import { getDefaultValues, getOperationDefinition } from "apollo-utilities";
import { parse } from "graphql";

const query = parse(`
  query GetUsers(
    $limit: Int = 10,
    $offset: Int = 0,
    $status: String = "active"
  ) {
    users(limit: $limit, offset: $offset, status: $status) {
      id
      name
    }
  }
`);

const operation = getOperationDefinition(query);
const defaults = getDefaultValues(operation);

console.log(defaults);
// {
//   limit: 10,
//   offset: 0,
//   status: "active"
// }

/**
 * Get names of all variables declared in an operation
 * @param operation - Operation definition to analyze
 * @returns Set of variable names
 */
function variablesInOperation(operation: OperationDefinitionNode): Set<string>;

import { variablesInOperation, getOperationDefinition } from "apollo-utilities";
import { parse } from "graphql";

const query = parse(`
  query GetUser($id: ID!, $includeEmail: Boolean, $limit: Int) {
    user(id: $id) {
      name
      email @include(if: $includeEmail)
      posts(limit: $limit) {
        title
      }
    }
  }
`);

const operation = getOperationDefinition(query);
const variables = variablesInOperation(operation);

console.log(Array.from(variables)); // ["id", "includeEmail", "limit"]

interface FragmentMap {
  [fragmentName: string]: FragmentDefinitionNode;
}

interface JsonValue {
  type: 'json';
  json: any;
}