Better error handling for update learned patterns

[elie222]

Summary by CodeRabbit

• Bug Fixes

  • Improved error handling when saving learned patterns, providing clearer feedback if issues occur during the process.

• Chores

  • Updated the app version to v1.9.13.

[vercel]

The latest updates on your projects. Learn more about Vercel for Git ↗︎

Name	Status	Preview	Updated (UTC)
inbox-zero	✅ Ready (Inspect)	Visit Preview	Jul 16, 2025 0:17am

[coderabbitai]

Walkthrough

The changes introduce enhanced error handling for saving learned patterns in the assistant's chat logic and pattern management utility. The saveLearnedPatterns function now returns structured error or success objects, and the calling code in the assistant tool handles these outcomes explicitly. The application version is incremented to v1.9.13.

Changes

File(s)	Change Summary
apps/web/utils/ai/assistant/chat.ts	Updated to handle errors from saveLearnedPatterns by checking returned results and responding accordingly.
apps/web/utils/rule/learned-patterns.ts	Refactored saveLearnedPatterns to return explicit error or success objects, with improved error detection and aggregation.
version.txt	Version updated from v1.9.12 to v1.9.13.

Poem

A patch for patterns, errors now in sight,
The code grows wiser, handling wrong and right.
With clear returns and messages to show,
The assistant’s mind continues to grow.
Version hops ahead, a gentle cheer—
Another bug chased, another step clear!
🐇✨

---

📜 Recent review details

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 81550a1 and bc554fc.

📒 Files selected for processing (3)

• apps/web/utils/ai/assistant/chat.ts (1 hunks)
• apps/web/utils/rule/learned-patterns.ts (2 hunks)
• version.txt (1 hunks)

🧰 Additional context used

📓 Path-based instructions (2)

apps/web/**/*.{ts,tsx}

Instructions used from:

Sources:
📄 CodeRabbit Inference Engine

• apps/web/CLAUDE.md

**/*.{ts,tsx}

Instructions used from:

Sources:
📄 CodeRabbit Inference Engine

• .cursor/rules/form-handling.mdc

🧠 Learnings (1)

apps/web/utils/rule/learned-patterns.ts (7)

Learnt from: CR
PR: elie222/inbox-zero#0
File: .cursor/rules/form-handling.mdc:0-0
Timestamp: 2025-07-03T12:02:53.001Z
Learning: Applies to **/*.{ts,tsx} : Use descriptive error messages

Learnt from: CR
PR: elie222/inbox-zero#0
File: apps/web/CLAUDE.md:0-0
Timestamp: 2025-07-03T12:02:16.137Z
Learning: Applies to apps/web/**/*.{ts,tsx} : Use proper error handling with try/catch blocks

Learnt from: CR
PR: elie222/inbox-zero#0
File: .cursor/rules/prisma.mdc:0-0
Timestamp: 2025-06-23T12:26:53.882Z
Learning: In this project, Prisma should be imported using 'import prisma from "@/utils/prisma";' in TypeScript files.

Learnt from: CR
PR: elie222/inbox-zero#0
File: .cursor/rules/testing.mdc:0-0
Timestamp: 2025-06-23T12:27:30.570Z
Learning: When mocking Prisma in Vitest, import the Prisma mock from '@/utils/__mocks__/prisma', mock '@/utils/prisma', and clear all mocks in a beforeEach hook to ensure test isolation.

Learnt from: CR
PR: elie222/inbox-zero#0
File: .cursor/rules/logging.mdc:0-0
Timestamp: 2025-06-23T12:26:43.177Z
Learning: In TypeScript backend code, use the `createScopedLogger` function from `@/utils/logger` to perform logging. Typically, instantiate the logger at the top of the file with a relevant scope string.

Learnt from: CR
PR: elie222/inbox-zero#0
File: .cursor/rules/get-api-route.mdc:0-0
Timestamp: 2025-06-23T12:26:11.276Z
Learning: Prisma should be used as the ORM for all database queries within GET API routes in Next.js.

Learnt from: CR
PR: elie222/inbox-zero#0
File: .cursor/rules/llm.mdc:0-0
Timestamp: 2025-06-23T12:26:36.694Z
Learning: When implementing LLM-related functions in TypeScript, follow a standard structure: create a scoped logger, define a Zod schema for output validation, perform early input validation and returns, separate system and user prompts, log inputs and outputs, call the LLM with proper configuration, and return the validated result.

🔇 Additional comments (6)

apps/web/utils/rule/learned-patterns.ts (4)

4-4: Good addition of error handling utility.

The isDuplicateError import provides a consistent way to handle duplicate key errors from Prisma operations.

---

98-98: Excellent structured error response.

The change from return to return { error: "Rule not found" } provides clear, structured error feedback to callers instead of undefined behavior.

---

104-129: Robust group creation error handling.

