@pattern-stack/frontend-patterns 0.0.6 → 0.1.0

package/cli/src/codegen/openapi/hook-generator.js

@@ -0,0 +1,1057 @@
+"use strict";
+/**
+ * React Hook Generator
+ *
+ * Generates React hooks with TanStack Query integration for API endpoints
+ * with proper TypeScript typing and error/loading states.
+ *
+ * Part of FRO-3: React Hook Generator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactHookGenerator = void 0;
+exports.generateHooks = generateHooks;
+const hook_config_1 = require("./hook-config");
+const confidence_scorer_1 = require("./confidence-scorer");
+const bulk_hook_generator_1 = require("./bulk-hook-generator");
+const bulk_types_1 = require("./bulk-types");
+class ReactHookGenerator {
+    constructor(options = {}) {
+        this.scoredNames = [];
+        this.resourceConfigs = new Map();
+        this.options = {
+            queryKeyPrefix: options.queryKeyPrefix || 'api',
+            includeInfiniteQueries: options.includeInfiniteQueries !== false,
+            includeOptimisticUpdates: options.includeOptimisticUpdates !== false,
+            includeMutationHelpers: options.includeMutationHelpers ?? true,
+            authenticationRequired: options.authenticationRequired ?? true,
+            errorHandling: options.errorHandling || 'throw',
+            configPath: options.configPath || './hooks.config.json',
+            enableConfidenceScoring: options.enableConfidenceScoring ?? true
+        };
+        this.configManager = new hook_config_1.HookConfigManager(this.options.configPath);
+        this.confidenceScorer = new confidence_scorer_1.ConfidenceScorer();
+        this.bulkHookGenerator = new bulk_hook_generator_1.BulkHookGenerator();
+    }
+    /**
+     * Detect resource operations from endpoints
+     */
+    detectResourceOperations(endpoints) {
+        const resourceMap = new Map();
+        endpoints.forEach(endpoint => {
+            const resourceName = this.extractResourceName(endpoint.path);
+            if (!resourceName)
+                return;
+            const config = resourceMap.get(resourceName) || this.createDefaultConfig(resourceName);
+            // Check if this is a bulk operation
+            const requestBody = endpoint.requestBody;
+            if ((0, bulk_types_1.isBulkOperation)(endpoint.path, endpoint.method, requestBody)) {
+                const bulkType = detectBulkOperationType(endpoint.path, endpoint.method);
+                switch (bulkType) {
+                    case 'delete':
+                        config.operations.bulkDelete = {
+                            path: endpoint.path,
+                            method: endpoint.method
+                        };
+                        break;
+                    case 'update':
+                        config.operations.bulkUpdate = {
+                            path: endpoint.path,
+                            method: endpoint.method
+                        };
+                        break;
+                    case 'create':
+                        config.operations.bulkCreate = {
+                            path: endpoint.path,
+                            method: endpoint.method
+                        };
+                        break;
+                    case 'mixed':
+                    default:
+                        if (!config.operations.customBulk) {
+                            config.operations.customBulk = [];
+                        }
+                        config.operations.customBulk.push({
+                            name: this.getOperationName(endpoint),
+                            path: endpoint.path,
+                            method: endpoint.method,
+                            operationType: bulkType || 'mixed'
+                        });
+                        break;
+                }
+            }
+            else {
+                // Standard CRUD operations
+                switch (endpoint.method.toLowerCase()) {
+                    case 'get':
+                        if (endpoint.path.includes('{')) {
+                            // Single resource fetch
+                        }
+                        else {
+                            config.operations.list = { path: endpoint.path, method: endpoint.method };
+                        }
+                        break;
+                    case 'post':
+                        config.operations.create = { path: endpoint.path, method: endpoint.method };
+                        break;
+                    case 'put':
+                    case 'patch':
+                        config.operations.update = { path: endpoint.path, method: endpoint.method };
+                        break;
+                    case 'delete':
+                        config.operations.delete = { path: endpoint.path, method: endpoint.method };
+                        break;
+                }
+            }
+            resourceMap.set(resourceName, config);
+        });
+        return resourceMap;
+    }
+    /**
+     * Extract resource name from path
+     */
+    extractResourceName(path) {
+        // Remove API version prefix
+        const cleanPath = path.replace(/^\/api\/v\d+\//, '/');
+        const segments = cleanPath.split('/').filter(Boolean);
+        // Find the first non-parameter segment
+        for (const segment of segments) {
+            if (!segment.startsWith('{')) {
+                return segment.replace(/-/g, '_');
+            }
+        }
+        return null;
+    }
+    /**
+     * Create default API config for a resource
+     */
+    createDefaultConfig(resourceName) {
+        return {
+            baseURL: '',
+            resourceName,
+            operations: {}
+        };
+    }
+    async generate(parsedAPI) {
+        const endpoints = parsedAPI.endpoints;
+        // Load configuration
+        await this.configManager.load();
+        // Detect resource operations
+        this.resourceConfigs = this.detectResourceOperations(endpoints);
+        // Reset scored names for this generation
+        this.scoredNames = [];
+        const result = {
+            queries: this.generateQueryHooks(endpoints),
+            mutations: this.generateMutationHooks(endpoints),
+            keys: this.generateQueryKeys(endpoints),
+            types: this.generateHookTypes(endpoints),
+            index: this.generateIndexFile(),
+            report: undefined
+        };
+        // Generate confidence report if scoring is enabled
+        if (this.options.enableConfidenceScoring && this.scoredNames.length > 0) {
+            console.log(`Generated ${this.scoredNames.length} scored hook names`);
+            result.report = this.confidenceScorer.generateReport(this.scoredNames);
+            // Update statistics
+            const stats = {
+                totalGenerated: this.scoredNames.length,
+                highConfidence: this.scoredNames.filter(s => s.confidence === 'high').length,
+                mediumConfidence: this.scoredNames.filter(s => s.confidence === 'medium').length,
+                lowConfidence: this.scoredNames.filter(s => s.confidence === 'low').length,
+                humanReviewed: this.configManager.getReviewedNames().length
+            };
+            this.configManager.updateStatistics(stats);
+            // Save updated configuration
+            await this.configManager.save();
+        }
+        return result;
+    }
+    generateQueryHooks(endpoints) {
+        const hooks = [];
+        hooks.push(this.generateFileHeader('Query Hooks'));
+        hooks.push('');
+        hooks.push("import { useQuery, useInfiniteQuery, type UseQueryOptions, type UseInfiniteQueryOptions } from '@tanstack/react-query'");
+        hooks.push("import { apiClient } from '../client'");
+        hooks.push("import { queryKeys } from './keys'");
+        hooks.push("import * as Types from './types'");
+        hooks.push('');
+        // Filter GET endpoints for queries
+        const queryEndpoints = endpoints.filter(endpoint => endpoint.method === 'get');
+        // Track generated hook names to avoid duplicates
+        const generatedHooks = new Map();
+        for (const endpoint of queryEndpoints) {
+            let hookName = this.generateQueryHookName(endpoint);
+            // If we've already generated this hook, add suffix to differentiate
+            if (generatedHooks.has(hookName)) {
+                const existingEndpoint = generatedHooks.get(hookName);
+                // Determine which endpoint should get a suffix based on the path
+                const existingIsSimpler = existingEndpoint.path.split('/').filter(s => !s.startsWith('{')).length <
+                    endpoint.path.split('/').filter(s => !s.startsWith('{')).length;
+                if (existingIsSimpler) {
+                    // Current endpoint needs a suffix
+                    const suffix = endpoint.path.includes('/{subcategory_id}') ? 'Single' : 'List';
+                    hookName = `${hookName}${suffix}`;
+                }
+                else {
+                    // Need to rename the existing hook that we already added
+                    const existingSuffix = existingEndpoint.path.includes('/{subcategory_id}') ? 'Single' : 'List';
+                    const existingHookName = hookName;
+                    const newExistingHookName = `${existingHookName}${existingSuffix}`;
+                    // Find and update the existing hook in our output
+                    for (let i = hooks.length - 1; i >= 0; i--) {
+                        if (hooks[i].includes(`function ${existingHookName}(`)) {
+                            hooks[i] = hooks[i].replace(`function ${existingHookName}(`, `function ${newExistingHookName}(`);
+                            // Also update the JSDoc if it references the hook name
+                            if (i > 0 && hooks[i - 1].includes(`${existingHookName}`)) {
+                                hooks[i - 1] = hooks[i - 1].replace(existingHookName, newExistingHookName);
+                            }
+                            break;
+                        }
+                    }
+                    // Update our tracking map
+                    generatedHooks.delete(existingHookName);
+                    generatedHooks.set(newExistingHookName, existingEndpoint);
+                }
+            }
+            generatedHooks.set(hookName, endpoint);
+            const hook = this.generateQueryHook(endpoint, hookName);
+            hooks.push(hook);
+            hooks.push('');
+            // Generate infinite query version if applicable
+            if (this.options.includeInfiniteQueries && this.isListEndpoint(endpoint)) {
+                const infiniteHook = this.generateInfiniteQueryHook(endpoint, hookName);
+                hooks.push(infiniteHook);
+                hooks.push('');
+            }
+        }
+        return hooks.join('\n');
+    }
+    generateQueryHook(endpoint, hookName) {
+        const operationName = this.getOperationName(endpoint);
+        const hasParams = this.hasRequiredParams(endpoint);
+        const lines = [];
+        // Generate JSDoc
+        lines.push('/**');
+        if (endpoint.summary) {
+            lines.push(` * ${endpoint.summary}`);
+        }
+        if (endpoint.description) {
+            lines.push(` * ${endpoint.description}`);
+        }
+        lines.push(` * @param ${hasParams ? 'params' : 'options'} ${hasParams ? 'Request parameters' : 'Query options'}`);
+        lines.push(' */');
+        // Generate hook signature
+        const paramType = hasParams ? this.generateParamType(endpoint) : '';
+        const params = hasParams ? `params: ${paramType}, options?: UseQueryOptions<any, any, any>` : 'options?: UseQueryOptions<any, any, any>';
+        lines.push(`export function ${hookName}(${params}) {`);
+        // Generate hook body
+        // Extract the query key name from the hook name (remove 'use' prefix)
+        const queryKeyName = hookName.replace(/^use/, '');
+        const queryKeyNameCamelCase = queryKeyName.charAt(0).toLowerCase() + queryKeyName.slice(1);
+        const queryKeyCall = hasParams ?
+            `queryKeys.${queryKeyNameCamelCase}(params)` :
+            `queryKeys.${queryKeyNameCamelCase}()`;
+        const apiCall = hasParams ?
+            `() => apiClient.${this.camelCase(operationName)}(params)` :
+            `() => apiClient.${this.camelCase(operationName)}()`;
+        lines.push('  return useQuery({');
+        lines.push(`    queryKey: ${queryKeyCall},`);
+        lines.push(`    queryFn: ${apiCall},`);
+        // Note: Authentication is handled by the API client interceptors
+        // If you need to disable queries when not authenticated, use:
+        // enabled: !!user && (options?.enabled ?? true) in your component
+        lines.push('    ...options');
+        lines.push('  })');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generateInfiniteQueryHook(endpoint, baseHookName) {
+        const hookName = baseHookName.replace('use', 'useInfinite');
+        const operationName = this.getOperationName(endpoint);
+        const lines = [];
+        lines.push('/**');
+        lines.push(` * Infinite query version of ${baseHookName}`);
+        lines.push(' */');
+        const paramType = this.generateParamType(endpoint);
+        // Extract the query key name from the hook name (remove 'use' prefix)
+        const queryKeyName = baseHookName.replace(/^use/, '');
+        const queryKeyNameCamelCase = queryKeyName.charAt(0).toLowerCase() + queryKeyName.slice(1);
+        lines.push(`export function ${hookName}(params: ${paramType}, options?: UseInfiniteQueryOptions<any, any, any, any, any>) {`);
+        lines.push('  return useInfiniteQuery({');
+        lines.push(`    queryKey: [...queryKeys.${queryKeyNameCamelCase}(), params],`);
+        lines.push(`    queryFn: ({ pageParam = 1 }) => apiClient.${this.camelCase(operationName)}({ ...params, page: pageParam }),`);
+        lines.push('    getNextPageParam: (lastPage, allPages) => {');
+        lines.push('      // Implement pagination logic based on your API response structure');
+        lines.push('      return lastPage?.hasNextPage ? allPages.length + 1 : undefined');
+        lines.push('    },');
+        lines.push('    initialPageParam: 1,');
+        lines.push('    ...options');
+        lines.push('  })');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generateMutationHooks(endpoints) {
+        const hooks = [];
+        hooks.push(this.generateFileHeader('Mutation Hooks'));
+        hooks.push('');
+        hooks.push("import { useMutation, useQueryClient, type UseMutationOptions } from '@tanstack/react-query'");
+        hooks.push("import { apiClient } from '../client'");
+        hooks.push("import { queryKeys } from './keys'");
+        hooks.push("import * as Types from './types'");
+        hooks.push("import type { BulkOperationRequest, BulkOperationResponse, BulkOperationProgress, BulkMutationOptions } from '../bulk-types'");
+        hooks.push('');
+        // Filter non-GET endpoints for mutations
+        const mutationEndpoints = endpoints.filter(endpoint => endpoint.method !== 'get');
+        // Track generated hook names to avoid duplicates
+        const generatedHooks = new Map();
+        for (const endpoint of mutationEndpoints) {
+            // Check if this is a bulk operation
+            const requestBody = endpoint.requestBody;
+            const isBulk = (0, bulk_types_1.isBulkOperation)(endpoint.path, endpoint.method, requestBody);
+            let hookName = this.generateMutationHookName(endpoint);
+            // If we've already generated this hook, add suffix to differentiate
+            if (generatedHooks.has(hookName)) {
+                const existingEndpoint = generatedHooks.get(hookName);
+                // Add method suffix to differentiate
+                const methodSuffix = endpoint.method.charAt(0).toUpperCase() + endpoint.method.slice(1);
+                hookName = `${hookName}${methodSuffix}`;
+            }
+            generatedHooks.set(hookName, endpoint);
+            // Generate appropriate hook based on type
+            const hook = isBulk
+                ? this.bulkHookGenerator.generateBulkMutationHook(endpoint, hookName, this.getOperationName(endpoint))
+                : this.generateMutationHook(endpoint, hookName);
+            hooks.push(hook);
+            hooks.push('');
+        }
+        return hooks.join('\n');
+    }
+    generateMutationHook(endpoint, hookName) {
+        const operationName = this.getOperationName(endpoint);
+        const lines = [];
+        // Generate JSDoc
+        lines.push('/**');
+        if (endpoint.summary) {
+            lines.push(` * ${endpoint.summary}`);
+        }
+        if (endpoint.description) {
+            lines.push(` * ${endpoint.description}`);
+        }
+        lines.push(' */');
+        // Generate hook signature
+        const mutationType = this.generateMutationType(endpoint);
+        lines.push(`export function ${hookName}(options?: UseMutationOptions<any, any, ${mutationType}>) {`);
+        lines.push('  const queryClient = useQueryClient()');
+        lines.push('');
+        lines.push('  return useMutation({');
+        // Generate mutation function
+        const hasParams = this.hasRequiredParams(endpoint);
+        if (hasParams) {
+            lines.push(`    mutationFn: ({ pathParams, ...data }) => apiClient.${this.camelCase(operationName)}(pathParams, data),`);
+        }
+        else {
+            lines.push(`    mutationFn: (data) => apiClient.${this.camelCase(operationName)}(data),`);
+        }
+        // Generate optimistic updates and cache invalidation
+        if (this.options.includeOptimisticUpdates) {
+            lines.push(this.generateOptimisticUpdate(endpoint));
+        }
+        lines.push(this.generateCacheInvalidation(endpoint));
+        lines.push('    ...options');
+        lines.push('  })');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generateOptimisticUpdate(endpoint) {
+        const method = endpoint.method.toLowerCase();
+        const resource = endpoint.tags?.[0] || 'default';
+        const hasPathParams = endpoint.parameters.some(p => p.in === 'path');
+        switch (method) {
+            case 'post':
+                return `    onMutate: async (data: any) => {
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
+      
+      // Snapshot previous value
+      const previousData = queryClient.getQueryData(queryKeys.${resource}())
+      
+      // Optimistically update cache
+      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
+        if (Array.isArray(old)) {
+          return [...old, data]
+        }
+        return old
+      })
+      
+      return { previousData }
+    },
+    onError: (err: any, data: any, context: any) => {
+      // Rollback on error
+      if (context?.previousData !== undefined) {
+        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
+      }
+    },`;
+            case 'put':
+            case 'patch':
+                if (hasPathParams) {
+                    return `    onMutate: async (data: any) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
+      
+      const previousData = queryClient.getQueryData(queryKeys.${resource}())
+      
+      // Update specific item in cache
+      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
+        if (Array.isArray(old)) {
+          return old.map((item: any) => 
+            item.id === data.pathParams?.id || item.id === data.pathParams?.${resource.slice(0, -1)}_id 
+              ? { ...item, ...data } 
+              : item
+          )
+        }
+        return old
+      })
+      
+      return { previousData }
+    },
+    onError: (err: any, data: any, context: any) => {
+      if (context?.previousData !== undefined) {
+        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
+      }
+    },`;
+                }
+                return `    onMutate: async (data: any) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
+      
+      const previousData = queryClient.getQueryData(queryKeys.${resource}())
+      
+      // Update cache with new data
+      queryClient.setQueryData(queryKeys.${resource}(), data)
+      
+      return { previousData }
+    },
+    onError: (err: any, data: any, context: any) => {
+      if (context?.previousData !== undefined) {
+        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
+      }
+    },`;
+            case 'delete':
+                return `    onMutate: async (data: any) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
+      
+      const previousData = queryClient.getQueryData(queryKeys.${resource}())
+      
+      // Remove item from cache
+      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
+        if (Array.isArray(old)) {
+          const idToDelete = data.pathParams?.id || data.pathParams?.${resource.slice(0, -1)}_id || data
+          return old.filter((item: any) => item.id !== idToDelete)
+        }
+        return old
+      })
+      
+      return { previousData }
+    },
+    onError: (err: any, data: any, context: any) => {
+      if (context?.previousData !== undefined) {
+        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
+      }
+    },`;
+            default:
+                return '';
+        }
+    }
+    generateCacheInvalidation(endpoint) {
+        const relatedTags = this.getRelatedQueryTags(endpoint);
+        return `    onSettled: () => {
+      // Invalidate related queries
+      ${relatedTags.map(tag => `queryClient.invalidateQueries({ queryKey: queryKeys.${tag}() })`).join('\n      ')}
+    },`;
+    }
+    generateQueryKeys(endpoints) {
+        const keys = [];
+        keys.push(this.generateFileHeader('Query Keys'));
+        keys.push('');
+        keys.push('/**');
+        keys.push(' * Centralized query key factory');
+        keys.push(' * Ensures consistent cache key generation across the application');
+        keys.push(' */');
+        keys.push('');
+        keys.push('export const queryKeys = {');
+        keys.push(`  all: ['${this.options.queryKeyPrefix}'] as const,`);
+        keys.push('');
+        // Group endpoints by resource/tag
+        const groupedEndpoints = this.groupEndpointsByResource(endpoints);
+        for (const [resource, resourceEndpoints] of Object.entries(groupedEndpoints)) {
+            keys.push(`  // ${resource} keys`);
+            keys.push(`  ${resource}: () => [...queryKeys.all, '${resource}'] as const,`);
+            // Track generated key names to avoid duplicates
+            const generatedKeys = new Map();
+            for (const endpoint of resourceEndpoints) {
+                if (endpoint.method !== 'get')
+                    continue;
+                const operationName = this.getOperationName(endpoint);
+                let keyName = this.camelCase(operationName.replace(/^get/, ''));
+                // If we've already generated this key, add suffix to differentiate
+                if (generatedKeys.has(keyName)) {
+                    const existingEndpoint = generatedKeys.get(keyName);
+                    // Determine which endpoint should get a suffix based on the path
+                    // The one with a single resource gets the plain name, the one with sub-resources gets a suffix
+                    const existingIsSimpler = existingEndpoint.path.split('/').filter(s => !s.startsWith('{')).length <
+                        endpoint.path.split('/').filter(s => !s.startsWith('{')).length;
+                    if (existingIsSimpler) {
+                        // Current endpoint needs a suffix
+                        const suffix = endpoint.path.includes('/{subcategory_id}') ? 'Single' : 'List';
+                        keyName = `${keyName}${suffix}`;
+                    }
+                    else {
+                        // Update the existing key with a suffix
+                        const existingSuffix = existingEndpoint.path.includes('/{subcategory_id}') ? 'Single' : 'List';
+                        const existingKeyName = keyName;
+                        const newExistingKeyName = `${existingKeyName}${existingSuffix}`;
+                        // Find and update the existing key in our output
+                        for (let i = keys.length - 1; i >= 0; i--) {
+                            if (keys[i].includes(`${existingKeyName}:`)) {
+                                // Replace both the function name and the cache key string
+                                keys[i] = keys[i]
+                                    .replace(`${existingKeyName}:`, `${newExistingKeyName}:`)
+                                    .replace(`'${existingKeyName}'`, `'${newExistingKeyName}'`);
+                                break;
+                            }
+                        }
+                        // Update our tracking map
+                        generatedKeys.delete(existingKeyName);
+                        generatedKeys.set(newExistingKeyName, existingEndpoint);
+                    }
+                }
+                generatedKeys.set(keyName, endpoint);
+                if (this.hasRequiredParams(endpoint)) {
+                    keys.push(`  ${keyName}: (params: any) => [...queryKeys.${resource}(), '${keyName}', params] as const,`);
+                }
+                else {
+                    keys.push(`  ${keyName}: () => [...queryKeys.${resource}(), '${keyName}'] as const,`);
+                }
+            }
+            keys.push('');
+        }
+        keys.push('}');
+        return keys.join('\n');
+    }
+    generateHookTypes(endpoints) {
+        const types = [];
+        types.push(this.generateFileHeader('Hook Types'));
+        types.push('');
+        types.push('// Re-export bulk operation types for convenience');
+        types.push("export type { BulkOperationRequest, BulkOperationResponse, BulkOperationProgress, BulkMutationOptions } from '../bulk-types'");
+        types.push('');
+        // Track generated type names to avoid duplicates
+        const generatedTypes = new Set();
+        // Generate parameter and response types for hooks
+        for (const endpoint of endpoints) {
+            const operationName = this.getOperationName(endpoint);
+            if (this.hasRequiredParams(endpoint)) {
+                const typeName = `${this.capitalize(operationName)}Params`;
+                if (!generatedTypes.has(typeName)) {
+                    generatedTypes.add(typeName);
+                    const paramType = this.generateParamType(endpoint);
+                    types.push(`export interface ${typeName} ${paramType}`);
+                    types.push('');
+                }
+            }
+            if (endpoint.method !== 'get') {
+                const typeName = `${this.capitalize(operationName)}Data`;
+                if (!generatedTypes.has(typeName)) {
+                    generatedTypes.add(typeName);
+                    const mutationType = this.generateMutationType(endpoint);
+                    types.push(`export interface ${typeName} ${mutationType}`);
+                    types.push('');
+                }
+            }
+        }
+        return types.join('\n');
+    }
+    generateIndexFile() {
+        const exports = [];
+        exports.push(this.generateFileHeader('Generated React Hooks'));
+        exports.push('');
+        exports.push('// Query hooks');
+        exports.push("export * from './queries'");
+        exports.push('');
+        exports.push('// Mutation hooks');
+        exports.push("export * from './mutations'");
+        exports.push('');
+        exports.push('// Query keys');
+        exports.push("export { queryKeys } from './keys'");
+        exports.push('');
+        exports.push('// Hook types');
+        exports.push("export * from './types'");
+        return exports.join('\n');
+    }
+    generateFileHeader(title) {
+        return `/**
+ * ${title}
+ * 
+ * Auto-generated React hooks from OpenAPI specification
+ * Do not edit manually - regenerate using the hook generator
+ */`;
+    }
+    generateQueryHookName(endpoint) {
+        const operationName = this.getOperationName(endpoint);
+        return `use${this.capitalize(operationName)}`;
+    }
+    generateMutationHookName(endpoint) {
+        const operationName = this.getOperationName(endpoint);
+        // Check if this is a bulk operation
+        const resourceName = this.extractResourceName(endpoint.path);
+        if (resourceName) {
+            const bulkHookName = this.bulkHookGenerator.generateBulkMutationHookName(endpoint, resourceName);
+            if (bulkHookName) {
+                return bulkHookName;
+            }
+        }
+        return `use${this.capitalize(operationName)}`;
+    }
+    getOperationName(endpoint) {
+        // Check if we have a manual override in config
+        if (endpoint.operationId) {
+            const override = this.configManager.getOverride(endpoint.operationId);
+            if (override) {
+                return override;
+            }
+        }
+        // Generate the name using existing logic
+        let operationName;
+        if (endpoint.operationId) {
+            operationName = this.cleanOperationId(endpoint.operationId, endpoint);
+        }
+        else {
+            operationName = this.generateCleanName(endpoint);
+        }
+        // Apply deduplication if enabled
+        const patterns = this.configManager.getPatterns();
+        if (patterns.deduplicateSegments) {
+            operationName = this.removeDuplicateSegments(operationName);
+        }
+        // Score the generated name if confidence scoring is enabled
+        if (this.options.enableConfidenceScoring && endpoint.operationId) {
+            const hookName = endpoint.method === 'get'
+                ? `use${this.capitalize(operationName)}`
+                : `use${this.capitalize(this.getMethodPrefix(endpoint.method))}${this.capitalize(operationName)}`;
+            const scored = this.confidenceScorer.scoreHookName(hookName, endpoint.operationId, endpoint.path, endpoint.method);
+            // Debug logging
+            if (scored.confidence === 'low') {
+                console.log(`Low confidence hook: ${hookName} (score: ${scored.score})`);
+            }
+            this.scoredNames.push(scored);
+            // If we have a suggestion with higher confidence, use it
+            if (scored.confidence === 'low' && scored.suggestions.length > 0) {
+                const suggestion = scored.suggestions[0];
+                // Extract just the operation name from the suggestion
+                const prefix = `use${this.capitalize(this.getMethodPrefix(endpoint.method))}`;
+                if (suggestion.startsWith(prefix)) {
+                    operationName = this.camelCase(suggestion.substring(prefix.length));
+                }
+                else if (suggestion.startsWith('use')) {
+                    operationName = this.camelCase(suggestion.substring(3));
+                }
+            }
+        }
+        return operationName;
+    }
+    cleanOperationId(operationId, endpoint) {
+        // Parse the operation ID into components
+        const parsed = this.parseOperationId(operationId, endpoint);
+        // Generate name based on parsed components
+        return this.generateNameFromParsed(parsed, endpoint);
+    }
+    /**
+     * Parse operation ID into structured components
+     */
+    parseOperationId(operationId, endpoint) {
+        // Clean common patterns
+        const cleaned = operationId
+            .replace(/_api_v\d+_/g, '_') // Remove API version
+            .replace(/_(get|post|put|patch|delete)$/i, ''); // Remove HTTP suffix
+        // Split into parts
+        const parts = cleaned.split('_').filter(Boolean);
+        // Extract prefix (action) if exists
+        const prefix = this.extractPrefix(parts, { ...endpoint, operationId });
+        // Extract resources from path
+        const resources = this.extractResourcesFromPath(endpoint.path);
+        // Check if it's a custom action
+        const segments = endpoint.path.split('/');
+        const lastSegment = segments[segments.length - 1];
+        const isCustomAction = !lastSegment.startsWith('{') && segments[segments.length - 2]?.startsWith('{');
+        return {
+            action: prefix?.action || '',
+            resource: resources.primary || '',
+            subResource: resources.sub?.[0] || '',
+            method: endpoint.method,
+            isCustomAction,
+            customActionName: isCustomAction ? lastSegment.replace(/-/g, '_') : undefined,
+            originalId: operationId,
+            prefix: prefix?.fullPrefix || '',
+            resources
+        };
+    }
+    /**
+     * Extract meaningful prefix from operation ID parts
+     */
+    extractPrefix(parts, endpoint) {
+        if (parts.length === 0)
+            return null;
+        // For extracting the prefix, use the original operation ID
+        const originalId = endpoint.operationId || '';
+        // Check if first part is a known action
+        const knownActions = [
+            'login', 'logout', 'register', 'signup', 'signin',
+            'assign', 'reassign', 'create', 'update', 'delete',
+            'get', 'list', 'health', 'status', 'verify', 'validate'
+        ];
+        const firstPart = parts[0].toLowerCase();
+        if (knownActions.includes(firstPart)) {
+            // Special handling for compound names like "get_health_status" or "get_current_user_info"
+            if (firstPart === 'get' && originalId.startsWith('get_')) {
+                // Extract everything between get_ and _api_v
+                const match = originalId.match(/^get_(.+?)_api_v\d+/);
+                if (match) {
+                    const compoundName = match[1];
+                    if (compoundName === 'health_status' || compoundName === 'current_user_info') {
+                        return {
+                            action: firstPart,
+                            fullPrefix: `${firstPart}_${compoundName}`
+                        };
+                    }
+                }
+            }
+            // Look for compound actions like "assign_roles" or "reassign_budget"
+            if (parts.length > 1 && ['assign', 'reassign'].includes(firstPart)) {
+                // Special case for reassign_transaction_budget
+                if (firstPart === 'reassign' && parts[1] === 'transaction' && parts[2] === 'budget') {
+                    return {
+                        action: 'reassign',
+                        fullPrefix: 'reassign_budget'
+                    };
+                }
+                return {
+                    action: firstPart,
+                    fullPrefix: `${parts[0]}_${parts[1]}`
+                };
+            }
+            return {
+                action: firstPart,
+                fullPrefix: parts[0]
+            };
+        }
+        return null;
+    }
+    /**
+     * Extract resources from API path
+     */
+    extractResourcesFromPath(path) {
+        // Remove API version prefix
+        const cleanPath = path.replace(/^\/api\/v\d+\//, '/');
+        const segments = cleanPath.split('/').filter(Boolean);
+        const resources = [];
+        let lastHasParam = false;
+        for (let i = 0; i < segments.length; i++) {
+            if (!segments[i].startsWith('{')) {
+                resources.push(segments[i].replace(/-/g, '_'));
+            }
+            else if (i === segments.length - 1) {
+                lastHasParam = true;
+            }
+        }
+        return {
+            primary: resources[0] || '',
+            sub: resources.slice(1),
+            lastHasParam
+        };
+    }
+    /**
+     * Generate clean hook name from parsed components
+     */
+    generateNameFromParsed(parsed, endpoint) {
+        // Special cases first
+        if (parsed.prefix === 'login')
+            return 'login';
+        if (parsed.prefix === 'logout')
+            return 'logout';
+        // Handle compound GET operations (e.g., get_health_status, get_current_user_info)
+        if (parsed.prefix && parsed.prefix.startsWith('get_') && parsed.prefix.includes('_')) {
+            const withoutGet = parsed.prefix.substring(4); // Remove "get_"
+            // Return the compound name without "get_" prefix
+            if (withoutGet === 'health_status' || withoutGet === 'current_user_info') {
+                return withoutGet;
+            }
+        }
+        // Handle custom actions with meaningful prefixes
+        if (parsed.prefix && this.isMeaningfulPrefix(parsed.prefix, parsed.resources)) {
+            return this.formatWithPrefix(parsed);
+        }
+        // Standard REST conventions
+        return this.formatStandardOperation(parsed, endpoint);
+    }
+    /**
+     * Check if prefix adds meaningful context
+     */
+    isMeaningfulPrefix(prefix, resources) {
+        const action = prefix.split('_')[0];
+        // Not meaningful if it just repeats the resource
+        if (prefix === resources.primary)
+            return false;
+        if (prefix === `get_${resources.primary}`)
+            return false;
+        if (prefix === `list_${resources.primary}`)
+            return false;
+        // Meaningful if it's a custom action
+        return ['assign', 'reassign', 'verify', 'validate', 'sync', 'refresh'].includes(action);
+    }
+    /**
+     * Format name with meaningful prefix
+     */
+    formatWithPrefix(parsed) {
+        const { prefix, resources, originalId, isCustomAction, customActionName } = parsed;
+        const prefixParts = prefix.split('_');
+        const action = prefixParts[0];
+        const subject = prefixParts.slice(1).join('_');
+        // Special handling for custom actions
+        if (isCustomAction && customActionName) {
+            // For reassign_budget on transactions
+            if (action === 'reassign' && subject === 'budget') {
+                return `reassign_${this.singularize(resources.primary)}_budget`;
+            }
+        }
+        // Handle deduplication - don't repeat if subject matches sub-resource
+        if (subject && resources.sub.length > 0) {
+            const subResource = resources.sub[0];
+            // If subject matches the sub-resource, don't duplicate
+            if (subject === subResource || subject === this.pluralize(subResource)) {
+                return `${action}_${this.singularize(resources.primary)}_${subResource}`;
+            }
+        }
+        // Standard format: action_resource_subresource
+        if (resources.sub.length > 0 && !isCustomAction) {
+            return `${action}_${this.singularize(resources.primary)}_${resources.sub[0]}`;
+        }
+        return `${action}_${this.singularize(resources.primary)}`;
+    }
+    /**
+     * Format standard REST operation
+     */
+    formatStandardOperation(parsed, endpoint) {
+        const { resources, method } = parsed;
+        const hasParams = endpoint.path.includes('{');
+        const isListOperation = method === 'get' && !hasParams;
+        // Handle sub-resources
+        if (resources.sub.length > 0) {
+            const primary = this.singularize(resources.primary);
+            const sub = resources.sub[0];
+            switch (method) {
+                case 'get':
+                    return isListOperation ? `${primary}_${this.pluralize(sub)}` : `${primary}_${sub}`;
+                case 'post':
+                    return `create_${primary}_${this.singularize(sub)}`;
+                case 'put':
+                case 'patch':
+                    return `set_${primary}_${sub}`;
+                case 'delete':
+                    return `remove_${primary}_${sub}`;
+            }
+        }
+        // Handle primary resource only
+        switch (method) {
+            case 'get':
+                return isListOperation ? this.pluralize(resources.primary) : this.singularize(resources.primary);
+            case 'post':
+                return `create_${this.singularize(resources.primary)}`;
+            case 'put':
+            case 'patch':
+                return `update_${this.singularize(resources.primary)}`;
+            case 'delete':
+                return `delete_${this.singularize(resources.primary)}`;
+            default:
+                return this.singularize(resources.primary);
+        }
+    }
+    generateCleanName(endpoint) {
+        const pathParts = endpoint.path
+            .split('/')
+            .filter(part => part && !part.startsWith('{'));
+        if (pathParts.length === 0)
+            return endpoint.method;
+        // Get the main resource (usually the last non-parameter segment)
+        const resource = pathParts[pathParts.length - 1];
+        const cleanResource = resource.replace(/-/g, '_');
+        // Check if it's a custom action (last segment after a parameter)
+        const segments = endpoint.path.split('/');
+        const lastSegment = segments[segments.length - 1];
+        const hasCustomAction = !lastSegment.startsWith('{') && segments[segments.length - 2]?.startsWith('{');
+        if (hasCustomAction) {
+            // Custom action: use resource + action
+            const mainResource = pathParts[pathParts.length - 2] || pathParts[pathParts.length - 1];
+            const action = lastSegment.replace(/-/g, '_');
+            return `${mainResource}_${action}`;
+        }
+        // For nested resources (e.g., /categories/{id}/subcategories), 
+        // just use the last resource name
+        if (pathParts.length > 2 && segments.some(s => s.startsWith('{'))) {
+            // This is a nested resource, just use the last part
+            return cleanResource;
+        }
+        // Standard CRUD operations
+        switch (endpoint.method) {
+            case 'get':
+                // Check if it's a list or single resource
+                const isList = !endpoint.path.includes('{');
+                // Only pluralize if it's a list and not already plural
+                if (isList && !cleanResource.endsWith('s') && !cleanResource.endsWith('ies')) {
+                    return this.pluralize(cleanResource);
+                }
+                return cleanResource;
+            case 'post':
+                return `create_${cleanResource}`;
+            case 'put':
+            case 'patch':
+                return `update_${cleanResource}`;
+            case 'delete':
+                return `delete_${cleanResource}`;
+            default:
+                return `${endpoint.method}_${cleanResource}`;
+        }
+    }
+    pluralize(word) {
+        // Don't pluralize if already plural
+        if (word.endsWith('s') && !word.endsWith('ss') && !word.endsWith('us') && !word.endsWith('is')) {
+            return word;
+        }
+        // Simple pluralization rules
+        if (word.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].includes(word.slice(-2))) {
+            return word.slice(0, -1) + 'ies';
+        }
+        if (word.endsWith('ss') || word.endsWith('x') || word.endsWith('ch') || word.endsWith('sh')) {
+            return word + 'es';
+        }
+        if (word.endsWith('us')) {
+            return word.slice(0, -2) + 'i';
+        }
+        if (word.endsWith('is')) {
+            return word.slice(0, -2) + 'es';
+        }
+        return word + 's';
+    }
+    singularize(word) {
+        // Simple singularization rules
+        if (word.endsWith('ies')) {
+            return word.slice(0, -3) + 'y';
+        }
+        if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('ches') || word.endsWith('shes')) {
+            return word.slice(0, -2);
+        }
+        if (word.endsWith('s') && !word.endsWith('ss')) {
+            return word.slice(0, -1);
+        }
+        return word;
+    }
+    hasRequiredParams(endpoint) {
+        return endpoint.parameters.some(p => p.required) ||
+            endpoint.parameters.some(p => p.in === 'path');
+    }
+    generateParamType(endpoint) {
+        const pathParams = endpoint.parameters.filter(p => p.in === 'path');
+        const queryParams = endpoint.parameters.filter(p => p.in === 'query');
+        const properties = [];
+        pathParams.forEach(param => {
+            properties.push(`${param.name}: ${this.getParameterType(param)}`);
+        });
+        queryParams.forEach(param => {
+            const optional = param.required ? '' : '?';
+            properties.push(`${param.name}${optional}: ${this.getParameterType(param)}`);
+        });
+        return `{ ${properties.join('; ')} }`;
+    }
+    generateMutationType(endpoint) {
+        const hasPathParams = endpoint.parameters.some(p => p.in === 'path');
+        if (hasPathParams) {
+            const pathType = this.generateParamType(endpoint);
+            return `{ pathParams: ${pathType}; [key: string]: any }`;
+        }
+        return '{ [key: string]: any }';
+    }
+    getParameterType(param) {
+        switch (param.schema.type) {
+            case 'string': return 'string';
+            case 'number':
+            case 'integer': return 'number';
+            case 'boolean': return 'boolean';
+            default: return 'any';
+        }
+    }
+    isListEndpoint(endpoint) {
+        // Only GET requests can be list endpoints
+        if (endpoint.method.toLowerCase() !== 'get')
+            return false;
+        // If it has path parameters, it's likely fetching a single resource
+        if (endpoint.path.includes('{'))
+            return false;
+        // Check if the response is an array
+        if (endpoint.responses?.['200']?.schema?.type === 'array')
+            return true;
+        // Check if summary/description indicates it's a list
+        const description = `${endpoint.summary || ''} ${endpoint.description || ''}`.toLowerCase();
+        return description.includes('list') ||
+            description.includes('get all') ||
+            description.includes('fetch all');
+    }
+    groupEndpointsByResource(endpoints) {
+        const groups = {};
+        for (const endpoint of endpoints) {
+            const resource = endpoint.tags?.[0] || 'default';
+            if (!groups[resource]) {
+                groups[resource] = [];
+            }
+            groups[resource].push(endpoint);
+        }
+        return groups;
+    }
+    getRelatedQueryTags(endpoint) {
+        const resource = endpoint.tags?.[0] || 'default';
+        return [resource, 'all'];
+    }
+    camelCase(str) {
+        return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+            .replace(/^./, char => char.toLowerCase());
+    }
+    capitalize(str) {
+        // Convert snake_case to PascalCase
+        return str.split('_')
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+    }
+    getMethodPrefix(method) {
+        const prefixes = {
+            post: 'create',
+            put: 'update',
+            patch: 'update',
+            delete: 'delete'
+        };
+        return prefixes[method.toLowerCase()] || method.toLowerCase();
+    }
+    removeDuplicateSegments(operationName) {
+        const parts = operationName.split('_');
+        const seen = new Set();
+        const result = [];
+        for (const part of parts) {
+            const lower = part.toLowerCase();
+            if (!seen.has(lower)) {
+                seen.add(lower);
+                result.push(part);
+            }
+        }
+        return result.join('_');
+    }
+}
+exports.ReactHookGenerator = ReactHookGenerator;
+// Factory function
+async function generateHooks(parsedAPI, options) {
+    const generator = new ReactHookGenerator(options);
+    return generator.generate(parsedAPI);
+}