AI Prompts for Handling Async Errors Correctly

Please review the async functions in [FILE_PATH] and identify any that lack proper error handling mechanisms, such as try-catch blocks or effective error propagation. For each function without these mechanisms, provide a detailed list that includes the function name, its purpose, and the specific areas where error handling is missing. Additionally, suggest improvements for each identified function to enhance its error management. Format the response as a structured report that clearly outlines your findings and recommendations.

Please analyze the following code for any unhandled promise rejections. Execute the code and capture the output, specifically noting the locations in the code where these rejections occur. Additionally, provide suggestions on how to handle these rejections effectively to improve the robustness of the code. Ensure that your response includes a clear explanation of the potential causes of these unhandled rejections and best practices for error handling in asynchronous JavaScript.

Examine the code in [FILE_PATH] to analyze how errors are propagated from asynchronous functions. Identify specific instances where errors are not being handled correctly, and provide detailed examples of the affected functions. Additionally, explain the potential consequences of improper error propagation in this context and suggest best practices for handling errors in asynchronous code. Format your response to include code snippets and explanations for clarity.

Please review the following CLAUDE.md file content: [PASTE CONTENT]. Assess whether the current async error handling complies with the established rules and guidelines. Identify any discrepancies or areas for improvement, and provide specific recommendations on how to enhance the error handling practices outlined in the document. Your response should include a summary of the key findings and suggested changes.

Inspect the async functions in [FILE_PATH] and identify whether errors are being logged appropriately. For each function, provide a brief description of its purpose and indicate if error logging is present or missing. If any functions lack error logging, list them and suggest what type of error logging would be beneficial to implement for better debugging and monitoring.

Identify all async functions in the provided code that currently lack try-catch blocks for error handling. For each of these functions, add appropriate try-catch blocks to ensure that any potential errors are caught and handled gracefully. After implementing the changes, provide the updated code with comments explaining the error handling logic used in each function. Ensure that the code remains clean and maintainable while effectively managing asynchronous errors.

Revise the async functions in [FILE_PATH] to ensure that errors are propagated correctly throughout the code. Provide the updated code with clear comments explaining how error handling is implemented. Additionally, include examples of how the revised functions can be called and how they handle errors in different scenarios. Ensure that the solution adheres to best practices for error propagation in asynchronous programming.

Please enhance the error logging in all asynchronous functions within the file located at [FILE_PATH]. Identify any functions that currently lack logging and implement a structured logging mechanism that captures errors and relevant context. For each change made, provide a summary of the modifications, including the specific lines of code where logging was added and the type of information being logged. Ensure that the logging format is consistent throughout the file and follows best practices for error handling.

Refactor the async error handling in the code located at [FILE_PATH] to ensure it adheres to the guidelines outlined in CLAUDE.md. Provide the updated code with clear comments explaining the changes made for consistency. Additionally, include a brief summary of the improvements in error handling and how they align with best practices. Ensure that the refactored code is well-structured and easy to read, highlighting any significant modifications or enhancements.

Review the code in [FILE_PATH] and ensure that all promises are handled correctly. Identify any promises that are missing a .catch() method or a try-catch block for error handling. Provide the updated code snippets with the necessary error handling added, and explain the changes made to improve the robustness of the code. Highlight any specific areas where errors could occur and how the new handling prevents potential issues.

Please execute the test suite for the async error handling functionality in the codebase. I need you to verify that all async errors are being caught and managed appropriately. After running the tests, provide a detailed report of the results, including any errors encountered, the number of tests passed versus failed, and any relevant logs or stack traces that could help diagnose issues. Additionally, summarize any patterns or common failures observed during the testing process.

Please run the application and check for any unhandled promise rejections. I need a detailed output log that highlights any instances of rejections, including the error messages and the stack traces associated with them. Additionally, summarize whether the application handled all promises correctly and if any improvements are needed to ensure proper error handling in the future.

Please review the error logs generated after running the application for any instances of asynchronous errors. Ensure that all async errors are properly logged and provide excerpts from the logs that illustrate these errors. Additionally, summarize any patterns or recurring issues you notice in the logs, and suggest potential improvements to enhance error handling in the application. Format your findings in a clear report with sections for log excerpts, analysis, and recommendations.

Please demonstrate how errors are propagating correctly through asynchronous functions in a JavaScript context. Provide sample code snippets that illustrate both the correct handling of errors and the expected outputs when an error occurs. Include at least two examples: one where an error is caught and handled gracefully, and another where the error is allowed to propagate up the call stack. Ensure that the explanations for each example clearly outline the flow of execution and how the error is managed.

Please review the provided code for consistent asynchronous error handling. Ensure that it adheres to the guidelines outlined in the CLAUDE.md documentation. Identify any discrepancies or areas where the error handling could be improved, and provide a summary of your findings, including specific examples from the code. Additionally, suggest best practices for maintaining consistency in async error handling moving forward.

Please draft a new rule for the CLAUDE.md documentation that focuses on enforcing async error handling in code. The rule should clearly outline the importance of handling asynchronous errors, provide examples of common pitfalls, and specify best practices for developers to follow. Include a section on how to implement proper error handling in async functions, along with code snippets that illustrate both correct and incorrect approaches. Ensure the rule is concise yet comprehensive, suitable for inclusion in a technical guideline document.

Please review the code in [FILE_PATH] and insert detailed comments that explain the async error handling strategy used throughout the file. Make sure to clarify the purpose of each section of the code, particularly where errors may occur and how they are managed. Include explanations of any specific error handling techniques applied, such as try-catch blocks or promise rejection handling. Present the updated code with the comments integrated, ensuring that the comments enhance understanding for someone unfamiliar with the code.

Create a comprehensive checklist for reviewing asynchronous error handling in new code. The checklist should include key areas such as: verifying that all async functions have appropriate try-catch blocks, ensuring that errors are logged correctly, checking that promises are handled properly with .catch() or async/await syntax, and confirming that fallback mechanisms are in place for critical operations. Additionally, include points on testing error scenarios to ensure robustness and documenting any known issues or limitations. Format the checklist in a clear, organized manner for easy reference.

Define clear naming conventions for asynchronous functions that indicate their error handling capabilities. Explain how these conventions can help developers understand the function's behavior at a glance. Provide specific examples of naming patterns, such as using prefixes or suffixes to denote functions that handle errors, and describe the rationale behind each example. Additionally, suggest best practices for maintaining consistency in naming across a codebase.

Help me implement a project guard that will alert me when there are missing try-catch blocks in asynchronous functions within my codebase. Please provide a detailed description of the configuration settings needed for this guard, including the specific criteria it should monitor, how to integrate it into the existing project, and any necessary adjustments to the code or project structure. Additionally, outline the steps for testing the guard to ensure it functions correctly and effectively captures the intended errors. Format your response as a step-by-step guide that I can easily follow.