@pattern-stack/frontend-patterns 0.1.3 → 0.2.0-alpha.1

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * React Hook Generator
  *
@@ -7,17 +6,16 @@
  *
  * 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 {
+import { HookConfigManager } from './hook-config.js';
+import { ConfidenceScorer } from './confidence-scorer.js';
+import { singularize, pluralize, isPlural } from './naming-utils.js';
+import { AUTH_ACTIONS, HEALTH_ENDPOINTS, USER_PROFILE_ENDPOINTS, SINGLETON_RESOURCES, COLLECTION_ACTIONS, SPECIAL_ACTIONS } from './naming-constants.js';
+export class ReactHookGenerator {
+    options;
+    configManager;
+    confidenceScorer;
+    scoredNames = [];
     constructor(options = {}) {
-        this.scoredNames = [];
-        this.resourceConfigs = new Map();
         this.options = {
             queryKeyPrefix: options.queryKeyPrefix || 'api',
             includeInfiniteQueries: options.includeInfiniteQueries !== false,
@@ -28,115 +26,13 @@ class ReactHookGenerator {
             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: {}
-        };
+        this.configManager = new HookConfigManager(this.options.configPath);
+        this.confidenceScorer = new ConfidenceScorer();
     }
     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 = {
@@ -169,50 +65,15 @@ class ReactHookGenerator {
         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 { 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');
-        // 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 hookName = this.generateQueryHookName(endpoint);
             const hook = this.generateQueryHook(endpoint, hookName);
             hooks.push(hook);
             hooks.push('');
@@ -241,24 +102,21 @@ class ReactHookGenerator {
         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>';
+        const params = hasParams ? `params: ${paramType}, options?: QueryOptions` : 'options?: QueryOptions = {}';
         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}()`;
+            `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},`);
-        // 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
+        if (this.options.authenticationRequired) {
+            lines.push('    enabled: !!authToken && (options?.enabled ?? true),');
+        }
         lines.push('    ...options');
         lines.push('  })');
         lines.push('}');
@@ -272,18 +130,14 @@ class ReactHookGenerator {
         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(`export function ${hookName}(params: ${paramType}, options?: InfiniteQueryOptions) {`);
         lines.push('  return useInfiniteQuery({');
-        lines.push(`    queryKey: [...queryKeys.${queryKeyNameCamelCase}(), params],`);
+        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('    initialPageParam: 1,');
         lines.push('    ...options');
         lines.push('  })');
         lines.push('}');
@@ -293,33 +147,16 @@ class ReactHookGenerator {
         const hooks = [];
         hooks.push(this.generateFileHeader('Mutation Hooks'));
         hooks.push('');
-        hooks.push("import { useMutation, useQueryClient, type UseMutationOptions } from '@tanstack/react-query'");
+        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("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);
+            const hookName = this.generateMutationHookName(endpoint);
+            const hook = this.generateMutationHook(endpoint, hookName);
             hooks.push(hook);
             hooks.push('');
         }
@@ -339,7 +176,7 @@ class ReactHookGenerator {
         lines.push(' */');
         // Generate hook signature
         const mutationType = this.generateMutationType(endpoint);
-        lines.push(`export function ${hookName}(options?: UseMutationOptions<any, any, ${mutationType}>) {`);
+        lines.push(`export function ${hookName}(options?: MutationOptions<any, any, ${mutationType}>) {`);
         lines.push('  const queryClient = useQueryClient()');
         lines.push('');
         lines.push('  return useMutation({');
@@ -363,97 +200,56 @@ class ReactHookGenerator {
     }
     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) => {
+                return `    onMutate: async (newData) => {
       // Cancel outgoing refetches
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
+      await queryClient.cancelQueries({ queryKey: queryKeys.all })
+
       // Snapshot previous value
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
+      const previousData = queryClient.getQueryData(queryKeys.all)
+
       // Optimistically update cache
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return [...old, data]
-        }
-        return old
-      })
-      
+      queryClient.setQueryData(queryKeys.all, (old: any) => [...(old || []), newData])
+
       return { previousData }
     },
-    onError: (err: any, data: any, context: any) => {
+    onError: (err, newData, context) => {
       // Rollback on error
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
+      queryClient.setQueryData(queryKeys.all, 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}())
-      
+                return `    onMutate: async (updatedData) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.all })
+
+      const previousData = queryClient.getQueryData(queryKeys.all)
+
       // 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)
-      
+      queryClient.setQueryData(queryKeys.all, (old: any) =>
+        old?.map((item: any) => item.id === updatedData.id ? { ...item, ...updatedData } : item)
+      )
+
       return { previousData }
     },
-    onError: (err: any, data: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
+    onError: (err, updatedData, context) => {
+      queryClient.setQueryData(queryKeys.all, context?.previousData)
     },`;
             case 'delete':
-                return `    onMutate: async (data: any) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
+                return `    onMutate: async (id) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.all })
+
+      const previousData = queryClient.getQueryData(queryKeys.all)
+
       // 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
-      })
-      
+      queryClient.setQueryData(queryKeys.all, (old: any) =>
+        old?.filter((item: any) => item.id !== id)
+      )
+
       return { previousData }
     },
-    onError: (err: any, data: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
+    onError: (err, id, context) => {
+      queryClient.setQueryData(queryKeys.all, context?.previousData)
     },`;
             default:
                 return '';
@@ -463,7 +259,7 @@ class ReactHookGenerator {
         const relatedTags = this.getRelatedQueryTags(endpoint);
         return `    onSettled: () => {
       // Invalidate related queries
-      ${relatedTags.map(tag => `queryClient.invalidateQueries({ queryKey: queryKeys.${tag}() })`).join('\n      ')}
+      ${relatedTags.map(tag => `queryClient.invalidateQueries({ queryKey: queryKeys.${tag} })`).join('\n      ')}
     },`;
     }
     generateQueryKeys(endpoints) {
@@ -481,53 +277,36 @@ class ReactHookGenerator {
         // Group endpoints by resource/tag
         const groupedEndpoints = this.groupEndpointsByResource(endpoints);
         for (const [resource, resourceEndpoints] of Object.entries(groupedEndpoints)) {
+            // Sanitize resource name to be a valid JS identifier
+            const sanitizedResource = this.sanitizeIdentifier(resource);
+            console.log(`DEBUG: resource="${resource}" -> sanitizedResource="${sanitizedResource}"`);
             keys.push(`  // ${resource} keys`);
-            keys.push(`  ${resource}: () => [...queryKeys.all, '${resource}'] as const,`);
-            // Track generated key names to avoid duplicates
-            const generatedKeys = new Map();
+            keys.push(`  ${sanitizedResource}: () => [...queryKeys.all, '${sanitizedResource}'] as const,`);
+            const usedKeys = new Set([sanitizedResource]); // Track used keys to avoid duplicates
             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);
-                    }
+                // Skip if keyName matches sanitizedResource (base key already handles this)
+                if (keyName === sanitizedResource) {
+                    continue;
+                }
+                // If keyName already used, add suffix to disambiguate
+                if (usedKeys.has(keyName)) {
+                    const isList = !endpoint.path.includes('{');
+                    keyName = isList ? `${keyName}List` : `${keyName}Detail`;
                 }
