mulink 1.0.4 → 1.0.5

package/dist/lib/{chunk-KCNMWAI2.js → chunk-7Y66DW7M.js}

@@ -1544,7 +1544,6 @@ export class BaseApiClient {
         retryDelay, retryCondition, validateResponse, skipAuth, 
         responseSchema, requestId, [...this.middleware, ...middleware],
         cacheTags, revalidate, connection, updateTag
-        cacheTags, revalidate, connection, updateTag
       )
       
       requestCache.set(dedupeKey, requestPromise)
@@ -1562,7 +1561,6 @@ export class BaseApiClient {
       retryDelay, retryCondition, validateResponse, skipAuth,
       responseSchema, requestId, [...this.middleware, ...middleware],
       cacheTags, revalidate, connection, updateTag
-      cacheTags, revalidate, connection, updateTag
     )
   }
 
@@ -2718,7 +2716,9 @@ var SchemaGenerator = class {
     ].join("\n");
     let content = this.removeUnusedCode(contentWithImports);
     if (!content.includes('import { z } from "zod"') && !content.includes("import { z } from 'zod'")) {
-      content = 'import { z } from "zod"\n\n' + content;
+      content = `import { z } from "zod"
+
+${content}`;
     }
     return {
       path: "schemas/index.ts",
@@ -3129,6 +3129,166 @@ var ActionGenerator = class {
   static {
     __name(this, "ActionGenerator");
   }
+  get loggingEnabled() {
+    return this.configuration.dev?.logging !== false;
+  }
+  get validationEnabled() {
+    return this.configuration.dev?.validation !== false;
+  }
+  get commentsEnabled() {
+    return this.configuration.generation?.comments !== false;
+  }
+  get documentationEnabled() {
+    return this.configuration.generation?.documentation !== false;
+  }
+  commentLine(text, indent = 2) {
+    if (!this.commentsEnabled) {
+      return "";
+    }
+    return `${" ".repeat(indent)}// ${text}
+`;
+  }
+  buildDocBlock(endpoint, featuresDescription) {
+    if (!this.documentationEnabled) {
+      return "";
+    }
+    const summary = endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`;
+    return `/**
+ * ${summary}
+ * @generated from ${endpoint.method} ${endpoint.path}
+ * Features: ${featuresDescription}
+ */
+`;
+  }
+  buildUtilityFunctions() {
+    const parts = [];
+    if (this.commentsEnabled) {
+      parts.push("// Utility functions for enhanced server actions");
+    }
+    parts.push(`async function getClientInfo() {
+  const headersList = await headers()
+  const userAgent = headersList.get('user-agent') || 'unknown'
+  const ip = headersList.get('x-forwarded-for') || headersList.get('x-real-ip') || 'unknown'
+  
+  return { userAgent, ip }
+}`);
+    if (this.validationEnabled) {
+      parts.push(`async function validateAndSanitizeInput<T>(schema: z.ZodSchema<T>, input: unknown): Promise<T> {
+  try {
+    return await schema.parseAsync(input)
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.issues.map(issue => {
+        const path = issue.path.length > 0 ? \`\${issue.path.join('.')}: \` : ''
+        return \`\${path}\${issue.message}\`
+      }).join(', ')
+      throw new ActionError(\`Input validation failed: \${errorMessages}\`, 'VALIDATION_ERROR')
+    }
+    throw new ActionError('Invalid input format', 'VALIDATION_ERROR')
+  }
+}`);
+    }
+    const actionErrorBlock = `${this.commentsEnabled ? "// Enhanced error handling with context\n" : ""}class ActionExecutionError extends ActionError {
+  constructor(
+    message: string,
+    public readonly context: {
+      endpoint: string
+      method: string
+      timestamp: number
+    },
+    public readonly originalError?: unknown
+  ) {
+    super(message, 'EXECUTION_ERROR')
+  }
+}`;
+    parts.push(actionErrorBlock);
+    if (this.loggingEnabled) {
+      const loggingHeader = this.commentsEnabled ? "// Logging utility for server actions\n" : "";
+      parts.push(`${loggingHeader}async function logActionExecution(
+  action: string,
+  success: boolean,
+  duration: number,
+  context?: Record<string, any>
+) {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(\`[ACTION] \${action} - \${success ? 'SUCCESS' : 'FAILED'} (\${duration}ms)\`, context)
+  }
+  
+${this.commentsEnabled ? "  // In production, send to your logging service\n  // await analytics.track('server_action_executed', { action, success, duration, ...context })" : ""}
+}`);
+    }
+    return parts.join("\n\n");
+  }
+  buildCombinedValidationSnippet(operationName, schemaName) {
+    if (this.validationEnabled) {
+      return `
+${this.commentLine("Validate and sanitize input payload", 6)}      const { body, params } = await validateAndSanitizeInput(${schemaName}, parsedInput)
+      const validatedBody = body
+      const validatedParams = params as z.infer<typeof ${operationName}ParamsSchema>`;
+    }
+    return `
+${this.commentLine("Runtime validation disabled - trusting provided payload", 6)}      const { body, params } = parsedInput as {
+        body: z.infer<typeof ${operationName}RequestSchema>
+        params: z.infer<typeof ${operationName}ParamsSchema>
+      }
+      const validatedBody = body
+      const validatedParams = params`;
+  }
+  buildBodyValidationSnippet(schemaName) {
+    if (schemaName === "z.void()") {
+      return "";
+    }
+    if (this.validationEnabled) {
+      return `
+${this.commentLine("Validate and sanitize request body", 6)}      const validatedBody = await validateAndSanitizeInput(${schemaName}, parsedInput)`;
+    }
+    return `
+${this.commentLine("Runtime validation disabled - trusting request body", 6)}      const validatedBody = parsedInput as z.infer<typeof ${schemaName}>`;
+  }
+  buildParamsValidationSnippet(operationName, schemaName) {
+    if (schemaName === "z.void()") {
+      return "";
+    }
+    if (this.validationEnabled) {
+      return `
+${this.commentLine("Validate and sanitize parameters", 6)}      const validatedParams = await validateAndSanitizeInput(${schemaName}, parsedInput) as z.infer<typeof ${operationName}ParamsSchema>`;
+    }
+    return `
+${this.commentLine("Runtime validation disabled - trusting parameters", 6)}      const validatedParams = parsedInput as z.infer<typeof ${operationName}ParamsSchema>`;
+  }
+  buildSuccessLoggingBlock(actionName, endpoint, indent, isStreaming = false) {
+    if (!this.loggingEnabled) {
+      return "";
+    }
+    if (isStreaming) {
+      return `
+${this.commentLine("Background tasks (Next.js 15 feature)", indent)}${" ".repeat(indent)}after(async () => {
+${this.commentLine("Perform background tasks after response is sent", indent + 2)}${" ".repeat(indent + 2)}await logActionExecution('${actionName}', true, Date.now() - startTime, {
+${" ".repeat(indent + 4)}method: '${endpoint.method}',
+${" ".repeat(indent + 4)}path: '${endpoint.path}'
+${" ".repeat(indent + 2)}})
+${" ".repeat(indent)}})`;
+    }
+    return `
+${this.commentLine("Log successful execution", indent)}${" ".repeat(indent)}const duration = Date.now() - startTime
+${" ".repeat(indent)}await logActionExecution('${actionName}', true, duration, {
+${" ".repeat(indent + 2)}method: '${endpoint.method}',
+${" ".repeat(indent + 2)}path: '${endpoint.path}'
+${" ".repeat(indent)}})`;
+  }
+  buildErrorLoggingBlock(actionName, endpoint, indent) {
+    if (!this.loggingEnabled) {
+      return "";
+    }
+    return `
+${" ".repeat(indent)}const duration = Date.now() - startTime
+
+${this.commentLine("Enhanced error logging", indent)}${" ".repeat(indent)}await logActionExecution('${actionName}', false, duration, {
+${" ".repeat(indent + 2)}method: '${endpoint.method}',
+${" ".repeat(indent + 2)}path: '${endpoint.path}',
+${" ".repeat(indent + 2)}error: error instanceof Error ? error.message : 'Unknown error'
+${" ".repeat(indent)}})`;
+  }
   buildImportPath(relativePath) {
     const outputDirectory = this.configuration.outputDir || "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
@@ -3193,8 +3353,7 @@ var ActionGenerator = class {
         ] : []
       ].filter(Boolean).join("\n");
       const rateLimitSetup = hasRateLimit ? `
-// Rate limiting setup
-const redis = new Redis({
+${this.commentsEnabled ? "// Rate limiting setup\n" : ""}const redis = new Redis({
   url: process.env.UPSTASH_REDIS_REST_URL!,
   token: process.env.UPSTASH_REDIS_REST_TOKEN!,
 })
@@ -3204,60 +3363,7 @@ const ratelimit = new Ratelimit({
   limiter: Ratelimit.slidingWindow(10, '1 m'),
   analytics: true,
 })` : "";
-      const utilityFunctions = `
-// Utility functions for enhanced server actions
-async function getClientInfo() {
-  const headersList = await headers()
-  const userAgent = headersList.get('user-agent') || 'unknown'
-  const ip = headersList.get('x-forwarded-for') || headersList.get('x-real-ip') || 'unknown'
-  
-  return { userAgent, ip }
-}
-
-async function validateAndSanitizeInput<T>(schema: z.ZodSchema<T>, input: unknown): Promise<T> {
-  try {
-    return await schema.parseAsync(input)
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const errorMessages = error.issues.map(issue => {
-        const path = issue.path.length > 0 ? \`\${issue.path.join('.')}: \` : ''
-        return \`\${path}\${issue.message}\`
-      }).join(', ')
-      throw new ActionError(\`Input validation failed: \${errorMessages}\`, 'VALIDATION_ERROR')
-    }
-    throw new ActionError('Invalid input format', 'VALIDATION_ERROR')
-  }
-}
-
-// Enhanced error handling with context
-class ActionExecutionError extends ActionError {
-  constructor(
-    message: string,
-    public readonly context: {
-      endpoint: string
-      method: string
-      timestamp: number
-    },
-    public readonly originalError?: unknown
-  ) {
-    super(message, 'EXECUTION_ERROR')
-  }
-}
-
-// Logging utility for server actions
-async function logActionExecution(
-  action: string,
-  success: boolean,
-  duration: number,
-  context?: Record<string, any>
-) {
-  if (process.env.NODE_ENV === 'development') {
-    console.log(\`[ACTION] \${action} - \${success ? 'SUCCESS' : 'FAILED'} (\${duration}ms)\`, context)
-  }
-  
-  // In production, send to your logging service
-  // await analytics.track('server_action_executed', { action, success, duration, ...context })
-}`;
+      const utilityFunctions = this.buildUtilityFunctions();
       const content = `${imports}
 ${rateLimitSetup}
 ${utilityFunctions}
@@ -3274,8 +3380,8 @@ ${actions}`;
         }
       });
     }
