@democratize-quality/mcp-server 1.1.2 → 1.1.3

package/src/tools/api/api-planner.js

@@ -2,6 +2,21 @@ const ToolBase = require('../base/ToolBase');
 const https = require('https');
 const http = require('http');
 const { URL } = require('url');
+const fs = require('fs').promises;
+const path = require('path');
+
+// Try to load GraphQL for SDL parsing
+let graphql;
+try {
+    graphql = require('graphql');
+    if (!graphql.buildSchema || !graphql.introspectionFromSchema || !graphql.getIntrospectionQuery) {
+        console.warn('GraphQL loaded but required functions not available');
+        graphql = null;
+    }
+} catch (error) {
+    console.warn('GraphQL library not available, SDL files will not be supported:', error.message);
+    graphql = null;
+}
 
 // Try to load faker.js for enhanced sample data generation
 let faker;
@@ -42,7 +57,7 @@ try {
 // Input schema for the API planner tool
 const apiPlannerInputSchema = z.object({
     schemaUrl: z.string().optional(),
-    schemaContent: z.string().optional(),
+    schemaPath: z.string().optional(),
     schemaType: z.enum(['openapi', 'swagger', 'graphql', 'auto']).optional(),
     apiBaseUrl: z.string().optional(),
     includeAuth: z.boolean().optional(),
@@ -69,9 +84,9 @@ class ApiPlannerTool extends ToolBase {
                     type: "string",
                     description: "URL to fetch the API schema/documentation (e.g., OpenAPI spec URL, GraphQL introspection endpoint)"
                 },
-                schemaContent: {
+                schemaPath: {
                     type: "string",
-                    description: "Direct schema content as JSON/YAML string (alternative to schemaUrl)"
+                    description: "File path to a local schema file (.graphql, .json, .yaml, .yml). GraphQL SDL files (.graphql, .gql) are automatically converted to introspection JSON. For large files, this is the recommended approach as it reads the complete file without truncation."
                 },
                 schemaType: {
                     type: "string",
@@ -173,9 +188,11 @@ class ApiPlannerTool extends ToolBase {
             // Fetch or parse schema
             let schemaData;
             if (params.schemaUrl) {
-                schemaData = await this._fetchSchema(params.schemaUrl);
-            } else if (params.schemaContent) {
-                schemaData = this._parseSchemaContent(params.schemaContent, options.schemaType);
+                schemaData = await this._fetchSchema(params.schemaUrl, options.schemaType);
+            } else if (params.schemaPath) {
+                schemaData = await this._readSchemaFromFile(params.schemaPath, options.schemaType);
+            } else {
+                throw new Error('Either schemaUrl or schemaPath must be provided. For local schema files, use schemaPath parameter.');
             }
 
             if (!schemaData) {
@@ -233,7 +250,16 @@ class ApiPlannerTool extends ToolBase {
         }
     }
 
-    async _fetchSchema(url) {
+    async _fetchSchema(url, schemaType = 'auto') {
+        // If schemaType is 'graphql' or if URL suggests GraphQL endpoint, perform introspection
+        const isGraphQL = schemaType === 'graphql' || 
+                         url.toLowerCase().includes('graphql') ||
+                         url.toLowerCase().includes('/graph');
+        
+        if (isGraphQL) {
+            return await this._fetchGraphQLSchema(url);
+        }
+        
         return new Promise((resolve, reject) => {
             const urlObj = new URL(url);
             const client = urlObj.protocol === 'https:' ? https : http;
@@ -278,8 +304,160 @@ class ApiPlannerTool extends ToolBase {
             req.end();
         });
     }
+    
+    /**
+     * Fetch GraphQL schema via introspection query
+     * GENERIC - Works with any GraphQL endpoint
+     */
+    async _fetchGraphQLSchema(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const client = urlObj.protocol === 'https:' ? https : http;
+            
+            const introspectionQuery = this._getGraphQLIntrospectionQuery();
+            const postData = JSON.stringify({
+                query: introspectionQuery
+            });
+            
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port,
+                path: urlObj.pathname + urlObj.search,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'User-Agent': 'Democratize-Quality-MCP-Server/1.0',
+                    'Content-Length': Buffer.byteLength(postData)
+                }
+            };
 
+            const req = client.request(options, (res) => {
+                let data = '';
+                
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                
+                res.on('end', () => {
+                    try {
+                        const response = JSON.parse(data);
+                        
+                        // Check for GraphQL errors
+                        if (response.errors) {
+                            reject(new Error(`GraphQL introspection failed: ${response.errors[0].message}`));
+                            return;
+                        }
+                        
+                        // Return the introspection result
+                        resolve(response);
+                    } catch (error) {
+                        reject(new Error(`Failed to parse GraphQL response: ${error.message}`));
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                reject(new Error(`Failed to fetch GraphQL schema: ${error.message}`));
+            });
+
+            req.setTimeout(30000, () => {
+                req.destroy();
+                reject(new Error('GraphQL introspection timeout'));
+            });
+
+            req.write(postData);
+            req.end();
+        });
+    }
+
+    /**
+     * Read schema from local file system
+     */
+    async _readSchemaFromFile(filePath, schemaType = 'auto') {
+        try {
+            // Resolve absolute path
+            const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+            
+            // Check file exists
+            try {
+                await fs.access(absolutePath);
+            } catch (error) {
+                throw new Error(`Schema file not found: ${absolutePath}`);
+            }
+
+            // Read file content
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const ext = path.extname(filePath).toLowerCase();
+
+            // Handle .graphql files
+            if (ext === '.graphql' || ext === '.gql') {
+                // Check if content is GraphQL SDL or introspection JSON
+                const trimmedContent = content.trim();
+                
+                // If it starts with '{', it's likely JSON introspection result
+                if (trimmedContent.startsWith('{')) {
+                    try {
+                        return JSON.parse(content);
+                    } catch (error) {
+                        throw new Error(`GraphQL file contains invalid JSON: ${error.message}`);
+                    }
+                }
+                
+                // Otherwise it's SDL (Schema Definition Language) - convert it
+                console.log(`📝 Detected GraphQL SDL in ${path.basename(filePath)}, converting to introspection JSON...`);
+                
+                if (!graphql) {
+                    throw new Error(
+                        `GraphQL SDL detected but 'graphql' package is not installed.\n` +
+                        `Please install it: npm install graphql\n` +
+                        `Or convert manually: npx graphql-cli introspect ${filePath}`
+                    );
+                }
+                
+                try {
+                    // Build schema from SDL
+                    const schema = graphql.buildSchema(content);
+                    
+                    // Generate introspection query result
+                    const introspectionQuery = graphql.getIntrospectionQuery();
+                    const introspectionResult = graphql.introspectionFromSchema(schema);
+                    
+                    // Create output filename (e.g., schema.graphql -> schema.json)
+                    const baseName = path.basename(filePath, ext);
+                    const outputPath = path.join(path.dirname(absolutePath), `${baseName}.json`);
+                    
+                    // Save introspection JSON file
+                    await fs.writeFile(outputPath, JSON.stringify(introspectionResult, null, 2));
+                    console.log(`✅ Introspection JSON saved to: ${outputPath}`);
+                    
+                    return introspectionResult;
+                } catch (error) {
+                    throw new Error(
+                        `Failed to convert GraphQL SDL to introspection JSON: ${error.message}\n` +
+                        `Please check that your SDL syntax is valid.`
+                    );
+                }
+            }
+
+            // Parse JSON or YAML content
+            return this._parseSchemaContent(content, schemaType);
+        } catch (error) {
+            // Re-throw with original message if it's already formatted
+            if (error.message.includes('GraphQL SDL') || error.message.includes('Schema file not found')) {
+                throw error;
+            }
+            throw new Error(`Failed to read schema file: ${error.message}`);
+        }
+    }
+
+    /**
+     * Parse schema content (JSON/YAML) - Internal method used by _fetchSchema and _readSchemaFromFile
+     * Note: SDL conversion is handled in _readSchemaFromFile before reaching this method
+     */
     _parseSchemaContent(content, schemaType) {
+        const trimmedContent = content.trim();
+        
         try {
             // Try JSON first
             return JSON.parse(content);
@@ -1470,10 +1648,848 @@ class ApiPlannerTool extends ToolBase {
         };
     }
 
+    // ============================================================================
+    // GRAPHQL SUPPORT - GENERIC IMPLEMENTATION
+    // ============================================================================
+    
+    /**
+     * Standard GraphQL introspection query (works with ANY GraphQL endpoint)
+     * Follows GraphQL specification: https://spec.graphql.org/October2021/#sec-Introspection
+     */
+    _getGraphQLIntrospectionQuery() {
+        return `
+            query IntrospectionQuery {
+                __schema {
+                    queryType { name }
+                    mutationType { name }
+                    subscriptionType { name }
+                    types {
+                        kind
+                        name
+                        description
+                        fields(includeDeprecated: true) {
+                            name
+                            description
+                            args {
+                                name
+                                description
+                                type { ...TypeRef }
+                                defaultValue
+                            }
+                            type { ...TypeRef }
+                            isDeprecated
+                            deprecationReason
+                        }
+                        inputFields {
+                            name
+                            description
+                            type { ...TypeRef }
+                            defaultValue
+                        }
+                        interfaces { ...TypeRef }
+                        enumValues(includeDeprecated: true) {
+                            name
+                            description
+                            isDeprecated
+                            deprecationReason
+                        }
+                        possibleTypes { ...TypeRef }
+                    }
+                    directives {
+                        name
+                        description
+                        locations
+                        args {
+                            name
+                            description
+                            type { ...TypeRef }
+                            defaultValue
+                        }
+                    }
+                }
+            }
+            
+            fragment TypeRef on __Type {
+                kind
+                name
+                ofType {
+                    kind
+                    name
+                    ofType {
+                        kind
+                        name
+                        ofType {
+                            kind
+                            name
+                            ofType {
+                                kind
+                                name
+                                ofType {
+                                    kind
+                                    name
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+    }
+
     async _generateGraphQLTestPlan(schema, options) {
-        // GraphQL implementation would be added here
-        // For now, return a placeholder
-        throw new Error('GraphQL schema analysis not yet implemented');
+        // Parse schema (generic - works with any GraphQL schema)
+        const parsedSchema = this._parseGraphQLSchema(schema);
+        
+        // Discover operations (generic)
+        const operations = this._discoverGraphQLOperations(parsedSchema);
+        
+        const testPlan = {
+            summary: {
+                title: 'GraphQL API Test Plan',
+                type: 'graphql',
+                baseUrl: options.apiBaseUrl || 'https://graphql.example.com/graphql',
+                totalQueries: operations.queries.length,
+                totalMutations: operations.mutations.length,
+                totalSubscriptions: operations.subscriptions.length,
+                totalScenarios: 0,
+                totalEndpoints: 1 // GraphQL typically has single endpoint
+            },
+            sections: []
+        };
+        
+        // Generate test scenarios for queries (generic)
+        for (const query of operations.queries) {
+            const section = this._generateGraphQLQueryTestSection(query, parsedSchema, options);
+            testPlan.sections.push(section);
+            testPlan.summary.totalScenarios += section.scenarios.length;
+        }
+        
+        // Generate test scenarios for mutations (generic)
+        for (const mutation of operations.mutations) {
+            const section = this._generateGraphQLMutationTestSection(mutation, parsedSchema, options);
+            testPlan.sections.push(section);
+            testPlan.summary.totalScenarios += section.scenarios.length;
+        }
+        
+        // Generate test scenarios for subscriptions if requested
+        if (options.testCategories.includes('subscriptions') && operations.subscriptions.length > 0) {
+            for (const subscription of operations.subscriptions) {
+                const section = this._generateGraphQLSubscriptionTestSection(subscription, parsedSchema, options);
+                testPlan.sections.push(section);
+                testPlan.summary.totalScenarios += section.scenarios.length;
+            }
+        }
+        
+        testPlan.content = this._generateMarkdownContent(testPlan);
+        return testPlan;
+    }
+    
+    /**
+     * Parse GraphQL introspection result into usable structure
+     * GENERIC - Works with any GraphQL schema following the spec
+     */
+    _parseGraphQLSchema(introspectionResult) {
+        // Handle both direct introspection result and wrapped result
+        const schemaData = introspectionResult.__schema || introspectionResult.data?.__schema;
+        
+        if (!schemaData) {
+            throw new Error('Invalid GraphQL introspection result - missing __schema');
+        }
+        
+        const schema = {
+            queryType: schemaData.queryType?.name,
+            mutationType: schemaData.mutationType?.name,
+            subscriptionType: schemaData.subscriptionType?.name,
+            types: {},
+            directives: schemaData.directives || []
+        };
+        
+        // Index all types by name (skip internal GraphQL types starting with __)
+        for (const type of schemaData.types) {
+            if (!type.name.startsWith('__')) {
+                schema.types[type.name] = {
+                    kind: type.kind,
+                    name: type.name,
+                    description: type.description,
+                    fields: type.fields || [],
+                    inputFields: type.inputFields || [],
+                    enumValues: type.enumValues || [],
+                    interfaces: type.interfaces || [],
+                    possibleTypes: type.possibleTypes || []
+                };
+            }
+        }
+        
+        return schema;
+    }
+    
+    /**
+     * Discover all queries, mutations, and subscriptions from schema
+     * GENERIC - Extracts operations from any GraphQL schema
+     */
+    _discoverGraphQLOperations(schema) {
+        const operations = {
+            queries: [],
+            mutations: [],
+            subscriptions: []
+        };
+        
+        // Find Query type operations
+        if (schema.queryType && schema.types[schema.queryType]) {
+            const queryType = schema.types[schema.queryType];
+            operations.queries = (queryType.fields || []).map(field => ({
+                name: field.name,
+                description: field.description,
+                args: field.args || [],
+                returnType: field.type,
+                isDeprecated: field.isDeprecated,
+                deprecationReason: field.deprecationReason
+            }));
+        }
+        
+        // Find Mutation type operations
+        if (schema.mutationType && schema.types[schema.mutationType]) {
+            const mutationType = schema.types[schema.mutationType];
+            operations.mutations = (mutationType.fields || []).map(field => ({
+                name: field.name,
+                description: field.description,
+                args: field.args || [],
+                returnType: field.type,
+                isDeprecated: field.isDeprecated,
+                deprecationReason: field.deprecationReason
+            }));
+        }
+        
+        // Find Subscription type operations
+        if (schema.subscriptionType && schema.types[schema.subscriptionType]) {
+            const subscriptionType = schema.types[schema.subscriptionType];
+            operations.subscriptions = (subscriptionType.fields || []).map(field => ({
+                name: field.name,
+                description: field.description,
+                args: field.args || [],
+                returnType: field.type,
+                isDeprecated: field.isDeprecated,
+                deprecationReason: field.deprecationReason
+            }));
+        }
+        
+        return operations;
+    }
+    
+    /**
+     * Generate realistic value for GraphQL scalar type
+     * GENERIC - Handles built-in scalars and custom scalars using field name semantics
+     */
+    _generateGraphQLScalarValue(scalarType, fieldName = '') {
+        const scalarName = scalarType.name;
+        
+        // ===== BUILT-IN SCALARS (GraphQL Spec - these 5 are always present) =====
+        switch (scalarName) {
+            case 'String':
+                return this._generateStringValue({ type: 'string' }, fieldName);
+            
+            case 'Int':
+                return this._generateNumericValue({ type: 'integer' }, fieldName);
+            
+            case 'Float':
+                return this._generateNumericValue({ type: 'number' }, fieldName);
+            
+            case 'Boolean':
+                return this._generateBooleanValue({}, fieldName);
+            
+            case 'ID':
+                // Generic ID generation
+                if (faker) {
+                    return faker.string.alphanumeric(16);
+                }
+                return `id_${Math.random().toString(36).substr(2, 9)}`;
+        }
+        
+        // ===== COMMON CUSTOM SCALAR PATTERNS (Generic Detection) =====
+        const lowerScalar = scalarName.toLowerCase();
+        
+        // Date/Time scalars (various naming conventions)
+        if (lowerScalar.includes('date') || lowerScalar.includes('time')) {
+            if (lowerScalar.includes('date') && !lowerScalar.includes('time')) {
+                return this._generateStringValue({ format: 'date' }, fieldName);
+            }
+            return this._generateStringValue({ format: 'date-time' }, fieldName);
+        }
+        
+        // URL/URI scalars
+        if (lowerScalar.includes('url') || lowerScalar.includes('uri')) {
+            return this._generateStringValue({ format: 'uri' }, fieldName);
+        }
+        
+        // JSON scalars
+        if (lowerScalar.includes('json')) {
+            return { example: 'json_data' };
+        }
+        
+        // Email scalars
+        if (lowerScalar.includes('email')) {
+            return this._generateStringValue({ format: 'email' }, fieldName);
+        }
+        
+        // HTML/Markdown scalars
+        if (lowerScalar.includes('html')) {
+            return '<p>Sample HTML content</p>';
+        }
+        
+        if (lowerScalar.includes('markdown')) {
+            return '# Sample Markdown\n\nThis is sample content.';
+        }
+        
+        // ===== FALLBACK: Use field name semantic analysis =====
+        // This is the SECRET WEAPON - works for ANY custom scalar!
+        // We analyze the field name to generate appropriate data
+        return this._generateStringValue({ type: 'string' }, fieldName);
+    }
+    
+    /**
+     * Recursively generate sample data from GraphQL type
+     * GENERIC - Handles all GraphQL type kinds with circular reference protection
+     */
+    _generateSampleFromGraphQLType(type, schema, fieldName = '', visited = new Set(), depth = 0) {
+        // Prevent infinite recursion
+        const MAX_DEPTH = 5;
+        if (depth > MAX_DEPTH) {
+            return null;
+        }
+        
+        // Circular reference detection
+        const typeKey = type.name ? `${type.name}_${fieldName}` : `${type.kind}_${fieldName}`;
+        if (visited.has(typeKey)) {
+            return null;
+        }
+        
+        switch (type.kind) {
+            case 'NON_NULL':
+                // Unwrap non-null and continue
+                return this._generateSampleFromGraphQLType(type.ofType, schema, fieldName, visited, depth);
+            
+            case 'LIST':
+                // Generate array with 1-2 sample items
+                visited.add(typeKey);
+                const itemValue = this._generateSampleFromGraphQLType(type.ofType, schema, fieldName, visited, depth + 1);
+                visited.delete(typeKey);
+                return itemValue !== null ? [itemValue] : [];
+            
+            case 'SCALAR':
+                return this._generateGraphQLScalarValue(type, fieldName);
+            
+            case 'ENUM':
+                // Pick first enum value
+                const enumType = schema.types[type.name];
+                if (enumType?.enumValues && enumType.enumValues.length > 0) {
+                    return enumType.enumValues[0].name;
+                }
+                return 'ENUM_VALUE';
+            
+            case 'OBJECT':
+            case 'INPUT_OBJECT':
+                visited.add(typeKey);
+                const objValue = this._generateGraphQLObject(type, schema, visited, depth + 1);
+                visited.delete(typeKey);
+                return objValue;
+            
+            case 'INTERFACE':
+                // For interfaces, generate fields from the interface itself
+                visited.add(typeKey);
+                const interfaceValue = this._generateGraphQLObject(type, schema, visited, depth + 1);
+                visited.delete(typeKey);
+                return interfaceValue;
+            
+            case 'UNION':
+                // Pick first possible type
+                const unionType = schema.types[type.name];
+                if (unionType?.possibleTypes && unionType.possibleTypes.length > 0) {
+                    const firstType = unionType.possibleTypes[0];
+                    return this._generateSampleFromGraphQLType(firstType, schema, fieldName, visited, depth + 1);
+                }
+                return null;
+            
+            default:
+                return null;
+        }
+    }
+    
+    /**
+     * Generate sample object with all fields
+     * GENERIC - Works with any GraphQL object type
+     */
+    _generateGraphQLObject(type, schema, visited, depth) {
+        const typeDefinition = schema.types[type.name];
+        if (!typeDefinition) {
+            return {};
+        }
+        
+        const obj = {};
+        const fields = typeDefinition.fields || typeDefinition.inputFields || [];
+        
+        // Limit fields at deep nesting levels to prevent bloat
+        const maxFieldsAtDepth = depth > 3 ? 3 : (depth > 2 ? 5 : 10);
+        const fieldsToGenerate = fields.slice(0, maxFieldsAtDepth);
+        
+        for (const field of fieldsToGenerate) {
+            // Use field name for semantic data generation
+            const value = this._generateSampleFromGraphQLType(
+                field.type,
+                schema,
+                field.name,
+                visited,
+                depth
+            );
+            
+            if (value !== null) {
+                obj[field.name] = value;
+            }
+        }
+        
+        return obj;
+    }
+    
+    /**
+     * Build GraphQL query string with variables
+     * GENERIC - Constructs valid GraphQL query/mutation syntax
+     */
+    _buildGraphQLQueryString(operation, args, schema, operationType = 'query') {
+        const operationName = this._capitalize(operation.name);
+        
+        // Build variable definitions
+        const variableDefinitions = [];
+        const argumentsList = [];
+        
+        for (const arg of args) {
+            const varName = arg.name;
+            const typeString = this._getGraphQLTypeString(arg.type);
+            variableDefinitions.push(`$${varName}: ${typeString}`);
+            argumentsList.push(`${arg.name}: $${varName}`);
+        }
+        
+        // Build field selection (simplified - select first level fields)
+        const returnType = this._unwrapType(operation.returnType);
+        const fields = this._buildFieldSelection(returnType, schema, 0);
+        
+        // Construct query string
+        let queryString = operationType;
+        if (variableDefinitions.length > 0) {
+            queryString += ` ${operationName}(${variableDefinitions.join(', ')})`;
+        } else {
+            queryString += ` ${operationName}`;
+        }
+        
+        queryString += ' {\n';
+        if (argumentsList.length > 0) {
+            queryString += `  ${operation.name}(${argumentsList.join(', ')}) `;
+        } else {
+            queryString += `  ${operation.name} `;
+        }
+        queryString += fields;
+        queryString += '\n}';
+        
+        return queryString;
+    }
+    
+    /**
+     * Build field selection for GraphQL query
+     * GENERIC - Selects appropriate fields based on return type
+     */
+    _buildFieldSelection(type, schema, depth = 0) {
+        const MAX_DEPTH = 2;
+        if (depth > MAX_DEPTH) {
+            return '';
+        }
+        
+        const typeDefinition = schema.types[type.name];
+        if (!typeDefinition || !typeDefinition.fields || typeDefinition.fields.length === 0) {
+            return '';
+        }
+        
+        let selection = '{\n';
+        const indent = '  '.repeat(depth + 2);
+        
+        // Select up to 5 fields to keep queries manageable
+        const fieldsToSelect = typeDefinition.fields.slice(0, 5);
+        
+        for (const field of fieldsToSelect) {
+            const fieldType = this._unwrapType(field.type);
+            const fieldTypeDefinition = schema.types[fieldType.name];
+            
+            // If field is scalar or enum, just select it
+            if (!fieldTypeDefinition || fieldType.kind === 'SCALAR' || fieldType.kind === 'ENUM') {
+                selection += `${indent}${field.name}\n`;
+            } else if (fieldType.kind === 'OBJECT' && depth < MAX_DEPTH) {
+                // If field is object, recursively build selection
+                const subSelection = this._buildFieldSelection(fieldType, schema, depth + 1);
+                if (subSelection) {
+                    selection += `${indent}${field.name} ${subSelection}`;
+                } else {
+                    selection += `${indent}${field.name}\n`;
+                }
+            }
+        }
+        
+        selection += '  '.repeat(depth + 1) + '}';
+        return selection;
+    }
+    
+    /**
+     * Get GraphQL type string (e.g., "String!", "[ID!]!")
+     * GENERIC - Constructs type strings following GraphQL syntax
+     */
+    _getGraphQLTypeString(type) {
+        if (type.kind === 'NON_NULL') {
+            return this._getGraphQLTypeString(type.ofType) + '!';
+        }
+        if (type.kind === 'LIST') {
+            return '[' + this._getGraphQLTypeString(type.ofType) + ']';
+        }
+        return type.name;
+    }
+    
+    /**
+     * Unwrap type to get base type (remove NON_NULL and LIST wrappers)
+     */
+    _unwrapType(type) {
+        if (type.kind === 'NON_NULL' || type.kind === 'LIST') {
+            return this._unwrapType(type.ofType);
+        }
+        return type;
+    }
+    
+    /**
+     * Capitalize first letter
+     */
+    _capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    
+    /**
+     * Generate test section for GraphQL query
+     * GENERIC - Creates test scenarios for any GraphQL query operation
+     */
+    _generateGraphQLQueryTestSection(query, schema, options) {
+        const scenarios = [];
+        
+        // Happy path scenario
+        const happyPathScenario = {
+            title: `${query.name} - Happy Path`,
+            method: 'POST',
+            endpoint: '/graphql',
+            description: query.description || `Test successful execution of ${query.name} query`,
+            data: {
+                query: this._buildGraphQLQueryString(query, query.args, schema, 'query'),
+                variables: this._generateGraphQLVariables(query.args, schema)
+            },
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            expect: {
+                status: 200,
+                body: {
+                    data: {
+                        [query.name]: this._generateExpectedGraphQLResponse(query.returnType, schema)
+                    }
+                }
+            }
+        };
+        
+        if (options.includeAuth) {
+            happyPathScenario.headers['Authorization'] = 'Bearer {{auth_token}}';
+        }
+        
+        scenarios.push(happyPathScenario);
+        
+        // Error scenarios
+        if (options.includeErrorHandling) {
+            // Missing required arguments
+            if (query.args.some(arg => arg.type.kind === 'NON_NULL')) {
+                scenarios.push({
+                    title: `${query.name} - Missing Required Arguments`,
+                    method: 'POST',
+                    endpoint: '/graphql',
+                    description: 'Test error handling when required arguments are missing',
+                    data: {
+                        query: this._buildGraphQLQueryString(query, query.args, schema, 'query'),
+                        variables: {}
+                    },
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    expect: {
+                        status: 200,
+                        body: {
+                            errors: [
+                                {
+                                    message: 'string'
+                                }
+                            ]
+                        }
+                    }
+                });
+            }
+            
+            // Invalid field selection
+            scenarios.push({
+                title: `${query.name} - Invalid Field Selection`,
+                method: 'POST',
+                endpoint: '/graphql',
+                description: 'Test error handling for invalid field in query',
+                data: {
+                    query: `query { ${query.name} { invalidField } }`,
+                    variables: this._generateGraphQLVariables(query.args, schema)
+                },
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                expect: {
+                    status: 200,
+                    body: {
+                        errors: [
+                            {
+                                message: 'string'
+                            }
+                        ]
+                    }
+                }
+            });
+        }
+        
+        // Authentication error
+        if (options.includeAuth) {
+            scenarios.push({
+                title: `${query.name} - Unauthorized Access`,
+                method: 'POST',
+                endpoint: '/graphql',
+                description: 'Test access without authentication',
+                data: {
+                    query: this._buildGraphQLQueryString(query, query.args, schema, 'query'),
+                    variables: this._generateGraphQLVariables(query.args, schema)
+                },
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                expect: {
+                    status: [200, 401],
+                    body: {
+                        errors: [
+                            {
+                                message: 'string'
+                            }
+                        ]
+                    }
+                }
+            });
+        }
+        
+        return {
+            title: `Query: ${query.name}`,
+            description: query.description || `Test cases for ${query.name} query`,
+            scenarios: scenarios
+        };
+    }
+    
+    /**
+     * Generate test section for GraphQL mutation
+     * GENERIC - Creates test scenarios for any GraphQL mutation operation
+     */
+    _generateGraphQLMutationTestSection(mutation, schema, options) {
+        const scenarios = [];
+        
+        // Happy path scenario
+        const happyPathScenario = {
+            title: `${mutation.name} - Happy Path`,
+            method: 'POST',
+            endpoint: '/graphql',
+            description: mutation.description || `Test successful execution of ${mutation.name} mutation`,
+            data: {
+                query: this._buildGraphQLQueryString(mutation, mutation.args, schema, 'mutation'),
+                variables: this._generateGraphQLVariables(mutation.args, schema)
+            },
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            expect: {
+                status: 200,
+                body: {
+                    data: {
+                        [mutation.name]: this._generateExpectedGraphQLResponse(mutation.returnType, schema)
+                    }
+                }
+            }
+        };
+        
+        if (options.includeAuth) {
+            happyPathScenario.headers['Authorization'] = 'Bearer {{auth_token}}';
+        }
+        
+        scenarios.push(happyPathScenario);
+        
+        // Error scenarios
+        if (options.includeErrorHandling) {
+            // Invalid input data
+            scenarios.push({
+                title: `${mutation.name} - Invalid Input Data`,
+                method: 'POST',
+                endpoint: '/graphql',
+                description: 'Test error handling with invalid input data',
+                data: {
+                    query: this._buildGraphQLQueryString(mutation, mutation.args, schema, 'mutation'),
+                    variables: this._generateInvalidGraphQLVariables(mutation.args, schema)
+                },
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                expect: {
+                    status: 200,
+                    body: {
+                        errors: [
+                            {
+                                message: 'string'
+                            }
+                        ]
+                    }
+                }
+            });
+        }
+        
+        // Authorization error for mutations
+        if (options.includeAuth) {
+            scenarios.push({
+                title: `${mutation.name} - Unauthorized Mutation`,
+                method: 'POST',
+                endpoint: '/graphql',
+                description: 'Test mutation without proper authorization',
+                data: {
+                    query: this._buildGraphQLQueryString(mutation, mutation.args, schema, 'mutation'),
+                    variables: this._generateGraphQLVariables(mutation.args, schema)
+                },
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                expect: {
+                    status: [200, 401, 403],
+                    body: {
+                        errors: [
+                            {
+                                message: 'string'
+                            }
+                        ]
+                    }
+                }
+            });
+        }
+        
+        return {
+            title: `Mutation: ${mutation.name}`,
+            description: mutation.description || `Test cases for ${mutation.name} mutation`,
+            scenarios: scenarios
+        };
+    }
+    
+    /**
+     * Generate test section for GraphQL subscription
+     * GENERIC - Creates test scenarios for any GraphQL subscription operation
+     */
+    _generateGraphQLSubscriptionTestSection(subscription, schema, options) {
+        const scenarios = [];
+        
+        // Happy path scenario
+        const happyPathScenario = {
+            title: `${subscription.name} - Happy Path`,
+            method: 'POST',
+            endpoint: '/graphql',
+            description: subscription.description || `Test successful subscription to ${subscription.name}`,
+            data: {
+                query: this._buildGraphQLQueryString(subscription, subscription.args, schema, 'subscription'),
+                variables: this._generateGraphQLVariables(subscription.args, schema)
+            },
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            expect: {
+                status: 200,
+                body: {
+                    data: {
+                        [subscription.name]: this._generateExpectedGraphQLResponse(subscription.returnType, schema)
+                    }
+                }
+            }
+        };
+        
+        if (options.includeAuth) {
+            happyPathScenario.headers['Authorization'] = 'Bearer {{auth_token}}';
+        }
+        
+        scenarios.push(happyPathScenario);
+        
+        return {
+            title: `Subscription: ${subscription.name}`,
+            description: subscription.description || `Test cases for ${subscription.name} subscription`,
+            scenarios: scenarios
+        };
+    }
+    
+    /**
+     * Generate variables object for GraphQL operation
+     * GENERIC - Creates realistic variable values based on argument types
+     */
+    _generateGraphQLVariables(args, schema) {
+        const variables = {};
+        
+        for (const arg of args) {
+            const argType = this._unwrapType(arg.type);
+            variables[arg.name] = this._generateSampleFromGraphQLType(argType, schema, arg.name, new Set(), 0);
+        }
+        
+        return variables;
+    }
+    
+    /**
+     * Generate invalid variables for error testing
+     * GENERIC - Creates intentionally invalid data for negative testing
+     */
+    _generateInvalidGraphQLVariables(args, schema) {
+        const variables = {};
+        
+        for (const arg of args) {
+            const argType = this._unwrapType(arg.type);
+            
+            // Generate wrong type of data based on expected type
+            if (argType.kind === 'SCALAR') {
+                switch (argType.name) {
+                    case 'String':
+                        variables[arg.name] = 12345; // Wrong type
+                        break;
+                    case 'Int':
+                    case 'Float':
+                        variables[arg.name] = 'not_a_number'; // Wrong type
+                        break;
+                    case 'Boolean':
+                        variables[arg.name] = 'not_a_boolean'; // Wrong type
+                        break;
+                    case 'ID':
+                        variables[arg.name] = { invalid: 'object' }; // Wrong type
+                        break;
+                    default:
+                        variables[arg.name] = null;
+                }
+            } else {
+                variables[arg.name] = null;
+            }
+        }
+        
+        return variables;
+    }
+    
+    /**
+     * Generate expected response structure for GraphQL operation
+     * GENERIC - Creates expected response based on return type
+     */
+    _generateExpectedGraphQLResponse(returnType, schema) {
+        const unwrappedType = this._unwrapType(returnType);
+        return this._generateSampleFromGraphQLType(unwrappedType, schema, '', new Set(), 0);
     }
 
     _generateMarkdownContent(testPlan) {