Request Processing

/**
 * GraphQL request parameters interface
 */
interface GraphQLParams<
  TVariables = Record<string, any>,
  TExtensions = Record<string, any>,
> {
  /** GraphQL operation name */
  operationName?: string;
  /** GraphQL query or mutation string */
  query?: string;
  /** Variables for the GraphQL operation */
  variables?: TVariables;
  /** Extensions for additional metadata */
  extensions?: TExtensions;
}

/**
 * Request parser plugin for handling multiple request formats
 * @param options - Parser configuration options
 * @returns Plugin instance
 */
function useRequestParser(options: RequestParserPluginOptions): Plugin;

interface RequestParserPluginOptions {
  /** Array of custom request parsers */
  parsers?: RequestParser[];
}

/**
 * Request parser function type
 */
type RequestParser = (
  request: Request
) => Promise<GraphQLParams> | GraphQLParams | null;

/**
 * Check if request is a GET request
 * @param request - HTTP request object
 * @returns True if request method is GET
 */
function isGETRequest(request: Request): boolean;

/**
 * Parse GraphQL parameters from GET request query string
 * @param request - HTTP request object
 * @returns Parsed GraphQL parameters
 */
function parseGETRequest(request: Request): GraphQLParams;

/**
 * Check if request is a POST request with JSON content type
 * @param request - HTTP request object
 * @returns True if request is POST with application/json
 */
function isPOSTJsonRequest(request: Request): boolean;

/**
 * Parse GraphQL parameters from POST JSON request body
 * @param request - HTTP request object
 * @returns Promise resolving to parsed GraphQL parameters
 */
function parsePOSTJsonRequest(request: Request): Promise<GraphQLParams>;

/**
 * Check if request is POST with form URL encoded content type
 * @param request - HTTP request object
 * @returns True if request is POST with application/x-www-form-urlencoded
 */
function isPOSTFormUrlEncodedRequest(request: Request): boolean;

/**
 * Parse GraphQL parameters from form URL encoded request body
 * @param request - HTTP request object
 * @returns Promise resolving to parsed GraphQL parameters
 */
function parsePOSTFormUrlEncodedRequest(request: Request): Promise<GraphQLParams>;

/**
 * Check if request is POST with GraphQL string content type
 * @param request - HTTP request object
 * @returns True if request is POST with application/graphql
 */
function isPOSTGraphQLStringRequest(request: Request): boolean;

/**
 * Parse GraphQL query from raw GraphQL string request body
 * @param request - HTTP request object
 * @returns Promise resolving to parsed GraphQL parameters
 */
function parsePOSTGraphQLStringRequest(request: Request): Promise<GraphQLParams>;

/**
 * Check if request is POST with multipart content type
 * @param request - HTTP request object
 * @returns True if request is POST with multipart/form-data
 */
function isPOSTMultipartRequest(request: Request): boolean;

/**
 * Parse GraphQL parameters from multipart form data request
 * @param request - HTTP request object
 * @returns Promise resolving to parsed GraphQL parameters
 */
function parsePOSTMultipartRequest(request: Request): Promise<GraphQLParams>;

/**
 * Plugin for validating GraphQL query parameters
 * @param extraParamNames - Additional allowed parameter names
 * @returns Plugin instance
 */
function useCheckGraphQLQueryParams(extraParamNames?: string[]): Plugin;

/**
 * Plugin for validating HTTP methods for GraphQL requests
 * @returns Plugin instance
 */
function useCheckMethodForGraphQL(): Plugin;

/**
 * Plugin for preventing mutations via GET requests
 * @returns Plugin instance
 */
function usePreventMutationViaGET(): Plugin;

/**
 * Plugin for limiting request batching
 * @param limit - Maximum number of operations in a batch
 * @returns Plugin instance
 */
function useLimitBatching(limit?: number): Plugin;

/**
 * Plugin for HTTP validation error handling
 * @returns Plugin instance
 */
function useHTTPValidationError<TServerContext>(): Plugin;

/**
 * Assert that parameters are invalid and throw error
 * @param params - Parameters to validate
 * @throws Error if parameters are invalid
 */
function assertInvalidParams(params: unknown): asserts params is GraphQLParams;

/**
 * Check and validate GraphQL query parameters
 * @param params - Parameters to validate
 * @returns Validated GraphQL parameters
 * @throws Error if validation fails
 */
function checkGraphQLQueryParams(params: unknown): GraphQLParams;

/**
 * Type guard to check if parameters are valid GraphQL parameters
 * @param params - Parameters to check
 * @returns True if parameters are valid
 */