-    const indexContent = `// Auto-generated actions index
-${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier(tag)}'`).join("\n")}`;
+    const indexHeader = this.commentsEnabled ? "// Auto-generated actions index\n" : "";
+    const indexContent = `${indexHeader}${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier(tag)}'`).join("\n")}`;
     generatedFiles.push({
       path: "actions/index.ts",
       content: indexContent,
@@ -3324,54 +3430,48 @@ ${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier
         body: ${operationName}RequestSchema,
         params: ${operationName}ParamsSchema
       })`;
-      parameterProcessing = `
-    // Validate and sanitize input
-    const { body, params } = await validateAndSanitizeInput(${schemaName}, parsedInput)
-    const validatedBody = body
-    const validatedParams = params as z.infer<typeof ${operationName}ParamsSchema>`;
+      parameterProcessing = this.buildCombinedValidationSnippet(operationName, schemaName);
       requestOptionsParams = this.buildRequestOptions(pathParameters, queryParameters, true, true);
     } else if (hasRequestBody) {
       schemaName = `${operationName}RequestSchema`;
-      parameterProcessing = `
-    // Validate and sanitize request body
-    const validatedBody = await validateAndSanitizeInput(${schemaName}, parsedInput)`;
+      parameterProcessing = this.buildBodyValidationSnippet(schemaName);
       requestOptionsParams = `body: validatedBody`;
     } else if (hasAnyParams) {
       schemaName = `${operationName}ParamsSchema`;
-      parameterProcessing = `
-    // Validate and sanitize parameters
-    const validatedParams = await validateAndSanitizeInput(${schemaName}, parsedInput) as z.infer<typeof ${operationName}ParamsSchema>`;
+      parameterProcessing = this.buildParamsValidationSnippet(operationName, schemaName);
       requestOptionsParams = this.buildRequestOptions(pathParameters, queryParameters, false, true);
     } else {
       schemaName = "z.void()";
       parameterProcessing = "";
       requestOptionsParams = "";
     }
+    const parsedInputType = hasRequestBody || hasAnyParams ? `z.infer<typeof ${schemaName}>` : "void";
+    const ctxType = requiresAuth || hasRateLimit ? "{ user?: any; ratelimit?: { remaining: number } }" : "any";
+    const ctxDeclaration = requiresAuth || hasRateLimit ? `ctx: ${ctxType}` : "ctx?: any";
+    const actionArgsType = `{ parsedInput: ${parsedInputType}; ${ctxDeclaration} }`;
     const clientName = requiresAuth || hasRateLimit ? "authActionClient" : "actionClientWithMeta";
     const rateLimitCode = hasRateLimit ? `
-    // Rate limiting
-    const { userAgent, ip } = await getClientInfo()
-    const identifier = \`\${ip}-\${userAgent}\`
-    const { success, limit, reset, remaining } = await ratelimit.limit(identifier)
-    
-    if (!success) {
-      throw new ActionError(
-        \`Rate limit exceeded. Try again in \${Math.round((reset - Date.now()) / 1000)} seconds.\`,
-        'RATE_LIMIT_EXCEEDED'
-      )
-    }` : "";
+${this.commentLine("Rate limiting", 6)}      const { userAgent, ip } = await getClientInfo()
+      const identifier = \`\${ip}-\${userAgent}\`
+      const { success, limit, reset, remaining } = await ratelimit.limit(identifier)
+      
+      if (!success) {
+        throw new ActionError(
+          \`Rate limit exceeded. Try again in \${Math.round((reset - Date.now()) / 1000)} seconds.\`,
+          'RATE_LIMIT_EXCEEDED'
+        )
+      }` : "";
     const revalidationCode = revalidationTags.length > 0 ? revalidationTags.map(
-      (tag) => `      updateTag('${tag}')
-      console.log('Updated tag: ${tag}')`
+      (tag) => `      updateTag('${tag}')${this.loggingEnabled ? `
+      console.log('Updated tag: ${tag}')` : ""}`
     ).join("\n") : "";
     const kebabActionName = actionName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
     if (isQuery) {
-      return `/**
- * ${endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`}
- * @generated from ${endpoint.method} ${endpoint.path}
- * Features: React cache, input validation, error handling
- */
-export const ${actionName} = cache(
+      const docBlock = this.buildDocBlock(
+        endpoint,
+        "React cache, input validation, error handling"
+      );
+      return `${docBlock}export const ${actionName} = cache(
   ${clientName}
     .metadata({
       name: "${kebabActionName}",
@@ -3379,7 +3479,7 @@ export const ${actionName} = cache(
       rateLimit: { requests: ${endpoint.metadata.rateLimit?.requests || 10}, window: "${endpoint.metadata.rateLimit?.window || "1m"}" }` : ""}
     })
     .schema(${schemaName})