-                generatedKeys.set(keyName, endpoint);
+                // Still duplicate after suffix? Skip to avoid compilation error
+                if (usedKeys.has(keyName)) {
+                    continue;
+                }
+                usedKeys.add(keyName);
                 if (this.hasRequiredParams(endpoint)) {
-                    keys.push(`  ${keyName}: (params: any) => [...queryKeys.${resource}(), '${keyName}', params] as const,`);
+                    keys.push(`  ${keyName}: (params: Record<string, unknown>) => [...queryKeys.${sanitizedResource}(), '${keyName}', params] as const,`);
                 }
                 else {
-                    keys.push(`  ${keyName}: () => [...queryKeys.${resource}(), '${keyName}'] as const,`);
+                    keys.push(`  ${keyName}: () => [...queryKeys.${sanitizedResource}(), '${keyName}'] as const,`);
                 }
             }
             keys.push('');
@@ -539,31 +318,20 @@ class ReactHookGenerator {
         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("import { QueryOptions, MutationOptions, InfiniteQueryOptions } from '@tanstack/react-query'");
         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('');
-                }
+                const paramType = this.generateParamType(endpoint);
+                types.push(`export interface ${this.capitalize(operationName)}Params ${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('');
-                }
+                const mutationType = this.generateMutationType(endpoint);
+                types.push(`export interface ${this.capitalize(operationName)}Data ${mutationType}`);
+                types.push('');
             }
         }
         return types.join('\n');
@@ -588,7 +356,7 @@ class ReactHookGenerator {
     generateFileHeader(title) {
         return `/**
  * ${title}
- * 
+ *
  * Auto-generated React hooks from OpenAPI specification
  * Do not edit manually - regenerate using the hook generator
  */`;
@@ -599,14 +367,6 @@ class ReactHookGenerator {
     }
     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) {
@@ -659,217 +419,168 @@ class ReactHookGenerator {
     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);
+        // 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) {
-        // 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);
+        // 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_action_method (e.g., ready_ready_get, health_health_get)
+            /^(?<action>\w+?)_\1_(?<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 segments = endpoint.path.split('/');
-        const lastSegment = segments[segments.length - 1];
-        const isCustomAction = !lastSegment.startsWith('{') && segments[segments.length - 2]?.startsWith('{');
+        const urlSegments = endpoint.path.split('/');
+        const lastSegment = urlSegments[urlSegments.length - 1];
+        const prevSegment = urlSegments[urlSegments.length - 2];
+        // Custom action: either after a path param (e.g., /accounts/{id}/archive)
+        // or a known action verb on a collection (e.g., /activities/search)
+        const isResourceAction = !lastSegment.startsWith('{') && prevSegment?.startsWith('{');
+        const isCollectionAction = !lastSegment.startsWith('{') && !prevSegment?.startsWith('{') && COLLECTION_ACTIONS.includes(lastSegment);
+        const isCustomAction = isResourceAction || isCollectionAction;
+        // 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: prefix?.action || '',
-            resource: resources.primary || '',
-            subResource: resources.sub?.[0] || '',
+            action: actionVerb,
+            resource: isCollectionAction ? prevSegment : resource,
+            path: components.path || '',
             method: endpoint.method,
             isCustomAction,
             customActionName: isCustomAction ? lastSegment.replace(/-/g, '_') : undefined,
-            originalId: operationId,
-            prefix: prefix?.fullPrefix || '',
-            resources
+            originalId: operationId
         };
     }
     /**
-     * Extract meaningful prefix from operation ID parts
+     * Extract the primary action verb from the operation ID
      */
-    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'
+    extractActionVerb(actionPart, method) {
+        // Common action verbs to recognize
+        const actionVerbs = [
+            ...AUTH_ACTIONS,
+            ...HEALTH_ENDPOINTS,
+            'list', 'get', 'create', 'update', 'delete',
+            ...COLLECTION_ACTIONS,
+            'approve', 'reject', 'archive', 'restore',
+            'sync', 'refresh', 'reset', '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]}`
-                };
+        // 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;
             }