function isValidGraphQLParams(params: unknown): params is GraphQLParams;

/**
 * Check if HTTP method is valid for GraphQL requests
 * @param method - HTTP method string
 * @returns True if method is GET or POST
 */
function isValidMethodForGraphQL(method: string): method is 'GET' | 'POST';

/**
 * Assert that mutation is not being sent via GET request
 * @param params - GraphQL parameters to check
 * @throws Error if mutation detected in GET request
 */
function assertMutationViaGet(params: GraphQLParams): void;

/**
 * Handle URL search parameters and convert to GraphQL parameters
 * @param searchParams - URLSearchParams object
 * @returns Parsed GraphQL parameters
 */
function handleURLSearchParams(searchParams: URLSearchParams): GraphQLParams;

/**
 * Parse URL search parameters from request body string
 * @param requestBody - Request body as string
 * @returns Parsed GraphQL parameters
 */
function parseURLSearchParams(requestBody: string): GraphQLParams;

/**
 * Check if request content type matches expected type
 * @param request - HTTP request object
 * @param expectedContentType - Expected content type string
 * @returns True if content types match
 */
function isContentTypeMatch(request: Request, expectedContentType: string): boolean;

import { 
  createYoga,
  useRequestParser,
  useCheckGraphQLQueryParams,
  useCheckMethodForGraphQL,
  usePreventMutationViaGET,
  useLimitBatching,
  parseGETRequest,
  parsePOSTJsonRequest
} from 'graphql-yoga';

// Basic request processing setup
const yoga = createYoga({
  schema: mySchema,
  plugins: [
    useCheckMethodForGraphQL(),
    useCheckGraphQLQueryParams(),
    usePreventMutationViaGET(),
    useLimitBatching(10)
  ]
});

// Custom request parser
function customRequestParser(request: Request): GraphQLParams | null {
  const contentType = request.headers.get('content-type');
  
  if (contentType?.includes('application/custom')) {
    // Parse custom format
    return {
      query: extractQueryFromCustomFormat(request),
      variables: extractVariablesFromCustomFormat(request)
    };
  }
  
  return null; // Let other parsers handle
}

const yogaWithCustomParser = createYoga({
  schema: mySchema,
  plugins: [
    useRequestParser({
      parsers: [customRequestParser]
    })
  ]
});

// Manual request parsing
async function handleRequest(request: Request): Promise<GraphQLParams> {
  if (isGETRequest(request)) {
    return parseGETRequest(request);
  }
  
  if (isPOSTJsonRequest(request)) {
    return await parsePOSTJsonRequest(request);
  }
  
  if (isPOSTFormUrlEncodedRequest(request)) {
    return await parsePOSTFormUrlEncodedRequest(request);
  }
  
  if (isPOSTGraphQLStringRequest(request)) {
    return await parsePOSTGraphQLStringRequest(request);
  }
  
  if (isPOSTMultipartRequest(request)) {
    return await parsePOSTMultipartRequest(request);
  }
  
  throw new Error('Unsupported request format');
}

// Parameter validation
function validateGraphQLParams(params: unknown): GraphQLParams {
  if (!isValidGraphQLParams(params)) {
    throw new Error('Invalid GraphQL parameters');
  }
  
  // Additional custom validation
  if (params.query && params.query.includes('mutation') && !params.operationName) {
    throw new Error('Mutation operations must include operation name');
  }
  
  return params;
}

// Advanced request processing with validation
const advancedYoga = createYoga({
  schema: mySchema,
  plugins: [
    {
      onParams({ params, request, setParams }) {
        // Custom parameter processing
        const validatedParams = validateGraphQLParams(params);
        
        // Add request metadata to extensions
        setParams({
          ...validatedParams,
          extensions: {
            ...validatedParams.extensions,
            requestId: generateRequestId(),
            userAgent: request.headers.get('user-agent'),
            timestamp: Date.now()
          }
        });
      }
    },
    useCheckMethodForGraphQL(),
    useCheckGraphQLQueryParams(['customParam']),
    usePreventMutationViaGET(),
    useLimitBatching(5)
  ]
});

// File upload handling
const uploadYoga = createYoga({
  schema: mySchema,
  multipart: true, // Enable multipart support
  plugins: [
    {
      onParams({ params }) {
        // Handle file uploads in variables
        if (params.variables) {
          for (const [key, value] of Object.entries(params.variables)) {
            if (value instanceof File) {
              console.log(`Received file upload: ${key} - ${value.name}`);
            }
          }
        }
      }
    }
  ]
});