-    .action(async ({ parsedInput, ctx }: { parsedInput: ${hasRequestBody || hasAnyParams ? `z.infer<typeof ${schemaName}>` : "void"}, ctx${requiresAuth || hasRateLimit ? ": { user?: any, ratelimit?: { remaining: number } }" : "?: any"}) => {
+    .action(async ({ parsedInput, ctx }: ${actionArgsType}) => {
       const startTime = Date.now()
       
       try {${rateLimitCode}${parameterProcessing}
@@ -3394,23 +3494,11 @@ export const ${actionName} = cache(
           }
         })
         
-        // Log successful execution
-        const duration = Date.now() - startTime
-        await logActionExecution('${actionName}', true, duration, {
-          method: '${endpoint.method}',
-          path: '${endpoint.path}'
-        })
+${this.buildSuccessLoggingBlock(actionName, endpoint, 8)}
         
         return response.data
       } catch (error) {
-        const duration = Date.now() - startTime
-        
-        // Enhanced error logging
-        await logActionExecution('${actionName}', false, duration, {
-          method: '${endpoint.method}',
-          path: '${endpoint.path}',
-          error: error instanceof Error ? error.message : 'Unknown error'
-        })
+${this.buildErrorLoggingBlock(actionName, endpoint, 8)}
         
         // Throw enhanced error with context
         throw new ActionExecutionError(
@@ -3427,50 +3515,37 @@ export const ${actionName} = cache(
 )`;
     }
     const redirectCode = `
-        // Handle potential redirects based on response
-        if (response.status === 201 && response.headers.get('location')) {
+${this.commentLine("Handle potential redirects based on response", 8)}        if (response.status === 201 && response.headers.get('location')) {
           const location = response.headers.get('location')!
           redirect(location)
         }`;
     const streamingCode = `
-        // Handle streaming responses
-        if (response.headers.get('content-type')?.includes('text/stream')) {
-          // Process streaming response
-          return response.data
+${this.commentLine("Handle streaming responses", 8)}        if (response.headers.get('content-type')?.includes('text/stream')) {
+${this.commentLine("Process streaming response", 10)}          return response.data
         }`;
     const fileUploadCode = hasFileUpload ? uploadStrategy === "external" && uploadProvider === "vercel-blob" ? `
-        // Handle file uploads with Vercel Blob
-        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
+${this.commentLine("Handle file uploads with Vercel Blob", 8)}        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
           const file = (validatedBody as any).file as File
           const blob = await put(file.name, file, { access: 'public' })
           Object.assign(validatedBody, { fileUrl: blob.url })
         }` : uploadStrategy === "external" && uploadProvider === "uploadthing" ? `
-        // Handle file uploads with UploadThing
-        // Note: UploadThing requires a separate route handler setup
-        // See: https://docs.uploadthing.com/getting-started/appdir
-        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
-          // UploadThing file handling should be done via their route handler
-          // This is a placeholder - implement according to UploadThing docs
-        }` : `
-        // Handle file uploads with standard FormData
-        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
-          // Standard file upload handling
-          const file = (validatedBody as any).file as File
-          // Process file with compression and validation if enabled
-        }` : "";
-    return `/**
- * ${endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`}
- * @generated from ${endpoint.method} ${endpoint.path}
- * Features: Input validation, revalidation, error handling
- */
-export const ${actionName} = ${clientName}
+${this.commentLine("Handle file uploads with UploadThing", 8)}${this.commentLine("UploadThing requires a separate route handler setup", 8)}${this.commentLine("See: https://docs.uploadthing.com/getting-started/appdir", 8)}        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
+${this.commentLine("UploadThing file handling should be done via their route handler", 10)}${this.commentLine("This is a placeholder - implement according to UploadThing docs", 10)}        }` : `
+${this.commentLine("Handle file uploads with standard FormData", 8)}        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
+${this.commentLine("Standard file upload handling", 10)}          const file = (validatedBody as any).file as File
+${this.commentLine("Process file with compression and validation if enabled", 10)}        }` : "";
+    const mutationDocBlock = this.buildDocBlock(
+      endpoint,
+      "Input validation, revalidation, error handling"
+    );
+    return `${mutationDocBlock}export const ${actionName} = ${clientName}
   .metadata({
     name: "${kebabActionName}",
     requiresAuth: ${requiresAuth}${hasRateLimit ? `,
     rateLimit: { requests: ${endpoint.metadata.rateLimit?.requests || 10}, window: "${endpoint.metadata.rateLimit?.window || "1m"}" }` : ""}
   })
   .schema(${schemaName})
-  .action(async ({ parsedInput, ctx }: { parsedInput: ${hasRequestBody || hasAnyParams ? `z.infer<typeof ${schemaName}>` : "void"}, ctx${requiresAuth || hasRateLimit ? ": { user?: any, ratelimit?: { remaining: number } }" : "?: any"}) => {
+  .action(async ({ parsedInput, ctx }: ${actionArgsType}) => {
     const startTime = Date.now()
     
     try {${rateLimitCode}${parameterProcessing}${fileUploadCode}
@@ -3485,33 +3560,13 @@ export const ${actionName} = ${clientName}
         }
       })${streamingCode}${redirectCode}
 
-      // Revalidate cache after successful mutation
-${revalidationCode}
-      
-      // Background tasks (Next.js 15 feature)
-      ${isStreaming ? `after(async () => {
-        // Perform background tasks after response is sent
-        await logActionExecution('${actionName}', true, Date.now() - startTime, {
-          method: '${endpoint.method}',
-          path: '${endpoint.path}'
-        })
-      })` : `// Log successful execution
-      const duration = Date.now() - startTime
-      await logActionExecution('${actionName}', true, duration, {
-        method: '${endpoint.method}',
-        path: '${endpoint.path}'
-      })`}
+      ${revalidationCode ? `${this.commentLine("Revalidate cache after successful mutation", 6)}${revalidationCode}
+` : ""}
+${this.buildSuccessLoggingBlock(actionName, endpoint, 6, isStreaming)}
       
       return response.data
     } catch (error) {
-      const duration = Date.now() - startTime
-      
-      // Enhanced error logging
-      await logActionExecution('${actionName}', false, duration, {
-        method: '${endpoint.method}',
-        path: '${endpoint.path}',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      })
+${this.buildErrorLoggingBlock(actionName, endpoint, 6)}
       
       // Throw enhanced error with context
       throw new ActionExecutionError(
@@ -3670,7 +3725,6 @@ var HookGenerator = class {
       if (hasInfiniteQueries) reactQueryImports.push("useInfiniteQuery");
       const reactImports = [];
       if (hasMutations) reactImports.push("useOptimistic", "useTransition");
-      if (hasQueries) reactImports.push("useCallback");
       const imports = [
         "'use client'",
         "",
@@ -3782,19 +3836,19 @@ ${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier
  * @returns useQuery result with data of type ${returnType}
  */
 export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
-  const [searchParams, setSearchParams] = useQueryStates(searchParamsParser)
+  const [searchParams] = useQueryStates(searchParamsParser)
   const { initialData, ...restOptions } = options ?? {}
   
   return useQuery({
     queryKey: [...${queryKey}, searchParams],
-    queryFn: useCallback(async ({ signal }: { signal?: AbortSignal }) => {
+    queryFn: async ({ signal }: { signal?: AbortSignal }) => {
       try {
         const result = await ${actionName}(${actionCallParams.replace(queryParamObject, "{ ...searchParams }")})
         return result
       } catch (error) {
         handleActionError(error)
       }
-    }, [searchParams]),
+    },
     staleTime: ${staleTime},
     gcTime: ${staleTime * 2}, // React Query v5: gcTime replaces cacheTime
     enabled: ${enabledCondition} && (options?.enabled ?? true),
@@ -3826,14 +3880,14 @@ export function ${hookName.replace("use", "useInfinite")}(${parameterTypes.lengt
 
   return useInfiniteQuery({
     queryKey: [...${queryKey}, 'infinite', searchParams],
-    queryFn: useCallback(async ({ pageParam = 1, signal }: { pageParam?: number; signal?: AbortSignal }) => {
+    queryFn: async ({ pageParam = 1, signal }: { pageParam?: number; signal?: AbortSignal }) => {
       try {
         const result = await ${actionName}(${actionCallParams.replace(queryParamObject, "{ ...searchParams, page: pageParam, limit: searchParams.limit }")})
         return result
       } catch (error) {
         handleActionError(error)
       }
-    }, [searchParams]),
+    },
     getNextPageParam: (lastPage: ${returnType}, allPages: ${returnType}[]) => {
       if (lastPage?.hasMore || (Array.isArray(lastPage) && lastPage.length === searchParams.limit)) {
         return allPages.length + 1
@@ -3863,10 +3917,10 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
 
   return useSuspenseQuery({
     queryKey: ${queryKey},
-    queryFn: useCallback(async () => {
+    queryFn: async () => {
       const result = await ${actionName}(${actionCallParams})
       return result
-    }, []),
+    },
     staleTime: ${staleTime},
     initialData: initialData as ${returnType} | undefined,
     ...restOptions
@@ -3883,14 +3937,14 @@ export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join
 
   return useQuery({
     queryKey: ${queryKey},
-    queryFn: useCallback(async ({ signal }: { signal?: AbortSignal }) => {
+    queryFn: async ({ signal }: { signal?: AbortSignal }) => {
       try {
         const result = await ${actionName}(${actionCallParams})
         return result
       } catch (error) {
         handleActionError(error)
       }
-    }, []),
+    },
     staleTime: ${staleTime},
     gcTime: ${staleTime * 2}, // React Query v5: gcTime replaces cacheTime
     enabled: ${enabledCondition} && (options?.enabled ?? true),
@@ -3921,10 +3975,10 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
 
   return useSuspenseQuery({
     queryKey: ${queryKey},
-    queryFn: useCallback(async () => {
+    queryFn: async () => {
       const result = await ${actionName}(${actionCallParams})
       return result
-    }, []),
+    },
     staleTime: ${staleTime},
     initialData: initialData as ${returnType} | undefined,
     ...restOptions
@@ -3957,8 +4011,6 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
     const relatedQueries = this.findRelatedQueries(endpoint, context);
     const invalidationCode = this.buildInvalidationCode(endpoint, relatedQueries, invalidationTags);
     const cancelQueriesCode = this.buildCancelQueriesCode(endpoint, relatedQueries);
-    const snapshotCode = this.buildSnapshotCode(endpoint, relatedQueries);
-    const rollbackCode = this.buildRollbackCode(endpoint, relatedQueries);
     return `/**
  * Optimized mutation hook for ${endpoint.method} ${endpoint.path}
  * Features: Optimistic updates, smart invalidation, error handling
@@ -3979,7 +4031,7 @@ export function ${hookName}(options?: {
     mutationFn: async (variables: ${inputType}): Promise<${outputType}> => {
       try {
         const result = await ${actionName}(${variablesParam === "undefined" ? "" : "variables"})
-        return result.data || ({} as ${outputType})
+        return (result ?? ({} as ${outputType}))
       } catch (error) {
         handleActionError(error)
       }
@@ -3987,16 +4039,14 @@ export function ${hookName}(options?: {
     
     onMutate: async (variables: ${inputType}) => {
 ${cancelQueriesCode}
-      
-${snapshotCode}
-      
+
       // Optimistic update (if provided)
       if (options?.optimisticUpdate) {
         const optimisticValue = options.optimisticUpdate(variables)
         setOptimisticData(optimisticValue)
       }
       
-      return { /* Snapshot handled via query invalidation */ }
+      return {}
     },
     
     onSuccess: (data, variables) => {
@@ -4005,17 +4055,11 @@ ${snapshotCode}
         toast.success('${this.getSuccessMessage(endpoint)}')
       }
       
-      // Invalidate and refetch related queries
-${invalidationCode}
-      
       // Custom success handler
       options?.onSuccess?.(data, variables)
     },
     
-    onError: (error: Error, variables: ${inputType}, context: any) => {
-      // Rollback optimistic update
-${rollbackCode}
-      
+    onError: (error: Error, variables: ${inputType}) => {
       // Show error toast
       if (options?.showToast !== false) {
         toast.error(error.message || '${this.getErrorMessage(endpoint)}')
@@ -4025,7 +4069,7 @@ ${rollbackCode}
       options?.onError?.(error as Error, variables)
     },
     
-    onSettled: () => {
+    onSettled: async () => {
       // Always refetch after error or success
 ${invalidationCode}
     }
@@ -4051,100 +4095,81 @@ ${invalidationCode}
       return [];
     }
     const relatedQueries = [];
-    const mutationPath = endpoint.path;
+    const seen = /* @__PURE__ */ new Set();
     const mutationTag = endpoint.tags[0];
-    const pathSegments = mutationPath.split("/").filter(Boolean);
+    const mutationSegments = this.getResourceSegments(endpoint.path);
+    const mutationResource = mutationSegments[0];
     context.schema.endpoints.forEach((queryEndpoint) => {
       if (queryEndpoint.method !== "GET") return;
-      const queryPath = queryEndpoint.path;
+      const queryId = queryEndpoint.operationId || queryEndpoint.id;
+      if (seen.has(queryId)) return;
       const queryTag = queryEndpoint.tags[0];
-      if (queryTag === mutationTag) {
+      const querySegments = this.getResourceSegments(queryEndpoint.path);
+      const queryResource = querySegments[0];
+      if (mutationTag && queryTag === mutationTag) {
         relatedQueries.push(queryEndpoint);
+        seen.add(queryId);
         return;
       }
-      const querySegments = queryPath.split("/").filter(Boolean);
-      if (pathSegments.length >= 2 && querySegments.length >= 2) {
-        const baseMatch = pathSegments.slice(0, 2).join("/") === querySegments.slice(0, 2).join("/");
-        if (baseMatch) {
-          relatedQueries.push(queryEndpoint);
-        }
+      if (mutationResource && queryResource && mutationResource === queryResource) {
+        relatedQueries.push(queryEndpoint);
+        seen.add(queryId);
       }
     });
     return relatedQueries;
   }
+  getResourceSegments(path3) {
+    return path3.split("/").filter(Boolean).filter((segment) => segment.toLowerCase() !== "api" && !/^v\d+/i.test(segment));
+  }
   /**
    * Build invalidation code for related queries
    */
   buildInvalidationCode(endpoint, relatedQueries, invalidationTags) {
-    const invalidations = [];
+    const invalidations = /* @__PURE__ */ new Set();
     relatedQueries.forEach((queryEndpoint) => {
-      const queryKey = this.generateQueryKey(queryEndpoint);
-      invalidations.push(`      queryClient.invalidateQueries({ queryKey: ${queryKey} })`);
+      const queryKeyPrefix = toActionName(queryEndpoint.operationId || queryEndpoint.id);
+      invalidations.add(`queryClient.invalidateQueries({ queryKey: ['${queryKeyPrefix}'] })`);
     });
     invalidationTags.forEach((tag) => {
-      if (!invalidations.some((inv) => inv.includes(`'${tag}'`))) {
-        invalidations.push(`      queryClient.invalidateQueries({ queryKey: ['${tag}'] })`);
-      }
+      invalidations.add(`queryClient.invalidateQueries({ queryKey: ['${tag}'] })`);
     });
-    if (invalidations.length === 0) {
+    if (invalidations.size === 0) {
       const inferredKey = this.inferQueryKeyFromPath(endpoint);
       if (inferredKey) {
-        invalidations.push(`      queryClient.invalidateQueries({ queryKey: ${inferredKey} })`);
+        invalidations.add(`queryClient.invalidateQueries({ queryKey: ${inferredKey} })`);
       }
     }
-    return invalidations.length > 0 ? invalidations.join("\n") : "      // No specific cache invalidation needed";
+    if (invalidations.size === 0) {
+      return "      // No specific cache invalidation needed";
+    }
+    if (invalidations.size === 1) {
+      const [statement] = Array.from(invalidations);
+      return `      await ${statement}`;
+    }
+    return `      await Promise.all([
+        ${Array.from(invalidations).join(",\n        ")}
+      ])`;
   }
   /**
    * Build cancel queries code
    * Uses query key patterns to cancel all related queries regardless of parameters
    */
   buildCancelQueriesCode(endpoint, relatedQueries) {
-    const cancels = [];
+    const cancels = /* @__PURE__ */ new Set();
     relatedQueries.forEach((queryEndpoint) => {
-      const queryKeyPrefix = `'${toActionName(queryEndpoint.operationId || queryEndpoint.id)}'`;
-      cancels.push(`      await queryClient.cancelQueries({ queryKey: [${queryKeyPrefix}] })`);
+      const queryKeyPrefix = toActionName(queryEndpoint.operationId || queryEndpoint.id);
+      cancels.add(`queryClient.cancelQueries({ queryKey: ['${queryKeyPrefix}'] })`);
     });
-    return cancels.length > 0 ? cancels.join("\n") : "      // No queries to cancel";
-  }
-  /**
-   * Build snapshot code for rollback
-   * Note: We can't snapshot specific queries with parameters in onMutate scope
-   * Instead, we'll invalidate all related queries on error
-   */
-  buildSnapshotCode(endpoint, relatedQueries) {
-    if (relatedQueries.length === 0) {
-      return "      // No queries to snapshot";
-    }
-    return "      // Snapshot handled via query invalidation";
-  }
-  /**
-   * Build rollback code
-   */
-  buildRollbackCode(endpoint, relatedQueries) {
-    if (relatedQueries.length === 0) {
-      return "      // No queries to rollback";
+    if (cancels.size === 0) {
+      return "      // No queries to cancel";
     }
-    const rollbacks = [];
-    relatedQueries.forEach((queryEndpoint) => {
-      const queryKey = this.generateQueryKey(queryEndpoint);
-      const varName = `previous${this.toPascalCase(toActionName(queryEndpoint.operationId || queryEndpoint.id))}`;
-      rollbacks.push(`      if (context?.${varName}) {
-        queryClient.setQueryData(${queryKey}, context.${varName})
-      }`);
-    });
-    return rollbacks.join("\n");
-  }
-  /**
-   * Get snapshot return names for context
-   */
-  getSnapshotReturnNames(relatedQueries) {
-    if (relatedQueries.length === 0) {
-      return "previousData: null";
+    if (cancels.size === 1) {
+      const [statement] = Array.from(cancels);
+      return `      await ${statement}`;
     }
-    return relatedQueries.map((queryEndpoint) => {
-      const varName = `previous${this.toPascalCase(toActionName(queryEndpoint.operationId || queryEndpoint.id))}`;
-      return `${varName}`;
-    }).join(", ");
+    return `      await Promise.all([
+        ${Array.from(cancels).join(",\n        ")}
+      ])`;
   }
   /**
    * Infer query key from mutation path
@@ -9394,7 +9419,8 @@ var bridgeConfigSchema = z.object({
     logging: z.boolean().default(true),
     validation: z.boolean().default(true),
     mocking: z.boolean().default(false),
-    watch: z.boolean().default(false)
+    watch: z.boolean().default(false),
+    hotReload: z.boolean().default(false)
   }).optional(),
   plugins: z.array(
     z.object({
@@ -9407,6 +9433,7 @@ var bridgeConfigSchema = z.object({
     typescript: z.boolean().default(true),
     strict: z.boolean().default(true),
     comments: z.boolean().default(true),
+    documentation: z.boolean().default(true),
     examples: z.boolean().default(false),
     tests: z.boolean().default(false)
   }).optional()
@@ -9512,12 +9539,14 @@ ${errorMessages}`,
         logging: true,
         validation: true,
         mocking: false,
-        watch: false
+        watch: false,
+        hotReload: false
       },
       generation: {
         typescript: true,
         strict: true,
         comments: true,
+        documentation: true,
         examples: false,
         tests: false
       }
@@ -9570,5 +9599,5 @@ ${errorMessages}`,
 };
 
 export { BridgeCore, BridgeError, BridgeLogger, ConfigurationLoader, FileSystemManager, GenerationError, LogLevel, NextJsCodeGenerator, OpenApiSchemaParser, SchemaParseError, ValidationError, VersionChecker, __name, checkAndNotifyUpdates, createBridgeVersionChecker };
-//# sourceMappingURL=chunk-KCNMWAI2.js.map
-//# sourceMappingURL=chunk-KCNMWAI2.js.map
+//# sourceMappingURL=chunk-7Y66DW7M.js.map
+//# sourceMappingURL=chunk-7Y66DW7M.js.map