The implementation properly handles duplicate group creation with a fallback strategy using timestamped names. The try-catch structure and specific error type checking align with the coding guidelines for proper error handling.

---

132-174: Comprehensive pattern upsert error handling.

The error collection approach allows the function to process all patterns and accumulate failures, providing detailed feedback about which specific patterns failed. The descriptive error messages follow the coding guidelines.

apps/web/utils/ai/assistant/chat.ts (1)

829-841: Excellent error handling integration.

The code properly captures the result from saveLearnedPatterns and handles errors explicitly with descriptive messages. The early return pattern prevents further execution on failure and maintains consistent error response structure.

version.txt (1)

1-1: Appropriate version bump.

The version increment to v1.9.13 properly reflects the error handling improvements in this release.

✨ Finishing Touches

• 📝 Generate Docstrings

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

🪧 Tips

Chat

There are 3 ways to chat with CodeRabbit:

• Review comments: Directly reply to a review comment made by CodeRabbit. Example:
  • I pushed a fix in commit <commit_id>, please review it.
  • Explain this complex logic.
  • Open a follow-up GitHub issue for this discussion.
• Files and specific lines of code (under the "Files changed" tab): Tag @coderabbitai in a new review comment at the desired location with your query. Examples:
  • @coderabbitai explain this code block.
  • @coderabbitai modularize this function.
• PR comments: Tag @coderabbitai in a new PR comment to ask questions about the PR branch. For the best results, please provide a very specific query, as very limited context is provided in this mode. Examples:
  • @coderabbitai gather interesting stats about this repository and render them as a table. Additionally, render a pie chart showing the language distribution in the codebase.
  • @coderabbitai read src/utils.ts and explain its main purpose.
  • @coderabbitai read the files in the src/scheduler package and generate a class diagram using mermaid and a README in the markdown format.
  • @coderabbitai help me debug CodeRabbit configuration file.

Support

Need help? Create a ticket on our support page for assistance with any issues or questions.

Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments.

CodeRabbit Commands (Invoked using PR comments)

• @coderabbitai pause to pause the reviews on a PR.
• @coderabbitai resume to resume the paused reviews.
• @coderabbitai review to trigger an incremental review. This is useful when automatic reviews are disabled for the repository.
• @coderabbitai full review to do a full review from scratch and review all the files again.
• @coderabbitai summary to regenerate the summary of the PR.
• @coderabbitai generate docstrings to generate docstrings for this PR.
• @coderabbitai generate sequence diagram to generate a sequence diagram of the changes in this PR.
• @coderabbitai resolve resolve all the CodeRabbit review comments.
• @coderabbitai configuration to show the current CodeRabbit configuration for the repository.
• @coderabbitai help to get help.

Other keywords and placeholders

• Add @coderabbitai ignore anywhere in the PR description to prevent this PR from being reviewed.
• Add @coderabbitai summary to generate the high-level summary at a specific location in the PR description.
• Add @coderabbitai anywhere in the PR title to generate the title automatically.

Documentation and Community

• Visit our Documentation for detailed information on how to use CodeRabbit.
• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[claude]

Claude finished @elie222's task —— View job

---

Code Review Complete ✅

I've reviewed the error handling improvements in this PR. Here's my feedback:

✅ Positive Changes

Improved Error Handling in learned-patterns.ts:

• Added comprehensive try-catch blocks around group creation (lines 104-130)
• Better error collection and reporting for pattern processing (lines 132-174)
• Proper error propagation to the calling function in chat.ts

Better Tool Response in chat.ts:

• The update_learned_patterns tool now properly handles and returns errors from saveLearnedPatterns (lines 835-841)

⚠️ Potential Issues

1. Duplicate Group Handling Logic (learned-patterns.ts:115-125)

if (isDuplicateError(error)) {
  logger.error("Group already exists", { emailAccountId, ruleName });
  const newGroup2 = await prisma.group.create({
    data: {
      emailAccountId,
      name: `${ruleName} (${new Date().toISOString()})`,
      rule: { connect: { id: rule.id } },
    },
  });
  groupId = newGroup2.id;
}

Issue: This creates a new group with a timestamp suffix when a duplicate is detected, which might not be the intended behavior. This could lead to multiple groups for the same rule.

2. Error Handling Inconsistency

• saveLearnedPattern (single) just logs errors and returns void
• saveLearnedPatterns (plural) returns structured error objects
• Consider standardizing error handling patterns across both functions

3. Continue-on-Error Pattern
In saveLearnedPatterns, errors are collected but processing continues:

for (const pattern of patterns) {
  try {
    // ... process pattern
  } catch (error) {
    // ... collect error but continue
  }
}

Consider: Whether this should fail-fast on the first error or continue processing all patterns.

📝 Suggestions

1. Improve Duplicate Group Handling