-            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
+        // Default to HTTP method mapping
+        const methodMap = {
+            get: 'get',
+            post: 'create',
+            put: 'update',
+            patch: 'update',
+            delete: 'delete'
         };
+        return methodMap[method] || method;
     }
     /**
-     * Generate clean hook name from parsed components
+     * Extract resource name from the API path
      */
-    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);
+    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 prefix adds meaningful context
+     * Check if this is a special endpoint that should keep its action verb
      */
-    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);
+    isSpecialEndpoint(parsed) {
+        return SPECIAL_ACTIONS.includes(parsed.action);
     }
     /**
-     * Format name with meaningful prefix
+     * Format name for custom action endpoints
      */
-    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`;
+    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 `${singularize(resource)}_${customActionName}`;
         }
-        // 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}`;
-            }
+        return `${action}_${singularize(resource)}`;
+    }
+    /**
+     * Format name for special endpoints (login, health, etc.)
+     */
+    formatSpecialEndpointName(parsed) {
+        const { action, resource } = parsed;
+        // For simple singleton endpoints, just return the action
+        const simpleActions = [...AUTH_ACTIONS.filter(a => ['login', 'logout'].includes(a)), ...HEALTH_ENDPOINTS.filter(h => ['health', 'ready', 'status'].includes(h)), ...USER_PROFILE_ENDPOINTS];
+        if (simpleActions.includes(action)) {
+            return action;
         }
-        // Standard format: action_resource_subresource
-        if (resources.sub.length > 0 && !isCustomAction) {
-            return `${action}_${this.singularize(resources.primary)}_${resources.sub[0]}`;
+        // For other special endpoints, combine with resource if meaningful
+        if (resource && resource !== action) {
+            return `${action}_${resource}`;
         }
-        return `${action}_${this.singularize(resources.primary)}`;
+        return action;
     }
     /**
-     * Format standard REST operation
+     * Format name for standard CRUD operations
      */
-    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) {
+    formatStandardOperationName(parsed, endpoint) {
+        const { resource } = parsed;
+        // Determine if it's a list or single resource operation
+        const isList = endpoint.method === 'get' && !endpoint.path.includes('{') && !this.isSingletonEndpoint(resource, endpoint.path);
+        switch (endpoint.method) {
             case 'get':
-                return isListOperation ? this.pluralize(resources.primary) : this.singularize(resources.primary);
+                return isList ? pluralize(resource) : singularize(resource);
             case 'post':
-                return `create_${this.singularize(resources.primary)}`;
+                return `create_${singularize(resource)}`;
             case 'put':
             case 'patch':
-                return `update_${this.singularize(resources.primary)}`;
+                return `update_${singularize(resource)}`;
             case 'delete':
-                return `delete_${this.singularize(resources.primary)}`;
+                return `delete_${singularize(resource)}`;
             default:
-                return this.singularize(resources.primary);
+                return singularize(resource);
         }
     }
     generateCleanName(endpoint) {
@@ -880,7 +591,7 @@ class ReactHookGenerator {
             return endpoint.method;
         // Get the main resource (usually the last non-parameter segment)
         const resource = pathParts[pathParts.length - 1];
-        const cleanResource = resource.replace(/-/g, '_');
+        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];
@@ -891,7 +602,7 @@ class ReactHookGenerator {
             const action = lastSegment.replace(/-/g, '_');
             return `${mainResource}_${action}`;
         }
-        // For nested resources (e.g., /categories/{id}/subcategories), 
+        // 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
@@ -904,7 +615,7 @@ class ReactHookGenerator {
                 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 pluralize(cleanResource);
                 }
                 return cleanResource;
             case 'post':
@@ -918,38 +629,22 @@ class ReactHookGenerator {
                 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);
+    isSingletonEndpoint(resource, path) {
+        // Check if resource matches singleton pattern
+        const lowerResource = resource.toLowerCase().replace(/_/g, '');
+        if (SINGLETON_RESOURCES.some(s => lowerResource === s || lowerResource.endsWith(s))) {
+            return true;
         }
-        if (word.endsWith('s') && !word.endsWith('ss')) {
-            return word.slice(0, -1);
+
+        // Check path patterns for common singletons
+        const pathSegments = path.split('/').filter(s => s && !s.startsWith('{'));
+        const lastSegment = pathSegments[pathSegments.length - 1]?.toLowerCase();
+
+        if (SINGLETON_RESOURCES.includes(lastSegment)) {
+            return true;
         }
-        return word;
+
+        return false;
     }
     hasRequiredParams(endpoint) {
         return endpoint.parameters.some(p => p.required) ||
@@ -986,25 +681,26 @@ class ReactHookGenerator {
         }
     }
     isListEndpoint(endpoint) {
-        // Only GET requests can be list endpoints
-        if (endpoint.method.toLowerCase() !== 'get')
+        // Extract resource for singleton check
+        const pathSegments = endpoint.path.split('/').filter(s => s && !s.startsWith('{'));
+        const resource = pathSegments[pathSegments.length - 1]?.replace(/-/g, '_') || '';
+
+        // Singleton endpoints are never list endpoints
+        if (this.isSingletonEndpoint(resource, endpoint.path)) {
             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');
+        }
+
+        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';
+            const tag = endpoint.tags?.[0] || 'default';
+            // Sanitize tag to be a valid JS identifier (camelCase, no spaces)
+            const resource = this.sanitizeIdentifier(tag);
             if (!groups[resource]) {
                 groups[resource] = [];
             }
@@ -1012,8 +708,17 @@ class ReactHookGenerator {
         }
         return groups;
     }
+    sanitizeIdentifier(str) {
+        // Convert to camelCase and remove invalid characters
+        return str
+            .replace(/[^a-zA-Z0-9\s]/g, '') // Remove special chars except spaces
+            .split(/\s+/) // Split on whitespace
+            .map((word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
     getRelatedQueryTags(endpoint) {
-        const resource = endpoint.tags?.[0] || 'default';
+        const tag = endpoint.tags?.[0] || 'default';
+        const resource = this.sanitizeIdentifier(tag);
         return [resource, 'all'];
     }
     camelCase(str) {
@@ -1041,7 +746,9 @@ class ReactHookGenerator {
         const result = [];
         for (const part of parts) {
             const lower = part.toLowerCase();
-            if (!seen.has(lower)) {
+            // 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);
             }
@@ -1049,9 +756,8 @@ class ReactHookGenerator {
         return result.join('_');
     }
 }
-exports.ReactHookGenerator = ReactHookGenerator;
 // Factory function
-async function generateHooks(parsedAPI, options) {
+export async function generateHooks(parsedAPI, options) {
     const generator = new ReactHookGenerator(options);
     return generator.generate(parsedAPI);
 }