@pattern-stack/frontend-patterns 0.1.2 → 0.2.0-alpha.0

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

@@ -0,0 +1,725 @@
+/**
+ * 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
+ */
+import { HookConfigManager } from './hook-config';
+import { ConfidenceScorer } from './confidence-scorer';
+export class ReactHookGenerator {
+    options;
+    configManager;
+    confidenceScorer;
+    scoredNames = [];
+    constructor(options = {}) {
+        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 HookConfigManager(this.options.configPath);
+        this.confidenceScorer = new ConfidenceScorer();
+    }
+    async generate(parsedAPI) {
+        const endpoints = parsedAPI.endpoints;
+        // Load configuration
+        await this.configManager.load();
+        // 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, QueryOptions, InfiniteQueryOptions } 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');
+        for (const endpoint of queryEndpoints) {
+            const hookName = this.generateQueryHookName(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?: QueryOptions` : 'options?: QueryOptions = {}';
+        lines.push(`export function ${hookName}(${params}) {`);
+        // Generate hook body
+        const queryKeyCall = hasParams ?
+            `queryKeys.${this.camelCase(operationName)}(params)` :
+            `queryKeys.${this.camelCase(operationName)}()`;
+        const apiCall = hasParams ?
+            `() => apiClient.${this.camelCase(operationName)}(params)` :
+            `() => apiClient.${this.camelCase(operationName)}()`;
+        lines.push('  return useQuery({');
+        lines.push(`    queryKey: ${queryKeyCall},`);
+        lines.push(`    queryFn: ${apiCall},`);
+        if (this.options.authenticationRequired) {
+            lines.push('    enabled: !!authToken && (options?.enabled ?? true),');
+        }
+        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);
+        lines.push(`export function ${hookName}(params: ${paramType}, options?: InfiniteQueryOptions) {`);
+        lines.push('  return useInfiniteQuery({');
+        lines.push(`    queryKey: queryKeys.${this.camelCase(operationName)}(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('    ...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, MutationOptions } 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 non-GET endpoints for mutations
+        const mutationEndpoints = endpoints.filter(endpoint => endpoint.method !== 'get');
+        for (const endpoint of mutationEndpoints) {
+            const hookName = this.generateMutationHookName(endpoint);
+            const hook = 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?: MutationOptions<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();
+        switch (method) {
+            case 'post':
+                return `    onMutate: async (newData) => {
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({ queryKey: queryKeys.all })
+      
+      // Snapshot previous value
+      const previousData = queryClient.getQueryData(queryKeys.all)
+      
+      // Optimistically update cache
+      queryClient.setQueryData(queryKeys.all, (old: any) => [...(old || []), newData])
+      
+      return { previousData }
+    },
+    onError: (err, newData, context) => {
+      // Rollback on error
+      queryClient.setQueryData(queryKeys.all, context?.previousData)
+    },`;
+            case 'put':
+            case 'patch':
+                return `    onMutate: async (updatedData) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.all })
+      
+      const previousData = queryClient.getQueryData(queryKeys.all)
+      
+      // Update specific item in cache
+      queryClient.setQueryData(queryKeys.all, (old: any) => 
+        old?.map((item: any) => item.id === updatedData.id ? { ...item, ...updatedData } : item)
+      )
+      
+      return { previousData }
+    },
+    onError: (err, updatedData, context) => {
+      queryClient.setQueryData(queryKeys.all, context?.previousData)
+    },`;
+            case 'delete':
+                return `    onMutate: async (id) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.all })
+      
+      const previousData = queryClient.getQueryData(queryKeys.all)
+      
+      // Remove item from cache
+      queryClient.setQueryData(queryKeys.all, (old: any) => 
+        old?.filter((item: any) => item.id !== id)
+      )
+      
+      return { previousData }
+    },
+    onError: (err, id, context) => {
+      queryClient.setQueryData(queryKeys.all, 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,`);
+            for (const endpoint of resourceEndpoints) {
+                if (endpoint.method !== 'get')
+                    continue;
+                const operationName = this.getOperationName(endpoint);
+                const keyName = this.camelCase(operationName.replace(/^get/, ''));
+                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("import { QueryOptions, MutationOptions, InfiniteQueryOptions } from '@tanstack/react-query'");
+        types.push('');
+        // Generate parameter and response types for hooks
+        for (const endpoint of endpoints) {
+            const operationName = this.getOperationName(endpoint);
+            if (this.hasRequiredParams(endpoint)) {
+                const paramType = this.generateParamType(endpoint);
+                types.push(`export interface ${this.capitalize(operationName)}Params ${paramType}`);
+                types.push('');
+            }
+            if (endpoint.method !== 'get') {
+                const mutationType = this.generateMutationType(endpoint);
+                types.push(`export interface ${this.capitalize(operationName)}Data ${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);
+        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);
+        // Check if it's a custom action endpoint
+        if (parsed.isCustomAction) {
+            return this.formatCustomActionName(parsed);
+        }
+        // Check if it's a special endpoint that should keep its verb
+        if (this.isSpecialEndpoint(parsed)) {
+            return this.formatSpecialEndpointName(parsed);
+        }
+        // Format standard CRUD operation
+        return this.formatStandardOperationName(parsed, endpoint);
+    }
+    /**
+     * Parse operation ID into structured components
+     */
+    parseOperationId(operationId, endpoint) {
+        // Common patterns for operation IDs
+        const patterns = [
+            // Pattern: action_resource_api_v1_path_segments_method
+            /^(?<action>\w+?)_(?<resource>\w+?)_api_v\d+_(?<path>.+?)_(?<method>get|post|put|patch|delete)$/i,
+            // Pattern: action_api_v1_path_segments_method
+            /^(?<action>\w+?)_api_v\d+_(?<path>.+?)_(?<method>get|post|put|patch|delete)$/i,
+            // Pattern: action_resource_path_method
+            /^(?<action>\w+?)_(?<resource>\w+?)_(?<path>.+?)_(?<method>get|post|put|patch|delete)$/i,
+            // Pattern: simple action_resource
+            /^(?<action>\w+?)_(?<resource>\w+?)$/i,
+        ];
+        let components = {};
+        for (const pattern of patterns) {
+            const match = operationId.match(pattern);
+            if (match && match.groups) {
+                components = match.groups;
+                break;
+            }
+        }
+        // Extract path information
+        const pathSegments = endpoint.path.split('/').filter(s => s && !s.startsWith('{'));
+        const lastPathSegment = pathSegments[pathSegments.length - 1]?.replace(/-/g, '_');
+        // Check if it's a custom action
+        const urlSegments = endpoint.path.split('/');
+        const lastSegment = urlSegments[urlSegments.length - 1];
+        const isCustomAction = !lastSegment.startsWith('{') && urlSegments[urlSegments.length - 2]?.startsWith('{');
+        // Extract or infer the action verb
+        const actionVerb = this.extractActionVerb(components.action || operationId, endpoint.method);
+        // Extract or infer the resource
+        const resource = components.resource ||
+            this.extractResourceFromPath(endpoint.path) ||
+            lastPathSegment ||
+            'resource';
+        return {
+            action: actionVerb,
+            resource: resource,
+            path: components.path || '',
+            method: endpoint.method,
+            isCustomAction,
+            customActionName: isCustomAction ? lastSegment.replace(/-/g, '_') : undefined,
+            originalId: operationId
+        };
+    }
+    /**
+     * Extract the primary action verb from the operation ID
+     */
+    extractActionVerb(actionPart, method) {
+        // Common action verbs to recognize
+        const actionVerbs = [
+            'login', 'logout', 'register', 'signup', 'signin',
+            'health', 'status', 'check',
+            'list', 'get', 'create', 'update', 'delete',
+            'reassign', 'assign', 'settle', 'reconcile',
+            'approve', 'reject', 'archive', 'restore',
+            'sync', 'refresh', 'reset', 'verify', 'validate'
+        ];
+        // Check if the action part starts with any known verb
+        const lowerAction = actionPart.toLowerCase();
+        for (const verb of actionVerbs) {
+            if (lowerAction.startsWith(verb)) {
+                return verb;
+            }
+        }
+        // Default to HTTP method mapping
+        const methodMap = {
+            get: 'get',
+            post: 'create',
+            put: 'update',
+            patch: 'update',
+            delete: 'delete'
+        };
+        return methodMap[method] || method;
+    }
+    /**
+     * Extract resource name from the API path
+     */
+    extractResourceFromPath(path) {
+        const segments = path.split('/').filter(s => s && !s.startsWith('{'));
+        // Skip common prefixes
+        const filtered = segments.filter(s => !['api', 'v1', 'v2'].includes(s));
+        // Return the last meaningful segment
+        return filtered[filtered.length - 1]?.replace(/-/g, '_') || null;
+    }
+    /**
+     * Check if this is a special endpoint that should keep its action verb
+     */
+    isSpecialEndpoint(parsed) {
+        const specialActions = [
+            'login', 'logout', 'register', 'signup', 'signin',
+            'health', 'status', 'check', 'verify', 'validate'
+        ];
+        return specialActions.includes(parsed.action);
+    }
+    /**
+     * Format name for custom action endpoints
+     */
+    formatCustomActionName(parsed) {
+        const { action, resource, customActionName } = parsed;
+        // For custom actions like "reassign-budget", format as "reassign_budget"
+        if (customActionName) {
+            // Check if the action is already part of the custom action name
+            if (customActionName.startsWith(action)) {
+                return customActionName;
+            }
+            // Otherwise combine resource and action
+            return `${this.singularize(resource)}_${customActionName}`;
+        }
+        return `${action}_${this.singularize(resource)}`;
+    }
+    /**
+     * Format name for special endpoints (login, health, etc.)
+     */
+    formatSpecialEndpointName(parsed) {
+        const { action, resource } = parsed;
+        // For endpoints like "login", "health", just return the action
+        if (['login', 'logout', 'health', 'status'].includes(action)) {
+            return action;
+        }
+        // For other special endpoints, combine with resource if meaningful
+        if (resource && resource !== action) {
+            return `${action}_${resource}`;
+        }
+        return action;
+    }
+    /**
+     * Format name for standard CRUD operations
+     */
+    formatStandardOperationName(parsed, endpoint) {
+        const { resource } = parsed;
+        // Determine if it's a list or single resource operation
+        const isList = endpoint.method === 'get' && !endpoint.path.includes('{');
+        switch (endpoint.method) {
+            case 'get':
+                return isList ? this.pluralize(resource) : this.singularize(resource);
+            case 'post':
+                return `create_${this.singularize(resource)}`;
+            case 'put':
+            case 'patch':
+                return `update_${this.singularize(resource)}`;
+            case 'delete':
+                return `delete_${this.singularize(resource)}`;
+            default:
+                return this.singularize(resource);
+        }
+    }
+    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];
+        let 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) {
+        // 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('s') || word.endsWith('x') || word.endsWith('ch') || word.endsWith('sh')) {
+            return word + '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) {
+        return endpoint.path.includes('list') ||
+            !endpoint.path.includes('{') ||
+            (endpoint.summary?.toLowerCase().includes('list') ?? false) ||
+            (endpoint.summary?.toLowerCase().includes('get all') ?? false);
+    }
+    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();
+            // Keep important words even if duplicated (like verbs)
+            const importantWords = ['create', 'update', 'delete', 'get', 'list', 'reassign', 'assign'];
+            if (!seen.has(lower) || importantWords.includes(lower)) {
+                seen.add(lower);
+                result.push(part);
+            }
+        }
+        return result.join('_');
+    }
+}
+// Factory function
+export async function generateHooks(parsedAPI, options) {
+    const generator = new ReactHookGenerator(options);
+    return generator.generate(parsedAPI);
+}