// Instead of creating a new group with timestamp, consider:
if (isDuplicateError(error)) {
  // Find existing group and reuse it
  const existingGroup = await prisma.group.findFirst({
    where: { emailAccountId, name: ruleName }
  });
  if (existingGroup) {
    groupId = existingGroup.id;
  } else {
    // Only create with timestamp if absolutely necessary
    // or throw a more specific error
  }
}

2. Consider Adding More Specific Error Types

type SavePatternsError = {
  type: 'RULE_NOT_FOUND' | 'GROUP_CREATION_FAILED' | 'PATTERN_DUPLICATE' | 'PATTERN_SAVE_FAILED';
  message: string;
  details?: any;
};

3. Add Logging for Successful Operations
Currently only errors are logged. Consider adding info-level logging for successful operations.

🔒 Security & Performance

• Security: No security concerns identified
• Performance: The database operations look reasonable, though consider batching upserts if dealing with large numbers of patterns

📊 Code Quality

Strengths:

• Clear error messages with context
• Proper use of Prisma's upsert functionality
• Good logging practices

Areas for improvement:

• Inconsistent error handling patterns between functions
• Could benefit from more specific error types

🎯 Overall Assessment

This PR significantly improves error handling for learned patterns functionality. The changes are well-structured and address important edge cases. The main concerns are around the duplicate group handling logic and consistency of error handling patterns.

Recommendation: ✅ Approve with minor suggestions - The improvements are valuable and the issues identified are minor.

---

[claude]

Claude finished @elie222's task —— View job

---

PR Review: Better error handling for update learned patterns

I'll review this pull request focusing on code quality, potential bugs, performance, and security concerns.

Todo List:

• Read and analyze changed files
• Review apps/web/utils/ai/assistant/chat.ts changes
• Review apps/web/utils/rule/learned-patterns.ts changes
• Review version.txt changes
• Provide comprehensive feedback on code quality and best practices
• Identify potential bugs or issues
• Assess performance considerations
• Check for security concerns
• Final review summary

File Analysis:

apps/web/utils/ai/assistant/chat.ts (+9/-1):

• Added proper error handling for saveLearnedPatterns call in apps/web/utils/ai/assistant/chat.ts:835-840
• Now checks if result contains error and returns it appropriately

apps/web/utils/rule/learned-patterns.ts (+61/-24):

• Major improvements to error handling throughout the function
• Added try-catch blocks around database operations
• Added error collection and detailed error reporting
• Added duplicate error handling when creating groups with timestamp fallback

version.txt (+1/-1):

• Version bump to v1.9.13

---

Code Quality & Best Practices ✅

Strengths:

• Improved error handling: The PR adds comprehensive error handling with proper try-catch blocks
• Better error reporting: Errors are now collected and returned with descriptive messages
• Consistent error patterns: Uses existing isDuplicateError helper consistently
• Proper logging: Maintains consistent logging patterns throughout

Areas for improvement:

• The fallback group name ${ruleName} (${new Date().toISOString()}) in learned-patterns.ts:120 could be more user-friendly
• Consider using a more descriptive error message format in the error collection

Potential Bugs & Issues ⚠️

Issues identified:

1. Potential race condition: In learned-patterns.ts:115-125, if multiple concurrent requests hit the duplicate error, they might all try to create the same timestamped group name
2. Error handling inconsistency: The function returns { error: "Rule not found" } early (line 98) but later collects errors in an array - this could cause confusion for callers
3. Missing error details: The error collection loses the original error context, making debugging harder

Recommendations:

• Add more specific error handling for the race condition scenario
• Consider adding error codes or types for better error handling upstream
• Preserve original error context in error messages for debugging

Performance Considerations ⚠️

Concerns:

1. N+1 query pattern: In learned-patterns.ts:135-168, the function processes patterns in a loop with individual database operations, which could be inefficient for large pattern sets
2. Redundant group creation: The duplicate error handling creates a new group after failing, which adds an extra database round trip

Recommendations:

• Consider using batch operations for multiple pattern updates
• Cache group lookup to avoid repeated queries
• Consider using database transactions for atomic operations

Security Concerns ✅

Assessment:

• No obvious security vulnerabilities introduced
• Proper use of Prisma ORM prevents SQL injection
• Input validation is handled upstream through Zod schemas
• Error messages don't expose sensitive information

Final Summary

Overall Assessment: Good improvements with minor issues to address

This PR successfully improves error handling for learned patterns, making the system more robust and providing better feedback to users. The main improvements include:

✅ What's working well:

• Comprehensive error handling and reporting
• Proper integration with existing error patterns
• Maintains backward compatibility
• Good logging practices

⚠️ What needs attention:

• Potential race condition in group creation fallback
• Performance considerations for batch operations
• Error handling consistency

Recommendation: Approve with minor fixes. The core functionality is solid, but consider addressing the race condition and performance concerns in a follow-up PR.

---