@pattern-stack/frontend-patterns 0.1.0 → 0.1.1

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

@@ -1,1057 +0,0 @@
-"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);
-}