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

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

@@ -1,725 +0,0 @@
-/**
- * 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);
-}