Implement Splitwise import functionality #239
Conversation
✅ Deploy Preview for split-but-wiser ready!
To edit notification comments on pull requests, go to your Netlify project configuration. |
WalkthroughAdds a Splitwise import integration end-to-end: backend API/router, service, Splitwise SDK client and schemas; migrations and currency support; group balance caching plan and init migration; web and mobile UI/routes and API client updates; auth placeholder activation; extensive tests, verification script, and documentation. Changes
🚥 Pre-merge checks | ✅ 3✅ Passed checks (3 passed)
✏️ Tip: You can configure your own custom pre-merge checks in the settings. 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. Comment |
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 30
🤖 Fix all issues with AI agents
In @backend/app/config.py:
- Around line 36-41: The Settings class exposes frontend_url which is used
directly in OAuth redirect URIs (router.py), allowing an attacker to configure
an untrusted domain; add a Pydantic validator on the Settings model (e.g.,
validate_frontend_url or a @validator for frontend_url) to ensure the value is a
well-formed URL and matches a whitelist of allowed origins (or at minimum only
allows specific schemes and hostnames), and update any code paths that consume
frontend_url (router functions that build redirect URIs) to rely on the
validated property so untrusted domains cannot be used for redirects.
In @backend/app/integrations/router.py:
- Around line 151-155: The HTTPException raised in the except block that handles
import startup failures should use exception chaining to preserve the original
traceback; update the raise of HTTPException (the one with
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR and detail=f"Failed to start
import: {str(e)}") to re-raise the HTTPException using "from e" so the original
exception e is chained to the HTTPException.
- Around line 98-101: In the except block that catches Exception as e in
backend/app/integrations/router.py (the block that raises HTTPException with
detail "Failed to exchange OAuth code"), re-raise the HTTPException using
exception chaining by adding "from e" to preserve the original traceback (i.e.,
raise HTTPException(...) from e) so the original exception context is not lost.
- Around line 84-90: ImportService is being instantiated without the required db
dependency (ImportService()) causing inconsistency with the later call
ImportService(db); update the endpoint to accept the database dependency and
pass it into the service: add the db parameter (injected via your existing DB
dependency provider) to the route handler signature and replace ImportService()
with ImportService(db) when calling start_import so both usages are consistent
and the service receives the DB connection.
- Around line 24-55: get_splitwise_oauth_url currently returns the OAuth state
secret to the client without server-side storage; store the generated `secret`
server-side (e.g., Redis or DB) keyed by the current user id (use the same
`current_user=Depends(get_current_user)` value) before returning the
`authorization_url` and return only a non-sensitive reference if needed. In the
Splitwise callback handler (the endpoint that accepts `state` and exchanges the
token, e.g., your callback function), fetch the stored state by the same user
key, compare it to the incoming `state`, reject the request with an HTTP 400/401
if they don’t match, and only then proceed to exchange the token; finally
delete/expire the stored state after validation. Ensure you reference
`get_splitwise_oauth_url`, the callback handler name, and the `state`/`secret`
symbols when making these changes.
In @backend/app/integrations/schemas.py:
- Around line 102-109: ImportStatusCheckpoint currently defines stage fields as
plain strings ("pending"); change each field (user, friends, groups, expenses,
settlements) to use the ImportStatus enum type and set their defaults to the
appropriate enum member (e.g., ImportStatus.PENDING) so the model enforces enum
values and improves type safety; update the class signature to annotate each
field as ImportStatus and ensure ImportStatus is imported into the module.
In @backend/app/integrations/service.py:
- Around line 155-166: The OAuth credentials are being stored in plaintext when
calling self.oauth_tokens.insert_one; encrypt apiKey, consumerKey, and
consumerSecret before insertion by invoking your encryption helper (e.g.,
encrypt_secret or a kms_encrypt function) and store the encrypted blobs instead
of raw strings, updating the document keys ("apiKey", "consumerKey",
"consumerSecret") to hold the encrypted values; ensure decrypt_secret is used
when reading and document the encryption scheme and required env/config (KMS
key, encryption key, or Fernet) so production uses a secure key management
system.
- Around line 369-374: The current call to client.get_expenses(limit=1000) can
miss records for users with >1000 expenses; replace the single call with a
paginated fetch that repeatedly calls client.get_expenses(limit=..., offset=...)
(or the client’s paging params) in a loop, accumulate results into all_expenses
until an empty/shorter-than-limit batch is returned, then call await
self._update_checkpoint(import_job_id, "expensesImported.total",
len(all_expenses)); update any variables that assume a single batch (e.g.,
references to all_expenses) to use the accumulated list.
- Line 132: The call to options.dict() uses the deprecated Pydantic v2 API;
update the serialization to use options.model_dump() instead (replace the
options.dict() invocation where the payload is built so the "options" object is
serialized with model_dump()). Ensure any downstream code expecting the prior
dict format still works with the returned dict from model_dump().
- Around line 254-262: The code currently does users.find_one({"email":
friend_data["email"]}) which will match documents with missing or null email
when friend_data["email"] is None; before querying or inserting validate
friend_data.get("email") is a non-empty string (or a valid email) and only then
call users.find_one and users.insert_one; alternatively, if you must allow empty
emails, change the query to users.find_one({"email": {"$exists": True, "$eq":
friend_data["email"]}}) to avoid matching documents missing the field, and skip
or assign a generated placeholder when friend_data["email"] is None.
- Around line 76-82: The warning currently includes raw PII via the f"Email
{splitwise_user['email']} already exists" string; update the warnings.append
payload to avoid exposing the full email by either using a generic message like
"Email already exists" or a masked version of the address (e.g., show only
username initial and domain) before inserting into the "message" field; locate
the dict added in warnings.append and replace the f-string that references
splitwise_user['email'] with the non-PII/generic or masked value (you can add a
small helper like mask_email(email) and call it where the message is built).
- Around line 168-173: The background task created with asyncio.create_task is
discarded; capture and retain the Task so exceptions aren't lost and the task
can be monitored/cancelled. Assign the result of asyncio.create_task(...) to a
variable (e.g., task), add a done callback on that Task to log or handle
exceptions coming from self._perform_import, and store the Task reference on the
service instance (for example in a self._background_tasks dict keyed by
import_job_id or a list) so callers can query or cancel it later; keep the
existing comment about using a real task queue for production.
- Around line 314-323: The admin-role check is comparing different ID systems
(member["userId"] is a Splitwise ID) so it never matches; update the condition
inside the mapped_members append to compare the application's user ID instead,
e.g. replace ("admin" if member["userId"] == user_id else "member") with
("admin" if ObjectId(mapping["splitwiserId"]) == user_id else "member") so you
compare the same Splitwiser IDs (or, alternatively, compare
mapping["splitwiserId"] as a string to str(user_id) if user_id is not an
ObjectId).
- Around line 452-456: The createdAt assignment using
datetime.fromisoformat(expense_data["createdAt"]) can raise ValueError for
non-ISO strings; update the code that builds "createdAt" (the expense_data ->
"createdAt" logic inside the expense processing block) to try fromisoformat
first, then fall back to a more lenient parser (e.g., dateutil.parser.parse)
inside a localized try/except, and if parsing still fails use
datetime.now(timezone.utc); alternatively extract this into a small helper like
parse_created_at(expense_data["createdAt"]) that returns a timezone-aware
datetime so parsing errors are handled locally and do not cause the whole
expense to be skipped.
In @backend/app/integrations/splitwise/client.py:
- Around line 16-29: The __init__ parameters use implicit Optional types by
assigning = None; update the signature of Splitwise client __init__ to use
explicit Optional[str] for api_key, consumer_key, and consumer_secret (and add
the corresponding typing import), e.g. import Optional from typing and change
the annotations for api_key, consumer_key, consumer_secret to Optional[str], and
optionally annotate the method return as -> None; keep the rest of the
initialization (self.sObj = Splitwise(...)) unchanged.
- Around line 176-222: The loops and try/except blocks around users, split
transforms, category extraction (expense.getCategory) and receipt extraction
(expense.getReceipt) currently swallow all exceptions; change each bare "except
Exception" to capture the exception as "e" and log it (e.g., logger.exception or
logger.warning(..., exc_info=True)) with contextual identifiers like
user.getId(), paid_by_user_id, or expense.getId()/other expense fields before
continuing, so you still skip bad records but retain stacktrace and context for
debugging.
- Around line 106-107: The bare "except Exception: pass" in the Splitwise
balance-processing block silently swallows errors; replace it with a logging
warning that includes the caught exception and any relevant balance/input data
so issues are visible. Catch Exception as e, call the module/class logger (e.g.,
logger.warning or self.logger.warning) with a message like "Failed to parse
Splitwise balance" including the exception (or use logger.exception) and the
problematic balance payload, then continue or handle fallback as before.
In @backend/verify_settlements.py:
- Around line 104-146: The create_group function currently declares it returns
str but can return None on failure; change its signature to async def
create_group(...) -> Optional[str] and add from typing import Optional, keep the
early return None on non-201 responses, and ensure callers of create_group (see
the invocation around the area previously shown near lines 487-493) check the
returned value and either abort/raise a clear RuntimeError or handle the None
case before using the group_id in URLs or further requests so failures don’t
cascade into invalid requests or misleading verification results.
- Around line 147-177: The equal-split logic in create_expense currently uses
split_amount = round(amount / len(members), 2) which can cause the sum of splits
to differ from amount; instead compute splits in integer cents to guarantee
totals match: convert amount to cents (int(round(amount * 100))), compute
base_cents = cents // n and remainder = cents - base_cents * n, then build
splits by assigning base_cents to every member and adding one extra cent to the
first `remainder` members; replace the current `split_amount`/`splits`
construction with this cents-based distribution while still using
self.user_ids[member] for "userId" and converting per-member cents back to
dollars for the "amount" field so the sum of `splits` equals `amount`.
- Around line 428-463: cleanup_test_data currently deletes every group the test
accounts can access; limit deletion to only test-created groups by either (a)
tracking created group IDs in this script (e.g., maintain a created_group_ids
set when creating groups and iterate that set in cleanup_test_data to delete
only those IDs), or (b) filter fetched groups by a safe name prefix (check
group.get("name") against the test prefix before deleting). Remove or use the
unused local group_name only for the prefix check, and keep the existing
token/header logic and HTTP delete calls but applied only to the tracked IDs or
filtered groups.
In @docs/splitwise-import-integration.md:
- Around line 24-36: Add explicit fenced code block languages (e.g., use
```text) for the ASCII diagrams (for example the block that begins with
"┌─────────────────┐" and the Splitwise import diagram), ensure there is exactly
one blank line before and after each fenced block, remove any trailing spaces on
lines inside and around those blocks, and fix spacing around headings so
markdownlint rules pass; apply the same changes to the other diagram/code blocks
noted (lines 110-137, 206-212, 221-255, 260-288).
In @mobile/screens/SplitwiseImportScreen.js:
- Around line 24-30: The loading spinner is never cleared after successfully
opening the OAuth URL; after calling Linking.openURL(authorization_url) you
should reset the component's loading state (e.g., call setLoading(false) or
equivalent) so the spinner stops; update the block around Linking.openURL and
Alert.alert to call the state reset immediately after openURL succeeds (or in
the Alert.alert onPress handler before navigation.goBack()) to ensure the
loading flag used by the spinner is cleared.
- Around line 143-167: Remove the unused style properties from the styles object
in SplitwiseImportScreen.js: delete input, link, progressContainer,
progressHeader, progressText, and progressBar from the StyleSheet so the styles
object only contains used keys; also search the file for any remaining
references to these symbol names (e.g., className/ style={styles.input} etc.)
and remove or replace them if found to avoid runtime errors.
In @web/pages/Profile.tsx:
- Around line 111-116: The Import menu entry currently reuses the Settings icon
which can confuse users; update the items array for the menu object with title
'Import' to use a more semantically appropriate icon (e.g., replace Settings
with Download or ArrowDownToLine from lucide-react) for the item whose onClick
navigates to '/import/splitwise' so the entry visually indicates
importing/download rather than settings.
In @web/pages/SplitwiseImport.tsx:
- Around line 41-61: The button element that invokes handleOAuthImport is
missing an explicit type (so it defaults to "submit") and the SVG lacks
accessible text; change the button to include type="button" to prevent
unintended form submissions and update the SVG used in the non-loading branch to
provide accessible alternative text (e.g., add a <title> like "Splitwise icon"
and ensure the SVG has role="img" or an aria-label) so screen readers announce
the icon; keep the loading spinner decorative (e.g., aria-hidden="true") while
the non-loading SVG provides a proper accessible name.
In @web/services/api.ts:
- Around line 52-58: The frontend function startSplitwiseImport is sending an
unused apiKey to /import/splitwise/start; remove the apiKey parameter from
startSplitwiseImport in web/services/api.ts and stop including { api_key: apiKey
} in the POST body, then update all call sites to call startSplitwiseImport()
with no args. Alternatively, if per-request credentials are desired instead,
modify the backend router handler referenced (router.py lines ~126–128) to
accept and validate an api_key from the request body and use it instead of the
environment config, and add server-side validation/tests accordingly so the
frontend payload becomes meaningful.
📜 Review details
Configuration used: Organization UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (20)
backend/app/config.pybackend/app/integrations/__init__.pybackend/app/integrations/router.pybackend/app/integrations/schemas.pybackend/app/integrations/service.pybackend/app/integrations/splitwise/__init__.pybackend/app/integrations/splitwise/client.pybackend/main.pybackend/requirements.txtbackend/verify_settlements.pydocs/splitwise-import-integration.mdmobile/api/client.jsmobile/navigation/AccountStackNavigator.jsmobile/screens/AccountScreen.jsmobile/screens/SplitwiseImportScreen.jsweb/App.tsxweb/pages/Profile.tsxweb/pages/SplitwiseCallback.tsxweb/pages/SplitwiseImport.tsxweb/services/api.ts
🧰 Additional context used
📓 Path-based instructions (4)
web/pages/**/*.{ts,tsx}
📄 CodeRabbit inference engine (.github/copilot-instructions.md)
Web pages should be created as components in
web/pages/and added to routing configuration
Files:
web/pages/Profile.tsxweb/pages/SplitwiseImport.tsxweb/pages/SplitwiseCallback.tsx
backend/app/**/*.py
📄 CodeRabbit inference engine (.github/copilot-instructions.md)
backend/app/**/*.py: Backend API routes should be added to the appropriate service router file inbackend/app/based on the feature area (auth, user, groups, expenses)
Use RESTful API design patterns with FastAPI in the backend
Use MongoDB for persistent data storage in the backend with a nonrelational schema design
Files:
backend/app/integrations/__init__.pybackend/app/integrations/splitwise/client.pybackend/app/config.pybackend/app/integrations/splitwise/__init__.pybackend/app/integrations/router.pybackend/app/integrations/service.pybackend/app/integrations/schemas.py
{mobile/api/**/*.js,web/services/**/*.{ts,tsx,js}}
📄 CodeRabbit inference engine (.github/copilot-instructions.md)
Use Axios for HTTP requests with Content-Type application/json header in API client calls
Files:
web/services/api.tsmobile/api/client.js
mobile/screens/**/*.js
📄 CodeRabbit inference engine (.github/copilot-instructions.md)
Mobile screens should be created as components in
mobile/screens/and registered in the navigation structure
Files:
mobile/screens/SplitwiseImportScreen.jsmobile/screens/AccountScreen.js
🧬 Code graph analysis (8)
web/pages/Profile.tsx (1)
backend/app/config.py (1)
Settings(12-52)
web/services/api.ts (1)
mobile/api/client.js (10)
getSplitwiseAuthUrl(120-122)getSplitwiseAuthUrl(120-122)handleSplitwiseCallback(124-126)handleSplitwiseCallback(124-126)startSplitwiseImport(128-130)startSplitwiseImport(128-130)getImportStatus(132-134)getImportStatus(132-134)rollbackImport(136-138)rollbackImport(136-138)
web/pages/SplitwiseImport.tsx (2)
mobile/screens/SplitwiseImportScreen.js (2)
loading(14-14)handleOAuthImport(16-43)web/contexts/ToastContext.tsx (1)
useToast(39-45)
mobile/api/client.js (1)
web/services/api.ts (5)
getSplitwiseAuthUrl(53-53)handleSplitwiseCallback(54-54)startSplitwiseImport(55-55)getImportStatus(56-56)rollbackImport(57-57)
web/pages/SplitwiseCallback.tsx (2)
web/contexts/ToastContext.tsx (1)
useToast(39-45)mobile/api/client.js (1)
status(84-84)
web/App.tsx (2)
web/pages/SplitwiseImport.tsx (1)
SplitwiseImport(5-98)web/pages/SplitwiseCallback.tsx (1)
SplitwiseCallback(6-114)
backend/verify_settlements.py (1)
backend/tests/user/test_user_routes.py (1)
client(15-17)
backend/app/integrations/service.py (3)
backend/app/integrations/schemas.py (5)
ImportError(46-52)ImportOptions(55-61)ImportProvider(12-15)ImportStatus(18-25)ImportSummary(124-132)backend/app/integrations/splitwise/client.py (9)
SplitwiseClient(13-276)get_current_user(31-33)get_friends(35-37)get_groups(39-41)get_expenses(43-56)transform_user(59-78)transform_friend(81-118)transform_group(121-155)transform_expense(171-276)backend/app/integrations/router.py (1)
get_import_status(159-243)
🪛 Biome (2.1.2)
web/pages/SplitwiseImport.tsx
[error] 55-55: Alternative text title element cannot be empty
For accessibility purposes, SVGs should have an alternative text, provided via title element. If the svg element has role="img", you should add the aria-label or aria-labelledby attribute.
(lint/a11y/noSvgWithoutTitle)
[error] 41-47: Provide an explicit type prop for the button element.
The default type of a button is submit, which causes the submission of a form when placed inside a form element. This is likely not the behaviour that you want inside a React application.
Allowed button types are: submit, button or reset
(lint/a11y/useButtonType)
🪛 LanguageTool
docs/splitwise-import-integration.md
[grammar] ~264-~264: Use a hyphen to join words.
Context: ...esponse: Array of comments ``` ### Rate Limiting Strategy Splitwise API has rat...
(QB_NEW_EN_HYPHEN)
[uncategorized] ~989-~989: If this is a compound adjective that modifies the following noun, use a hyphen.
Context: ...ion API client, monitor for changes | | Rate limiting issues | Medium | High | Implement smar...
(EN_COMPOUND_ADJECTIVE_INTERNAL)
🪛 markdownlint-cli2 (0.18.1)
docs/splitwise-import-integration.md
24-24: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
52-52: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
110-110: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
118-118: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
126-126: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
206-206: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
269-269: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
436-436: Headings should be surrounded by blank lines
Expected: 1; Actual: 0; Below
(MD022, blanks-around-headings)
441-441: Headings should be surrounded by blank lines
Expected: 1; Actual: 0; Below
(MD022, blanks-around-headings)
446-446: Headings should be surrounded by blank lines
Expected: 1; Actual: 0; Below
(MD022, blanks-around-headings)
451-451: Headings should be surrounded by blank lines
Expected: 1; Actual: 0; Below
(MD022, blanks-around-headings)
453-453: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
458-458: Headings should be surrounded by blank lines
Expected: 1; Actual: 0; Below
(MD022, blanks-around-headings)
687-687: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
688-688: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
689-689: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
690-690: Trailing spaces
Expected: 0 or 2; Actual: 1
(MD009, no-trailing-spaces)
692-692: Fenced code blocks should be surrounded by blank lines
(MD031, blanks-around-fences)
692-692: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
🪛 Ruff (0.14.10)
backend/app/integrations/splitwise/client.py
8-8: typing.Dict is deprecated, use dict instead
(UP035)
8-8: typing.List is deprecated, use list instead
(UP035)
16-16: Missing return type annotation for special method __init__
Add return type annotation: None
(ANN204)
17-17: PEP 484 prohibits implicit Optional
Convert to T | None
(RUF013)
17-17: PEP 484 prohibits implicit Optional
Convert to T | None
(RUF013)
17-17: PEP 484 prohibits implicit Optional
Convert to T | None
(RUF013)
106-107: try-except-pass detected, consider logging the exception
(S110)
106-106: Do not catch blind exception: Exception
(BLE001)
158-158: Missing return type annotation for staticmethod _safe_isoformat
(ANN205)
181-182: try-except-continue detected, consider logging the exception
(S112)
181-181: Do not catch blind exception: Exception
(BLE001)
201-202: try-except-continue detected, consider logging the exception
(S112)
201-201: Do not catch blind exception: Exception
(BLE001)
211-212: try-except-pass detected, consider logging the exception
(S110)
211-211: Do not catch blind exception: Exception
(BLE001)
221-222: try-except-pass detected, consider logging the exception
(S110)
221-221: Do not catch blind exception: Exception
(BLE001)
backend/verify_settlements.py
28-28: typing.Dict is deprecated, use dict instead
(UP035)
28-28: typing.List is deprecated, use list instead
(UP035)
47-47: Missing return type annotation for special method __init__
Add return type annotation: None
(ANN204)
77-77: f-string without any placeholders
Remove extraneous f prefix
(F541)
81-81: Do not catch blind exception: Exception
(BLE001)
181-181: f-string without any placeholders
Remove extraneous f prefix
(F541)
326-326: f-string without any placeholders
Remove extraneous f prefix
(F541)
447-447: Local variable group_name is assigned to but never used
Remove assignment to unused variable group_name
(F841)
462-462: f-string without any placeholders
Remove extraneous f prefix
(F541)
462-462: String contains ambiguous ℹ (INFORMATION SOURCE). Did you mean i (LATIN SMALL LETTER I)?
(RUF001)
575-575: Do not catch blind exception: Exception
(BLE001)
backend/app/integrations/router.py
25-25: Unused function argument: current_user
(ARG001)
25-25: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
60-60: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
98-98: Do not catch blind exception: Exception
(BLE001)
99-101: Within an except clause, raise exceptions with raise ... from err or raise ... from None to distinguish them from errors in exception handling
(B904)
100-100: Use explicit conversion flag
Replace with conversion flag
(RUF010)
107-107: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
108-108: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
151-151: Do not catch blind exception: Exception
(BLE001)
152-155: Within an except clause, raise exceptions with raise ... from err or raise ... from None to distinguish them from errors in exception handling
(B904)
154-154: Use explicit conversion flag
Replace with conversion flag
(RUF010)
161-161: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
162-162: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
249-249: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
250-250: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
backend/app/integrations/service.py
7-7: typing.Dict is deprecated, use dict instead
(UP035)
7-7: typing.List is deprecated, use list instead
(UP035)
25-25: Missing return type annotation for special method __init__
Add return type annotation: None
(ANN204)
169-173: Store a reference to the return value of asyncio.create_task
(RUF006)
177-177: Missing return type annotation for private function _perform_import
Add return type annotation: None
(ANN202)
211-211: Boolean positional value in function call
(FBT003)
217-217: Boolean positional value in function call
(FBT003)
241-241: Do not catch blind exception: Exception
(BLE001)
249-249: Missing return type annotation for private function _import_friends
Add return type annotation: None
(ANN202)
249-249: Unused method argument: user_id
(ARG002)
294-294: Do not catch blind exception: Exception
(BLE001)
297-297: Missing return type annotation for private function _import_groups
Add return type annotation: None
(ANN202)
358-358: Do not catch blind exception: Exception
(BLE001)
361-361: Missing return type annotation for private function _import_expenses
Add return type annotation: None
(ANN202)
478-478: Do not catch blind exception: Exception
(BLE001)
481-481: Missing return type annotation for private function _update_checkpoint
Add return type annotation: None
(ANN202)
482-482: Boolean-typed positional argument in function definition
(FBT001)
482-482: Boolean default positional argument in function definition
(FBT002)
496-496: Missing return type annotation for private function _increment_summary
Add return type annotation: None
(ANN202)
502-502: Missing return type annotation for private function _record_error
Add return type annotation: None
(ANN202)
554-558: Consider moving this statement to an else block
(TRY300)
560-560: Do not catch blind exception: Exception
(BLE001)
564-564: Use explicit conversion flag
Replace with conversion flag
(RUF010)
backend/app/integrations/schemas.py
7-7: typing.Dict is deprecated, use dict instead
(UP035)
7-7: typing.List is deprecated, use list instead
(UP035)
⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (2)
- GitHub Check: rn-bundle-analysis
- GitHub Check: preview
🔇 Additional comments (29)
mobile/screens/AccountScreen.js (1)
56-61: Looks good; just confirm the"import"icon name exists in your icon set. If not, the item may render with a missing icon glyph.backend/app/integrations/splitwise/__init__.py (1)
1-5: LGTM. Clear package docstring; no behavioral impact.mobile/navigation/AccountStackNavigator.js (1)
4-4: LGTM. Route registration matchesnavigation.navigate("SplitwiseImport").Also applies to: 13-13
backend/verify_settlements.py (1)
269-300: Verify expected balance values against actual backend calculation behavior. The script's expected values assume completed settlements don't affect balances, but the backend's aggregation pipelines include all settlements (pending and completed) in balance calculations. If actual API responses include completed settlements, these expected values are correct; if they exclude completed settlements despite the code including them, the assertions will fail.backend/requirements.txt (1)
14-14: Pinsplitwiseto an exact version to maintain reproducibility. All other dependencies in requirements.txt use==pinning (fastapi==0.116.1, pymongo==4.13.1, etc.), but splitwise is unpinned with>=3.0.0. Since the codebase heavily depends on splitwise for OAuth and data import flows, inconsistent versions across environments could cause breakage. Determine the appropriate version for this codebase and update tosplitwise==X.Y.Z.backend/app/integrations/__init__.py (1)
1-7: LGTM!Clean package initialization with appropriate documentation describing the module's purpose and future extensibility.
backend/main.py (2)
9-9: LGTM!Import follows the established pattern for other routers in the application.
132-132: Router is properly configured with prefix and tags.The
integrations_routerinbackend/app/integrations/router.pycorrectly defines both the prefix (/import) and tags (["import"]) for API documentation consistency. No changes needed.web/App.tsx (1)
15-16: LGTM!Imports for the new Splitwise integration pages follow the established pattern.
web/pages/SplitwiseCallback.tsx (1)
78-113: LGTM!The JSX structure is clean with good dark mode support, proper loading states, and helpful user guidance.
mobile/api/client.js (1)
118-138: LGTM!The new Splitwise import API functions are well-structured and consistent with the existing client patterns. They correctly use the configured
apiClientwhich already includes the requiredContent-Type: application/jsonheader. The API surface aligns with the web counterpart inweb/services/api.ts.web/pages/SplitwiseImport.tsx (1)
9-25: LGTM!The OAuth flow initiation is clean. The error handling properly displays backend error details and resets loading state on failure. Since
window.location.hrefnavigates away on success, not resettingloadingis acceptable.mobile/screens/SplitwiseImportScreen.js (1)
45-121: LGTM!The UI implementation is well-structured with proper use of react-native-paper components. The informational cards clearly communicate what will be imported and important notes for the user.
backend/app/integrations/router.py (2)
158-243: LGTM!The status endpoint correctly verifies ownership, calculates progress percentages, and provides detailed stage information. The authorization check properly compares user IDs.
246-275: LGTM!The rollback endpoint properly verifies ownership before allowing the operation. The authorization flow is consistent with the status endpoint.
backend/app/integrations/splitwise/client.py (5)
31-56: LGTM!The API wrapper methods are clean pass-throughs to the SDK with appropriate parameter handling.
58-78: LGTM!Defensive attribute access pattern is appropriate for handling SDK object variations.
120-155: LGTM!Group transformation logic is solid. Note that
joinedAtis set to import time rather than the original join date, which is acceptable if the original data isn't available from the SDK.
157-168: LGTM!Robust date handling with appropriate fallbacks for various input types.
173-182: Only the first payer is captured when multiple users contribute.The
breakon line 180 exits after finding the first user withpaidShare > 0. If Splitwise allows multiple payers on a single expense, only the first will be recorded. Verify this matches the expected behavior for multi-payer expenses.backend/app/integrations/schemas.py (6)
12-35: LGTM!Enums are well-defined with appropriate values. Using
str, Enumpattern allows direct JSON serialization.
38-62: LGTM!Well-structured models with sensible defaults for import configuration and error tracking.
64-85: LGTM!Preview schemas are appropriately flexible for the import preview flow.
87-100: LGTM!Request/response models for starting imports are clean and complete.
124-158: LGTM!Summary and job response models are well-structured with appropriate field types.
176-180: Verify OAuth state validation is enforced elsewhere.The
stateparameter inOAuthCallbackRequestis optional, but OAuth state is critical for CSRF protection. Ensure the router or service layer validates state before processing the callback.backend/app/integrations/service.py (3)
22-33: LGTM!Service initialization with MongoDB collections is clean and appropriate. Following coding guidelines, MongoDB is correctly used for persistent storage.
177-247: LGTM!Import orchestration has appropriate error handling with status updates on failure. The sequential approach is reasonable for an initial implementation.
481-519: LGTM!Helper methods are clean and appropriately handle MongoDB operations and ID conversions.
| # Splitwise Integration | ||
| splitwise_api_key: Optional[str] = None | ||
| splitwise_consumer_key: Optional[str] = None | ||
| splitwise_consumer_secret: Optional[str] = None | ||
| frontend_url: str = "http://localhost:5173" # Frontend URL for OAuth redirect | ||
|
|
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
# First, let's explore the backend directory structure
git ls-files backend/app/ | head -20Repository: Devasy/splitwiser
Length of output: 644
🏁 Script executed:
# Read the config.py file to see the actual implementation
cat -n backend/app/config.pyRepository: Devasy/splitwiser
Length of output: 3651
🏁 Script executed:
# Search for RequestResponseLoggingMiddleware to understand logging behavior
fd -t f "*.py" backend/ -x grep -l "RequestResponseLoggingMiddleware"Repository: Devasy/splitwiser
Length of output: 344
🏁 Script executed:
# Search for Splitwise usage throughout the codebase
rg -n "splitwise" --type py -iRepository: Devasy/splitwiser
Length of output: 12475
🏁 Script executed:
# Check if there's URL validation in the router file
cat -n backend/app/integrations/router.py | head -100Repository: Devasy/splitwiser
Length of output: 4161
🏁 Script executed:
# Search for any logging of credentials or sensitive data
rg -n "logger\.|splitwise_consumer|splitwise_api_key|frontend_url" backend/app/integrations/router.pyRepository: Devasy/splitwiser
Length of output: 854
🏁 Script executed:
# Check if there are any pydantic validators in config.py
rg -n "validator|field_validator" backend/app/config.pyRepository: Devasy/splitwiser
Length of output: 43
🏁 Script executed:
# Search for any logging statements that might expose secrets
rg -n "logger\." backend/app/config.py backend/app/integrations/service.py backend/app/integrations/router.pyRepository: Devasy/splitwiser
Length of output: 1184
Add URL validation for frontend_url to prevent OAuth redirect vulnerabilities.
The frontend_url configuration is used directly in OAuth redirect URIs (lines 47 and 81 in router.py) without validation. An attacker could set this to an untrusted domain, creating an open redirect vulnerability. Consider:
- Validating that
frontend_urlmatches an allowed list of origins - Using Pydantic validators in the Settings class to enforce valid URL formats and trusted domains
The RequestResponseLoggingMiddleware is safe—it only logs request/response metadata (method, URL, status, time) and does not expose request bodies or headers containing credentials.
🤖 Prompt for AI Agents
In @backend/app/config.py around lines 36 - 41, The Settings class exposes
frontend_url which is used directly in OAuth redirect URIs (router.py), allowing
an attacker to configure an untrusted domain; add a Pydantic validator on the
Settings model (e.g., validate_frontend_url or a @validator for frontend_url) to
ensure the value is a well-formed URL and matches a whitelist of allowed origins
(or at minimum only allows specific schemes and hostnames), and update any code
paths that consume frontend_url (router functions that build redirect URIs) to
rely on the validated property so untrusted domains cannot be used for
redirects.
| @router.get("/splitwise/authorize") | ||
| async def get_splitwise_oauth_url(current_user=Depends(get_current_user)): | ||
| """ | ||
| Get Splitwise OAuth 2.0 authorization URL. | ||
| Returns the URL where user should be redirected to authorize Splitwiser | ||
| to access their Splitwise data. | ||
| """ | ||
| if not all([settings.splitwise_consumer_key, settings.splitwise_consumer_secret]): | ||
| raise HTTPException( | ||
| status_code=500, | ||
| detail="Splitwise OAuth not configured. Please contact administrator.", | ||
| ) | ||
|
|
||
| # Initialize Splitwise SDK with OAuth credentials | ||
| sObj = Splitwise( | ||
| consumer_key=settings.splitwise_consumer_key, | ||
| consumer_secret=settings.splitwise_consumer_secret, | ||
| ) | ||
|
|
||
| # Get OAuth authorization URL | ||
| # User will be redirected back to: {FRONTEND_URL}/import/splitwise/callback | ||
| auth_url, secret = sObj.getOAuth2AuthorizeURL( | ||
| redirect_uri=f"{settings.frontend_url}/import/splitwise/callback" | ||
| ) | ||
|
|
||
| # Store the secret temporarily (you may want to use Redis/cache instead) | ||
| # For now, we'll include it in the response for the callback to use | ||
| return { | ||
| "authorization_url": auth_url, | ||
| "state": secret, # This will be needed in the callback | ||
| } |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
#!/bin/bash
# Check if state validation exists in the callback or service layer
rg -n "state" backend/app/integrations/ -A 3 -B 1Repository: Devasy/splitwiser
Length of output: 767
🏁 Script executed:
#!/bin/bash
# Search for the callback endpoint
rg -n "splitwise_oauth_callback|callback" backend/app/integrations/ -A 5 -B 2Repository: Devasy/splitwiser
Length of output: 3455
🏁 Script executed:
#!/bin/bash
# Look for all routes in the integrations router
rg -n "@router\." backend/app/integrations/router.pyRepository: Devasy/splitwiser
Length of output: 376
🏁 Script executed:
#!/bin/bash
# Read the complete callback endpoint implementation
sed -n '58,103p' backend/app/integrations/router.pyRepository: Devasy/splitwiser
Length of output: 1618
🏁 Script executed:
#!/bin/bash
# Check if there's any state validation logic in the service layer
rg -n "validate.*state|state.*valid|csrf" backend/app/integrations/Repository: Devasy/splitwiser
Length of output: 43
🏁 Script executed:
#!/bin/bash
# Check for state storage in database, cache, or session
rg -n "state|redis|cache|session" backend/app/integrations/router.py | head -20Repository: Devasy/splitwiser
Length of output: 207
🏁 Script executed:
#!/bin/bash
# Check the full router.py file size and look for any state persistence
wc -l backend/app/integrations/router.pyRepository: Devasy/splitwiser
Length of output: 99
Implement OAuth state validation to prevent CSRF attacks.
The state parameter returned to the client is not validated in the callback endpoint. The callback accepts state in the request but never compares it against the original value. Implement state storage (Redis, session, or database) during the authorize request and validate the returned state matches the stored value before processing the token exchange. This is a required security measure for OAuth 2.0.
🧰 Tools
🪛 Ruff (0.14.10)
25-25: Unused function argument: current_user
(ARG001)
25-25: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
🤖 Prompt for AI Agents
In @backend/app/integrations/router.py around lines 24 - 55,
get_splitwise_oauth_url currently returns the OAuth state secret to the client
without server-side storage; store the generated `secret` server-side (e.g.,
Redis or DB) keyed by the current user id (use the same
`current_user=Depends(get_current_user)` value) before returning the
`authorization_url` and return only a non-sensitive reference if needed. In the
Splitwise callback handler (the endpoint that accepts `state` and exchanges the
token, e.g., your callback function), fetch the stored state by the same user
key, compare it to the incoming `state`, reject the request with an HTTP 400/401
if they don’t match, and only then proceed to exchange the token; finally
delete/expire the stored state after validation. Ensure you reference
`get_splitwise_oauth_url`, the callback handler name, and the `state`/`secret`
symbols when making these changes.
| except Exception as e: | ||
| raise HTTPException( | ||
| status_code=400, detail=f"Failed to exchange OAuth code: {str(e)}" | ||
| ) |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Use exception chaining for proper error context.
Re-raising without from e or from None obscures the original traceback. This makes debugging harder and is flagged by Ruff (B904).
♻️ Proposed fix
except Exception as e:
raise HTTPException(
- status_code=400, detail=f"Failed to exchange OAuth code: {str(e)}"
- )
+ status_code=400, detail=f"Failed to exchange OAuth code: {e!s}"
+ ) from e🧰 Tools
🪛 Ruff (0.14.10)
98-98: Do not catch blind exception: Exception
(BLE001)
99-101: Within an except clause, raise exceptions with raise ... from err or raise ... from None to distinguish them from errors in exception handling
(B904)
100-100: Use explicit conversion flag
Replace with conversion flag
(RUF010)
🤖 Prompt for AI Agents
In @backend/app/integrations/router.py around lines 98 - 101, In the except
block that catches Exception as e in backend/app/integrations/router.py (the
block that raises HTTPException with detail "Failed to exchange OAuth code"),
re-raise the HTTPException using exception chaining by adding "from e" to
preserve the original traceback (i.e., raise HTTPException(...) from e) so the
original exception context is not lost.
| except Exception as e: | ||
| raise HTTPException( | ||
| status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, | ||
| detail=f"Failed to start import: {str(e)}", | ||
| ) |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Use exception chaining here as well.
Same issue as the callback endpoint—chain the exception for proper traceback context.
♻️ Proposed fix
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to start import: {str(e)}",
- )
+ detail=f"Failed to start import: {e!s}",
+ ) from e📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| except Exception as e: | |
| raise HTTPException( | |
| status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, | |
| detail=f"Failed to start import: {str(e)}", | |
| ) | |
| except Exception as e: | |
| raise HTTPException( | |
| status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, | |
| detail=f"Failed to start import: {e!s}", | |
| ) from e |
🧰 Tools
🪛 Ruff (0.14.10)
151-151: Do not catch blind exception: Exception
(BLE001)
152-155: Within an except clause, raise exceptions with raise ... from err or raise ... from None to distinguish them from errors in exception handling
(B904)
154-154: Use explicit conversion flag
Replace with conversion flag
(RUF010)
🤖 Prompt for AI Agents
In @backend/app/integrations/router.py around lines 151 - 155, The HTTPException
raised in the except block that handles import startup failures should use
exception chaining to preserve the original traceback; update the raise of
HTTPException (the one with status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
and detail=f"Failed to start import: {str(e)}") to re-raise the HTTPException
using "from e" so the original exception e is chained to the HTTPException.
| <Route path="/import/splitwise" element={<ProtectedRoute><SplitwiseImport /></ProtectedRoute>} /> | ||
| <Route path="/import/splitwise/callback" element={<ProtectedRoute><SplitwiseCallback /></ProtectedRoute>} /> |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
# First, let's explore the repository structure and locate the relevant files
git ls-files | grep -E "(App\.tsx|SplitwiseCallback\.tsx)" | head -20Repository: Devasy/splitwiser
Length of output: 104
🏁 Script executed:
# List files in the web directory to understand the structure
fd -t f "\.tsx$" | grep -E "(App|Splitwise)" | head -20Repository: Devasy/splitwiser
Length of output: 134
🏁 Script executed:
# Read App.tsx with line numbers, focusing on the route area
cat -n web/App.tsx | sed -n '40,50p'Repository: Devasy/splitwiser
Length of output: 871
🏁 Script executed:
# Read SplitwiseCallback.tsx to examine the useEffect structure
cat -n web/pages/SplitwiseCallback.tsxRepository: Devasy/splitwiser
Length of output: 5305
OAuth callback route should not be protected, and useEffect cleanup is incorrectly implemented.
The /import/splitwise/callback route is wrapped in ProtectedRoute, which redirects unauthenticated users to /login. If the user's session expires during the OAuth flow, they'll lose the authorization code from the URL parameters and the flow will break.
Additionally, in SplitwiseCallback.tsx, the cleanup function at line 63 is incorrectly placed inside the async handleCallback function rather than being returned from the useEffect itself. This means the cleanup function is never executed—the interval won't be cleared on component unmount, causing memory leaks and potential multiple intervals running simultaneously.
| { | ||
| title: 'Import', | ||
| items: [ | ||
| { label: 'Import from Splitwise', icon: Settings, onClick: () => navigate('/import/splitwise'), desc: 'Import all your Splitwise data' }, | ||
| ] | ||
| }, |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Consider using a more descriptive icon for the Import action.
The implementation is correct and follows the existing menu pattern. However, the Settings icon is reused here, which may cause visual confusion with the "Appearance" item in the App section. Consider using a more semantically appropriate icon like Download or ArrowDownToLine from lucide-react.
💡 Suggested icon change
-import { Camera, ChevronRight, CreditCard, LogOut, Mail, MessageSquare, Settings, Shield, User } from 'lucide-react';
+import { Camera, ChevronRight, CreditCard, Download, LogOut, Mail, MessageSquare, Settings, Shield, User } from 'lucide-react'; {
title: 'Import',
items: [
- { label: 'Import from Splitwise', icon: Settings, onClick: () => navigate('/import/splitwise'), desc: 'Import all your Splitwise data' },
+ { label: 'Import from Splitwise', icon: Download, onClick: () => navigate('/import/splitwise'), desc: 'Import all your Splitwise data' },
]
},🤖 Prompt for AI Agents
In @web/pages/Profile.tsx around lines 111 - 116, The Import menu entry
currently reuses the Settings icon which can confuse users; update the items
array for the menu object with title 'Import' to use a more semantically
appropriate icon (e.g., replace Settings with Download or ArrowDownToLine from
lucide-react) for the item whose onClick navigates to '/import/splitwise' so the
entry visually indicates importing/download rather than settings.
web/pages/SplitwiseCallback.tsx
Outdated
| useEffect(() => { | ||
| const handleCallback = async () => { | ||
| const code = searchParams.get('code'); | ||
| const state = searchParams.get('state'); | ||
|
|
||
| if (!code) { | ||
| showToast('Authorization failed - no code received', 'error'); | ||
| navigate('/import/splitwise'); | ||
| return; | ||
| } | ||
|
|
||
| try { | ||
| // Send code to backend to exchange for access token and start import | ||
| const response = await handleSplitwiseCallback(code, state || ''); | ||
| const jobId = response.data.import_job_id || response.data.importJobId; | ||
|
|
||
| if (!jobId) { | ||
| throw new Error('No import job ID received'); | ||
| } | ||
|
|
||
| showToast('Authorization successful! Starting import...', 'success'); | ||
| setStatus('Import started...'); | ||
|
|
||
| // Poll for progress | ||
| const pollInterval = setInterval(async () => { | ||
| try { | ||
| const statusResponse = await getImportStatus(jobId); | ||
| const statusData = statusResponse.data; | ||
|
|
||
| setProgress(statusData.progress_percentage || 0); | ||
| setStatus(statusData.current_stage || 'Processing...'); | ||
|
|
||
| if (statusData.status === 'completed') { | ||
| clearInterval(pollInterval); | ||
| setImporting(false); | ||
| showToast('Import completed successfully!', 'success'); | ||
| setStatus('Completed! Redirecting to dashboard...'); | ||
| setTimeout(() => navigate('/dashboard'), 2000); | ||
| } else if (statusData.status === 'failed') { | ||
| clearInterval(pollInterval); | ||
| setImporting(false); | ||
| showToast('Import failed', 'error'); | ||
| setStatus(`Failed: ${statusData.error_details || 'Unknown error'}`); | ||
| } | ||
| } catch (error) { | ||
| console.error('Error polling import status:', error); | ||
| } | ||
| }, 2000); | ||
|
|
||
| return () => clearInterval(pollInterval); | ||
| } catch (error: any) { | ||
| console.error('Callback error:', error); | ||
| showToast( | ||
| error.response?.data?.detail || 'Failed to process authorization', | ||
| 'error' | ||
| ); | ||
| setImporting(false); | ||
| setTimeout(() => navigate('/import/splitwise'), 2000); | ||
| } | ||
| }; | ||
|
|
||
| handleCallback(); | ||
| }, [searchParams, navigate, showToast]); |
There was a problem hiding this comment.
Memory leak: interval cleanup function is unreachable.
The return () => clearInterval(pollInterval) on line 63 is inside the async handleCallback function. This return value is ignored—React's useEffect cleanup only works from the direct return of the effect callback, not from a nested async function. If the component unmounts while polling, the interval will continue running.
🔧 Proposed fix
export const SplitwiseCallback = () => {
const [searchParams] = useSearchParams();
const navigate = useNavigate();
const { showToast } = useToast();
const [status, setStatus] = useState('Processing authorization...');
const [progress, setProgress] = useState(0);
const [importing, setImporting] = useState(true);
+ const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
useEffect(() => {
const handleCallback = async () => {
const code = searchParams.get('code');
const state = searchParams.get('state');
if (!code) {
showToast('Authorization failed - no code received', 'error');
navigate('/import/splitwise');
return;
}
try {
const response = await handleSplitwiseCallback(code, state || '');
const jobId = response.data.import_job_id || response.data.importJobId;
if (!jobId) {
throw new Error('No import job ID received');
}
showToast('Authorization successful! Starting import...', 'success');
setStatus('Import started...');
- const pollInterval = setInterval(async () => {
+ pollIntervalRef.current = setInterval(async () => {
try {
const statusResponse = await getImportStatus(jobId);
const statusData = statusResponse.data;
setProgress(statusData.progress_percentage || 0);
setStatus(statusData.current_stage || 'Processing...');
if (statusData.status === 'completed') {
- clearInterval(pollInterval);
+ if (pollIntervalRef.current) clearInterval(pollIntervalRef.current);
setImporting(false);
showToast('Import completed successfully!', 'success');
setStatus('Completed! Redirecting to dashboard...');
setTimeout(() => navigate('/dashboard'), 2000);
} else if (statusData.status === 'failed') {
- clearInterval(pollInterval);
+ if (pollIntervalRef.current) clearInterval(pollIntervalRef.current);
setImporting(false);
showToast('Import failed', 'error');
setStatus(`Failed: ${statusData.error_details || 'Unknown error'}`);
}
} catch (error) {
console.error('Error polling import status:', error);
}
}, 2000);
-
- return () => clearInterval(pollInterval);
} catch (error: any) {
console.error('Callback error:', error);
showToast(
error.response?.data?.detail || 'Failed to process authorization',
'error'
);
setImporting(false);
setTimeout(() => navigate('/import/splitwise'), 2000);
}
};
handleCallback();
+
+ return () => {
+ if (pollIntervalRef.current) {
+ clearInterval(pollIntervalRef.current);
+ }
+ };
}, [searchParams, navigate, showToast]);Also add useRef to the import on line 1:
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| useEffect(() => { | |
| const handleCallback = async () => { | |
| const code = searchParams.get('code'); | |
| const state = searchParams.get('state'); | |
| if (!code) { | |
| showToast('Authorization failed - no code received', 'error'); | |
| navigate('/import/splitwise'); | |
| return; | |
| } | |
| try { | |
| // Send code to backend to exchange for access token and start import | |
| const response = await handleSplitwiseCallback(code, state || ''); | |
| const jobId = response.data.import_job_id || response.data.importJobId; | |
| if (!jobId) { | |
| throw new Error('No import job ID received'); | |
| } | |
| showToast('Authorization successful! Starting import...', 'success'); | |
| setStatus('Import started...'); | |
| // Poll for progress | |
| const pollInterval = setInterval(async () => { | |
| try { | |
| const statusResponse = await getImportStatus(jobId); | |
| const statusData = statusResponse.data; | |
| setProgress(statusData.progress_percentage || 0); | |
| setStatus(statusData.current_stage || 'Processing...'); | |
| if (statusData.status === 'completed') { | |
| clearInterval(pollInterval); | |
| setImporting(false); | |
| showToast('Import completed successfully!', 'success'); | |
| setStatus('Completed! Redirecting to dashboard...'); | |
| setTimeout(() => navigate('/dashboard'), 2000); | |
| } else if (statusData.status === 'failed') { | |
| clearInterval(pollInterval); | |
| setImporting(false); | |
| showToast('Import failed', 'error'); | |
| setStatus(`Failed: ${statusData.error_details || 'Unknown error'}`); | |
| } | |
| } catch (error) { | |
| console.error('Error polling import status:', error); | |
| } | |
| }, 2000); | |
| return () => clearInterval(pollInterval); | |
| } catch (error: any) { | |
| console.error('Callback error:', error); | |
| showToast( | |
| error.response?.data?.detail || 'Failed to process authorization', | |
| 'error' | |
| ); | |
| setImporting(false); | |
| setTimeout(() => navigate('/import/splitwise'), 2000); | |
| } | |
| }; | |
| handleCallback(); | |
| }, [searchParams, navigate, showToast]); | |
| import { useEffect, useRef, useState } from 'react'; | |
| export const SplitwiseCallback = () => { | |
| const [searchParams] = useSearchParams(); | |
| const navigate = useNavigate(); | |
| const { showToast } = useToast(); | |
| const [status, setStatus] = useState('Processing authorization...'); | |
| const [progress, setProgress] = useState(0); | |
| const [importing, setImporting] = useState(true); | |
| const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null); | |
| useEffect(() => { | |
| const handleCallback = async () => { | |
| const code = searchParams.get('code'); | |
| const state = searchParams.get('state'); | |
| if (!code) { | |
| showToast('Authorization failed - no code received', 'error'); | |
| navigate('/import/splitwise'); | |
| return; | |
| } | |
| try { | |
| // Send code to backend to exchange for access token and start import | |
| const response = await handleSplitwiseCallback(code, state || ''); | |
| const jobId = response.data.import_job_id || response.data.importJobId; | |
| if (!jobId) { | |
| throw new Error('No import job ID received'); | |
| } | |
| showToast('Authorization successful! Starting import...', 'success'); | |
| setStatus('Import started...'); | |
| // Poll for progress | |
| pollIntervalRef.current = setInterval(async () => { | |
| try { | |
| const statusResponse = await getImportStatus(jobId); | |
| const statusData = statusResponse.data; | |
| setProgress(statusData.progress_percentage || 0); | |
| setStatus(statusData.current_stage || 'Processing...'); | |
| if (statusData.status === 'completed') { | |
| if (pollIntervalRef.current) clearInterval(pollIntervalRef.current); | |
| setImporting(false); | |
| showToast('Import completed successfully!', 'success'); | |
| setStatus('Completed! Redirecting to dashboard...'); | |
| setTimeout(() => navigate('/dashboard'), 2000); | |
| } else if (statusData.status === 'failed') { | |
| if (pollIntervalRef.current) clearInterval(pollIntervalRef.current); | |
| setImporting(false); | |
| showToast('Import failed', 'error'); | |
| setStatus(`Failed: ${statusData.error_details || 'Unknown error'}`); | |
| } | |
| } catch (error) { | |
| console.error('Error polling import status:', error); | |
| } | |
| }, 2000); | |
| } catch (error: any) { | |
| console.error('Callback error:', error); | |
| showToast( | |
| error.response?.data?.detail || 'Failed to process authorization', | |
| 'error' | |
| ); | |
| setImporting(false); | |
| setTimeout(() => navigate('/import/splitwise'), 2000); | |
| } | |
| }; | |
| handleCallback(); | |
| return () => { | |
| if (pollIntervalRef.current) { | |
| clearInterval(pollIntervalRef.current); | |
| } | |
| }; | |
| }, [searchParams, navigate, showToast]); |
web/pages/SplitwiseImport.tsx
Outdated
| <button | ||
| onClick={handleOAuthImport} | ||
| disabled={loading} | ||
| className="w-full py-4 px-6 bg-blue-500 hover:bg-blue-600 text-white font-semibold | ||
| rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed | ||
| disabled:hover:bg-blue-500 shadow-lg hover:shadow-xl flex items-center justify-center gap-2" | ||
| > | ||
| {loading ? ( | ||
| <> | ||
| <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-white"></div> | ||
| <span>Connecting to Splitwise...</span> | ||
| </> | ||
| ) : ( | ||
| <> | ||
| <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20"> | ||
| <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" /> | ||
| </svg> | ||
| <span>Connect with Splitwise & Import</span> | ||
| </> | ||
| )} | ||
| </button> |
There was a problem hiding this comment.
Fix accessibility issues: missing button type and SVG title.
Two accessibility issues flagged by static analysis:
- The button lacks an explicit
typeattribute. Default is"submit", which can cause unintended form submissions. - The SVG icon lacks alternative text for screen readers.
♿ Proposed fix
<button
+ type="button"
onClick={handleOAuthImport}
disabled={loading}
className="w-full py-4 px-6 bg-blue-500 hover:bg-blue-600 text-white font-semibold
rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed
disabled:hover:bg-blue-500 shadow-lg hover:shadow-xl flex items-center justify-center gap-2"
>
{loading ? (
<>
<div className="animate-spin rounded-full h-5 w-5 border-b-2 border-white"></div>
<span>Connecting to Splitwise...</span>
</>
) : (
<>
- <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20">
+ <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20" aria-hidden="true">
<path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" />
</svg>
<span>Connect with Splitwise & Import</span>
</>
)}
</button>📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| <button | |
| onClick={handleOAuthImport} | |
| disabled={loading} | |
| className="w-full py-4 px-6 bg-blue-500 hover:bg-blue-600 text-white font-semibold | |
| rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed | |
| disabled:hover:bg-blue-500 shadow-lg hover:shadow-xl flex items-center justify-center gap-2" | |
| > | |
| {loading ? ( | |
| <> | |
| <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-white"></div> | |
| <span>Connecting to Splitwise...</span> | |
| </> | |
| ) : ( | |
| <> | |
| <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20"> | |
| <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" /> | |
| </svg> | |
| <span>Connect with Splitwise & Import</span> | |
| </> | |
| )} | |
| </button> | |
| <button | |
| type="button" | |
| onClick={handleOAuthImport} | |
| disabled={loading} | |
| className="w-full py-4 px-6 bg-blue-500 hover:bg-blue-600 text-white font-semibold | |
| rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed | |
| disabled:hover:bg-blue-500 shadow-lg hover:shadow-xl flex items-center justify-center gap-2" | |
| > | |
| {loading ? ( | |
| <> | |
| <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-white"></div> | |
| <span>Connecting to Splitwise...</span> | |
| </> | |
| ) : ( | |
| <> | |
| <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20" aria-hidden="true"> | |
| <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" /> | |
| </svg> | |
| <span>Connect with Splitwise & Import</span> | |
| </> | |
| )} | |
| </button> |
🧰 Tools
🪛 Biome (2.1.2)
[error] 55-55: Alternative text title element cannot be empty
For accessibility purposes, SVGs should have an alternative text, provided via title element. If the svg element has role="img", you should add the aria-label or aria-labelledby attribute.
(lint/a11y/noSvgWithoutTitle)
[error] 41-47: Provide an explicit type prop for the button element.
The default type of a button is submit, which causes the submission of a form when placed inside a form element. This is likely not the behaviour that you want inside a React application.
Allowed button types are: submit, button or reset
(lint/a11y/useButtonType)
🤖 Prompt for AI Agents
In @web/pages/SplitwiseImport.tsx around lines 41 - 61, The button element that
invokes handleOAuthImport is missing an explicit type (so it defaults to
"submit") and the SVG lacks accessible text; change the button to include
type="button" to prevent unintended form submissions and update the SVG used in
the non-loading branch to provide accessible alternative text (e.g., add a
<title> like "Splitwise icon" and ensure the SVG has role="img" or an
aria-label) so screen readers announce the icon; keep the loading spinner
decorative (e.g., aria-hidden="true") while the non-loading SVG provides a
proper accessible name.
… and settlements.
|
@coderabbitai review the frontend changes critically, as they don't match the theme, fonts, or vibe of the overall app |
|
Tip For best results, initiate chat on the files or code changes. 🧩 Analysis chain🏁 Script executed: Length of output: 18950 🏁 Script executed: Length of output: 2972 🏁 Script executed: Length of output: 119 🏁 Script executed: Length of output: 21866 🏁 Script executed: Length of output: 13933
🔴 Mobile App Issues (React Native)SplitwiseImportScreen.js breaks the app's minimal, theme-driven aesthetic: Problem 1: Hardcoded Colors// ❌ Current - Hardcoded colors that don't respect theme
infoCard: {
marginBottom: 16,
backgroundColor: "#E3F2FD", // Hardcoded blue
},
warningCard: {
marginBottom: 16,
backgroundColor: "#FFF3E0", // Hardcoded orange
},The existing AccountScreen.js doesn't use any custom background colors - it relies entirely on the Paper theme system for consistency. Problem 2: Over-Styled CardsThe info and warning cards with colored backgrounds and manual styling are inconsistent with the clean, minimal design pattern used throughout the mobile app. Compare with AccountScreen's simple Recommendation: Remove colored background cards, use Paper's theme colors, and adopt the simpler List.Item pattern seen in AccountScreen. 🔴 Web App Issues (React + Tailwind)SplitwiseImport.tsx ✅Actually quite good! This page properly implements:
SplitwiseCallback.tsx ❌This is the major problem - it completely ignores the app's design language: // ❌ Current - Generic, no theme awareness
<div className="max-w-md w-full bg-white dark:bg-gray-800 rounded-lg shadow-lg p-8">
<h2 className="text-2xl font-bold text-gray-900 dark:text-white mb-2">Compare with Profile.tsx and Groups.tsx patterns: // ✅ Expected - Bold, theme-aware, immersive
<motion.div
initial={{ y: 20, opacity: 0 }}
animate={{ y: 0, opacity: 1 }}
className={`${isNeo
? 'bg-white border-4 border-black shadow-[8px_8px_0px_0px_rgba(0,0,0,1)]'
: 'bg-white dark:bg-gray-800 rounded-xl shadow-lg'}`}
>Missing Elements in SplitwiseCallback.tsx:
Example Fix Needed:// The progress bar should be theme-aware:
<div className={`w-full h-3 ${isNeo ? 'bg-gray-200 border-2 border-black' : 'bg-gray-200 dark:bg-gray-700 rounded-full'}`}>
<div
className={`h-3 transition-all duration-300 ${isNeo
? 'bg-blue-500 border-r-2 border-black'
: 'bg-blue-500 rounded-full'}`}
style={{ width: `${progress}%` }}
/>
</div>SummaryMobile: Needs to adopt the minimal, theme-driven approach. Remove hardcoded colors and custom card backgrounds. Web: SplitwiseCallback.tsx needs a complete redesign to match the app's bold, theme-aware, animated design language. SplitwiseImport.tsx is acceptable as-is. Would you like me to generate updated code for these components that properly matches your app's theme and vibe? |
There was a problem hiding this comment.
Actionable comments posted: 32
Caution
Some comments are outside the diff and can’t be posted inline due to platform limitations.
⚠️ Outside diff range comments (6)
backend/tests/expenses/test_expense_service.py (1)
248-256: Fix payer/payee expectations in advanced settlement test (CI failure).The setup implies Charlie pays Alice after optimization (C owes B, B owes A ⇒ C owes A). CI already reports
fromUserNameas “Charlie”. Update the assertions and comment to match the actual optimized flow.🧪 Proposed fix
- # The optimized result should be Alice paying Charlie $100 - # (Alice owes Bob $100, Bob owes Charlie $100 -> Alice owes Charlie $100) + # The optimized result should be Charlie paying Alice $100 + # (Bob owes Alice $100, Charlie owes Bob $100 -> Charlie owes Alice $100) settlement = result[0] assert settlement.amount == 100.0 - assert settlement.fromUserName == "Alice" - assert settlement.toUserName == "Charlie" - assert settlement.fromUserId == str(user_a_id) - assert settlement.toUserId == str(user_c_id) + assert settlement.fromUserName == "Charlie" + assert settlement.toUserName == "Alice" + assert settlement.fromUserId == str(user_c_id) + assert settlement.toUserId == str(user_a_id)web/pages/GroupDetails.tsx (1)
95-110: Consider extracting default ID initialization to avoid potential re-render cycles.The dependency array includes
payerId,paymentPayerId, andpaymentPayeeId, but the effect only sets these when they're falsy. While the conditionals prevent infinite loops, this pattern can be simplified.The current implementation is functional, but consider initializing these defaults only once when members load, rather than on every change.
backend/app/expenses/schemas.py (1)
214-219: Inconsistent currency type inBalanceSummaryResponse.This schema still uses
strfor currency while other schemas now use theCurrencyenum. Consider updating for consistency.Suggested fix
class BalanceSummaryResponse(BaseModel): totalOwedToYou: float totalYouOwe: float netBalance: float - currency: str = "USD" + currency: Currency = Currency.USD groupsSummary: List[Dict[str, Any]]backend/app/expenses/service.py (3)
57-83: Normalize payer membership checks for mixed ID types.The access query accepts both ObjectId and string IDs, but the payer membership check still compares raw values. This can reject valid payers when member IDs are stored as ObjectIds.
🛠️ Suggested fix
- payer_is_member = any( - member.get("userId") == expense_data.paidBy - for member in group.get("members", []) - ) + paid_by = str(expense_data.paidBy) + payer_is_member = any( + str(member.get("userId")) == paid_by + for member in group.get("members", []) + )
1055-1094: Normalize member IDs when building friend lists.With ObjectId-compatible members, comparing raw IDs can include the current user as a “friend” and feed ObjectIds into settlement matching. Normalize to strings before comparisons and
$inlists.🛠️ Suggested fix
- friend_ids_in_groups = set() + friend_ids_in_groups = set() + user_id_str = str(user_id) for group in groups: for member in group["members"]: - if member["userId"] != user_id: - friend_ids_in_groups.add(member["userId"]) + member_id = str(member["userId"]) + if member_id != user_id_str: + friend_ids_in_groups.add(member_id)
949-977: Balance aggregations still use the old payer/payee semantics.
payerIdnow represents the debtor, but these pipelines treat payer as “paid” and payee as “owed,” which flips net balances. Swap the aggregation roles (or rename fields) so net balance uses creditor minus debtor in both summaries.🛠️ Suggested fix (apply to both pipelines)
- "totalPaid": { + "totalOwedByUser": { "$sum": { "$cond": [ {"$eq": ["$payerId", target_user_id]}, "$amount", 0, ] } }, - "totalOwed": { + "totalOwedToUser": { "$sum": { "$cond": [ {"$eq": ["$payeeId", target_user_id]}, "$amount", 0, ] } },- total_paid = balance_data["totalPaid"] - total_owed = balance_data["totalOwed"] - net_balance = total_paid - total_owed + total_owed_by = balance_data["totalOwedByUser"] + total_owed_to = balance_data["totalOwedToUser"] + net_balance = total_owed_to - total_owed_byAlso applies to: 1278-1297
🤖 Fix all issues with AI agents
In `@backend/app/auth/service.py`:
- Around line 264-266: Replace the logger.info call that currently logs the
user's email (the f"Activating placeholder account for {email} via Google auth"
message) with a privacy-safe message that avoids PII; e.g., log a generic event
and, if needed, include a non-sensitive identifier (like user_id or
hashed/email-redaction) instead of the raw email in the activation flow where
the logger.info is invoked.
- Line 110: The log statement logger.info(f"Linking signup to placeholder
account for {email}") exposes PII; update the call to avoid logging the raw
email by using a non-PII identifier (e.g., user_id if available) or a masked
email representation (e.g., mask_email(email)) before logging, and ensure the
change is applied where the logging occurs (search for logger.info and the email
variable in auth/service.py, e.g., inside the signup/linking function) so logs
contain only the safe identifier.
- Line 119: Replace the inconsistent timestamp field in the email signup flow by
adding or renaming the placeholder timestamp to "activated_at" so it matches the
Google auth path; specifically change the object that currently sets
"created_at": datetime.now(timezone.utc) to set "activated_at":
datetime.now(timezone.utc) (or include both fields if "created_at" is needed
elsewhere) so both flows use the "activated_at" symbol consistently for
activation timestamps.
- Around line 115-127: The code calls get_password_hash(password) twice causing
mismatched bcrypt hashes; compute hashed_password = get_password_hash(password)
once and reuse that variable in the DB update payload and when setting
existing_user["hashed_password"] (and anywhere else the new hash is needed) so
the stored and returned hashed_password are identical; update references in the
update operation and the existing_user assignments (get_password_hash,
existing_user["hashed_password"], the DB update payload) to use the single
hashed_password variable.
- Around line 277-285: The try/except around db.users.update_one and user.update
currently swallows PyMongoError and allows the flow to continue issuing a
refresh token with an inconsistent user state; change the except handler in the
block containing db.users.update_one and user.update (catching PyMongoError as
e) to log the error and then re-raise the exception (or return an explicit error
response) so execution stops and no refresh token is issued when activation
fails, ensuring the caller sees the failure instead of proceeding with a
placeholder account.
In `@backend/app/expenses/service.py`:
- Around line 544-548: The code fetches all settlements (settlements = await
self.settlements_collection.find({"groupId": group_id}).to_list(None)) which
includes completed/paid records; update both places where settlements are
queried (used by _calculate_normal_settlements() and
_calculate_advanced_settlements()) to only fetch pending obligations by adding
the appropriate status filter (e.g., include "status": "pending" or the
equivalent pending statuses used elsewhere) to the find() query so that only
unsettled obligations are included in the net balance calculations.
In `@backend/app/groups/service.py`:
- Around line 176-180: The try/except around converting user_id to ObjectId uses
a bare except; change it to catch the specific invalid ObjectId error (e.g.,
catch bson.errors.InvalidId or errors.InvalidId) so only conversion failures are
handled, e.g., use "except InvalidId:" (after importing InvalidId from
bson.errors) and keep the existing fallback assignment to user_obj_id = user_id;
ensure you do not swallow other exceptions like KeyboardInterrupt/SystemExit by
avoiding a bare except or broad Exception unless intentionally required.
- Around line 213-218: Replace the bare except around the ObjectId conversion
with a specific exception catch: import InvalidId from bson.errors and change
the block that sets user_obj_id (the ObjectId(user_id) conversion) to catch
InvalidId (and optionally ValueError/TypeError) instead of a bare except, so
invalid or non-convertible user_id falls back to the original value without
swallowing unrelated errors.
In `@backend/app/integrations/router.py`:
- Around line 88-93: The print statements in the OAuth handler are leaking
sensitive data (request.accessToken and request.code); remove these prints and
instead use the configured logger at DEBUG level (e.g., logger.debug) and never
log full secrets—either omit the token/code entirely or log a redacted snippet
(e.g., show only first/last few chars or a boolean indicating presence). Update
the statements around request.accessToken and request.code in the OAuth exchange
flow in router.py (the block that prints "Using stored access token" and
"Attempting OAuth token exchange...") to use logger.debug with redaction or
presence-only messages, and apply the same change to the other occurrence noted
in the review.
In `@backend/app/integrations/schemas.py`:
- Around line 192-197: Add a post-validation method to OAuthCallbackRequest to
enforce that either both code and state are provided (OAuth flow) or accessToken
is provided (token flow); implement a pydantic model_validator (e.g.,
check_required_fields) on OAuthCallbackRequest that checks (self.code and
self.state) or self.accessToken and raises a ValueError with a clear message if
neither combination is present.
- Around line 5-9: Replace deprecated typing generics with Python 3.9+ built-in
generics: remove or stop using Dict, List (and optionally Any/Optional) from the
typing imports at the top and update all type hints in this module (e.g., where
you use Dict[str, Any], List[str], Optional[Foo]) to dict[str, Any], list[str],
and Foo | None (or keep Optional[Foo] if you prefer), respectively; ensure the
imports at the top only include symbols you still use (e.g., keep Enum,
datetime, BaseModel, Field) and run a quick type-check to confirm no remaining
typing.* usages remain.
- Around line 55-63: Remove the unused fields confirmWarnings and
acknowledgeWarnings from the ImportOptions Pydantic model (class ImportOptions)
by deleting their declarations; ensure you only keep relevant fields like
importReceipts, importComments, importArchivedExpenses and selectedGroupIds,
search the codebase for any remaining references to confirmWarnings or
acknowledgeWarnings and remove or refactor them accordingly, and run/update
tests/serializations that consume ImportOptions to reflect the schema change.
In `@backend/app/integrations/service.py`:
- Around line 530-538: The placeholder user creation uses member.get("name")
which is never populated; update the placeholder construction (placeholder_id
and placeholder_user) to build the "name" from member.get("firstName") and
member.get("lastName") (e.g., join non-empty parts with a space), falling back
to member.get("name") and finally "Unknown User" if none exist; keep the other
fields (email, imageUrl) unchanged so placeholder_user still contains "_id",
"email", and "imageUrl".
In `@backend/migrations/003_add_currency_to_groups.py`:
- Around line 67-99: The verify_migration function currently logs exceptions and
swallows them; align its behavior with add_currency_to_groups by re-raising the
exception after logging so callers can detect failures. In verify_migration,
after logger.error(f"❌ Verification failed: {str(e)}") ensure the exception is
re-thrown (e.g., raise) so the caller sees the failure, preserving the existing
log; this mirrors add_currency_to_groups exception handling and prevents silent
verification failures.
In `@backend/migrations/004_fix_member_userid_format.py`:
- Around line 44-96: The current migration iterates groups_collection and
performs await groups_collection.update_one(...) per document (see update_one,
updated_members, needs_update, update_doc), which is inefficient; change it to
accumulate UpdateOne operations into a list (using pymongo.operations.UpdateOne)
and call groups_collection.bulk_write(ops, ordered=False) in batches (e.g.,
500-1000 ops), flushing the batch when it reaches the threshold and after the
loop, and keep logging updated_count accordingly so the behavior of createdBy
conversion and joinedAt fixes remains the same.
- Around line 74-81: The migration currently reconstructs member documents into
updated_members by creating a new dict with only "userId", "name", "email", and
"joinedAt", which drops any other fields; instead, clone the original member
dict (e.g., make a shallow copy of member) and then set/override the normalized
"userId" and "joinedAt" values so existing fields like "avatarUrl", "role", or
custom metadata are preserved; update the code around updated_members, user_id,
and member to merge rather than rebuild each member object.
In `@backend/tests/test_settlement_calculation.py`:
- Around line 289-395: The ins_valsura_scenario fixture contains unfinished
inline debugging comments and an inconsistent set of transactions that don't
produce the docstring's stated balances; update the ins_valsura_scenario fixture
to either (A) remove the incomplete debug comments (the block after the Dwij
expense and the "Wait, let me recalculate..." notes) and ensure the existing
transactions match the docstring, or (B) replace the scenario with the correct
transactions that net Devasy +78.62 and Dwij -78.62 (or delete the fixture if
redundant with simple_debt_scenario); locate and edit the ins_valsura_scenario
fixture and the trailing comment block around the Payment 3 / recalculation
notes to perform the chosen cleanup.
- Around line 937-941: The floating-point assertions for settlement balances are
using a looser tolerance (0.1) compared to the rest of the tests; update the
three assertions that reference balances.get("devasy"), balances.get("dwij"),
and the zero checks for balances.get("deep") and balances.get("yaksh") to use
the tighter tolerance 0.01 (consistent with other tests) so precision is
enforced uniformly across tests.
- Around line 20-21: Replace deprecated typing generics with Python 3.9+
built-in generics: remove Any, Dict, List, Tuple from the typing import and
update all type annotations in this test file (e.g., change Dict[str, Any] →
dict[str, Any], List[Dict[str, Any]] → list[dict[str, Any]],
Tuple[List[Dict[str, Any]], Dict[str, float]] → tuple[list[dict[str, float]],
dict[str, float]]); keep the existing collections import (defaultdict) and
update any function signatures, return annotations, and local variable type
hints that reference typing.Dict/typing.List/typing.Tuple/typing.Any accordingly
(search for usages of Dict, List, Tuple, Any in this file and replace with dict,
list, tuple, Any→object or keep Any from typing if you prefer, but using builtin
generics is required).
In `@backend/tests/test_splitwise_import.py`:
- Around line 65-66: The test uses naive datetimes for self._created_at and
self._updated_at; change the defaults in the constructor (or assignment) to use
timezone-aware datetimes by replacing datetime.now() with
datetime.now(timezone.utc) so the mocked timestamps match the application code's
UTC-aware datetimes (the timezone symbol is already imported); update the
assignments for _created_at and _updated_at accordingly.
- Around line 236-237: The import statement "from test_settlement_calculation
import SettlementCalculator" is incorrect and will fail; update occurrences in
test_splitwise_import.py (and the other two similar spots) to import the class
from the tests package by replacing that line with "from
tests.test_settlement_calculation import SettlementCalculator" so
SettlementCalculator is resolved from the tests module path.
In `@web/pages/GroupDetails.tsx`:
- Around line 985-986: Remove the extra spaces before the closing angle brackets
in the JSX closing tags (change "</Modal >" and "</div >" to "</Modal>" and
"</div>") to match the file's existing formatting style; locate the closing JSX
of the GroupDetails component where Modal and the wrapping div are closed and
update the tags accordingly.
- Around line 896-915: The label for the currency select is not programmatically
associated with the select which hurts accessibility; add a unique id (e.g.,
"group-currency-select") to the select element and set the label's htmlFor to
that id so screen readers correctly link the <label> and <select>; update the
select with id="group-currency-select" and the label with
htmlFor="group-currency-select" near the JSX that uses editGroupCurrency,
setEditGroupCurrency, THEMES.NEOBRUTALISM and the CURRENCIES mapping.
In `@web/pages/Groups.tsx`:
- Around line 258-265: The "Currency" label isn't associated with its <select>,
so add an id to the select used for newGroupCurrency (the element with
value={newGroupCurrency} and onChange={e =>
setNewGroupCurrency(e.target.value)}) and set the label's htmlFor to that id
(the label that currently uses className with isNeo/mode). This ensures the
<label> (text "Currency") is linked to the select control for accessibility.
In `@web/pages/SplitwiseCallback.tsx`:
- Around line 50-52: In the SplitwiseCallback component remove or guard all
debug console.log calls by either deleting them or wrapping each call in an
environment check (e.g., if (process.env.NODE_ENV === 'development') { ... }) or
replacing them with a proper logger utility; specifically update the console.log
usages around the OAuth flow (the calls shown near the token exchange that
reference handleSplitwiseCallback and any other console.log inside the
SplitwiseCallback component) so no debug logs are emitted in production. Ensure
you update all occurrences in that component consistently and prefer using a
centralized logger if available.
- Around line 82-87: The catch block in the SplitwiseCallback component calls
showToast but the hook destructures addToast from useToast(), causing a runtime
error; replace the showToast call with addToast and pass the same message and
severity (e.g., addToast(error.response?.data?.detail || 'Failed to process
authorization', 'error')) so the toast uses the correct function name from
useToast() (ensure the call matches addToast's expected parameters).
In `@web/pages/SplitwiseGroupSelection.tsx`:
- Around line 126-130: The three <button> elements in
SplitwiseGroupSelection.tsx (the one that calls navigate('/import/splitwise')
and the other buttons around the indicated ranges) are missing explicit type
attributes and will default to type="submit"; update those button elements to
include type="button" to prevent unintended form submissions (locate the buttons
by the onClick handlers such as navigate('/import/splitwise') and other onClick
callbacks in the same component and add type="button" to each).
- Line 76: Remove the debug console.log that prints authentication state from
the SplitwiseGroupSelection component (the console.log('Auth token present:',
!!token) call); delete that statement (or replace with a secure, non-sensitive
telemetry/logging mechanism if needed) so no auth presence is exposed in
production.
- Around line 145-147: In the SplitwiseGroupSelection component update the
paragraph text inside the <p> element (the string currently "Your Splitwise
groups are ready. Choose which once to bring to Splitwiser.") to correct the
typo by replacing "once" with "ones" so the copy reads "Choose which ones to
bring to Splitwiser."; locate the <p className={`text-lg font-bold ${isNeo ?
'text-black/70' : 'text-gray-600 dark:text-gray-400'}`}> in
SplitwiseGroupSelection.tsx and change only the displayed string.
- Around line 225-233: The number formatting currently hardcodes the 'en-IN'
locale in the Intl.NumberFormat call inside the SplitwiseGroupSelection
component; change it to use the user's locale (e.g., pass undefined or
navigator.language to Intl.NumberFormat) so formatting follows the browser/user
preferences when rendering group.totalAmount, keeping the same
minimumFractionDigits/maximumFractionDigits options and leaving
getCurrencySymbol and the surrounding JSX unchanged.
In `@web/utils/formatters.ts`:
- Around line 3-5: Replace the unsafe cast in formatCurrency: instead of using
"as any" to index CURRENCIES, introduce/use a CurrencyCode type (e.g., type
CurrencyCode = keyof typeof CURRENCIES) and add a runtime guard that checks the
provided currencyCode is a valid key (e.g., currencyCode in CURRENCIES) before
indexing; default to CURRENCIES.USD when invalid. Update the same pattern used
around lines 14-16 so all CURRENCIES lookups use the keyof type and the runtime
key-check guard (refer to formatCurrency and any other helpers that index
CURRENCIES).
- Around line 6-11: The Intl.NumberFormat call is hardcoded to 'en-IN' causing
Indian digit grouping for all currencies; update the formatter to accept an
optional locale parameter (e.g., locale?: string) or derive a locale from the
currency (map currency.code -> locale) and use that when constructing new
Intl.NumberFormat, falling back to the runtime default (omit locale or use
navigator.language/Intl.DateTimeFormat().resolvedOptions().locale) if none
provided; adjust the function signature that uses amount and currency to pass
the locale through and ensure currency.code remains used for the currency
option.
♻️ Duplicate comments (20)
web/services/api.ts (1)
118-118: UnusedapiKeyparameter—backend ignores it.The
/import/splitwise/startendpoint doesn't use theapiKeyfrom the request body. The backend retrieves credentials from environment config instead. Either remove this parameter or update the backend to accept it.web/pages/SplitwiseImport.tsx (2)
57-64: Addtype="button"to prevent unintended form submissions.The button lacks an explicit type attribute.
♿ Proposed fix
<button + type="button" onClick={handleOAuthImport} disabled={loading}
89-91: Add accessible text to decorative SVGs.The SVG icons lack alternative text for screen readers. Add
aria-hidden="true"for decorative icons.♿ Proposed fix
- <svg className="w-4 h-4 text-white" fill="currentColor" viewBox="0 0 20 20"> + <svg className="w-4 h-4 text-white" fill="currentColor" viewBox="0 0 20 20" aria-hidden="true">- <svg className={`w-6 h-6 ${isNeo ? 'text-black stroke-[3]' : 'text-amber-600 dark:text-amber-500'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24"> + <svg className={`w-6 h-6 ${isNeo ? 'text-black stroke-[3]' : 'text-amber-600 dark:text-amber-500'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24" aria-hidden="true">Also applies to: 110-112
web/App.tsx (1)
45-47: OAuth callback route should not be protected.The
/import/splitwise/callbackroute is wrapped inProtectedRoute. When Splitwise redirects back after OAuth authorization, if the user's session expired or tokens were cleared, they'll be redirected to/loginand lose the authorization code from the URL parameters—breaking the OAuth flow.Consider making the callback route public and handling authentication validation within the
SplitwiseCallbackcomponent itself.🔧 Proposed fix
<Route path="/import/splitwise" element={<ProtectedRoute><SplitwiseImport /></ProtectedRoute>} /> <Route path="/import/splitwise/select-groups" element={<ProtectedRoute><SplitwiseGroupSelection /></ProtectedRoute>} /> - <Route path="/import/splitwise/callback" element={<ProtectedRoute><SplitwiseCallback /></ProtectedRoute>} /> + <Route path="/import/splitwise/callback" element={<ThemeWrapper><SplitwiseCallback /></ThemeWrapper>} />Then handle auth validation inside
SplitwiseCallbackafter processing the OAuth code.web/pages/SplitwiseCallback.tsx (1)
96-137: Memory leak: polling interval not cleaned up on unmount.The
startProgressPollingfunction creates an interval that's never cleaned up if the component unmounts before import completes. This can cause state updates on unmounted components and memory leaks.🔧 Proposed fix
Store the interval ID in a ref and clean it up in useEffect:
+ const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null); + useEffect(() => { // ... existing code ... + + return () => { + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + } + }; }, [navigate, addToast, location.state]); const startProgressPolling = (jobId: string) => { setStatus('Import started...'); - const pollInterval = setInterval(async () => { + // Clear any existing interval + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + } + + pollIntervalRef.current = setInterval(async () => { // ... polling logic ... if (statusData.status === 'completed') { - clearInterval(pollInterval); + if (pollIntervalRef.current) clearInterval(pollIntervalRef.current); // ... } else if (statusData.status === 'failed') { - clearInterval(pollInterval); + if (pollIntervalRef.current) clearInterval(pollIntervalRef.current); // ... } }, 2000); };backend/app/integrations/schemas.py (1)
118-125: Stage status fields use strings instead ofImportStatusenum.This was flagged in a previous review. Using the
ImportStatusenum instead of hardcoded strings improves type safety and consistency.backend/app/integrations/router.py (3)
27-58: OAuth state validation is still missing - CSRF vulnerability remains.The
stateparameter is returned to the client but never validated in the callback. This was flagged in a previous review and remains unaddressed.
149-156: Use exception chaining for proper traceback context.This was flagged in a previous review. Re-raise with
from eto preserve the original traceback.
206-210: Use exception chaining here as well.Same issue as the callback endpoint - chain the exception for proper traceback context.
backend/app/integrations/splitwise/client.py (3)
16-29: Use explicit Optional types in__init__.Implicit Optional via
= Noneis not PEP 484 compliant; add explicitstr | None(orOptional[str]) and a-> Nonereturn type.🛠️ Suggested fix
- def __init__( - self, api_key: str = None, consumer_key: str = None, consumer_secret: str = None - ): + def __init__( + self, + api_key: str | None = None, + consumer_key: str | None = None, + consumer_secret: str | None = None, + ) -> None:
88-107: Log balance parsing failures instead of silently swallowing.Silent
excepthides malformed Splitwise payloads and makes debugging harder.🛠️ Suggested fix
+from app.config import logger ... - except Exception: - pass + except Exception: + logger.warning( + "Failed to parse Splitwise friend balances", + exc_info=True, + )
178-245: Avoid silent exception suppression in expense transforms.Multiple
try/exceptblocks swallow parsing errors; add logging to retain visibility into malformed Splitwise records.🛠️ Example improvement
- except Exception: - continue + except Exception: + logger.warning( + "Failed to parse Splitwise expense user shares", + exc_info=True, + ) + continueAlso applies to: 274-280
backend/app/integrations/service.py (8)
149-161: Avoid raw email exposure and guard None-email lookups.The email lookup should be skipped when the Splitwise email is missing, and the warning message should not include raw email addresses.
🛠️ Suggested fix
- existing_user = await self.users.find_one( - {"email": splitwise_user["email"]} - ) + existing_user = None + if splitwise_user.get("email"): + existing_user = await self.users.find_one( + {"email": splitwise_user["email"]} + ) ... - "message": f"Email {splitwise_user['email']} already exists in another account", + "message": "An account with this email already exists",
205-211: Use Pydantic v2model_dump()for options serialization.🛠️ Suggested fix
- "options": options.dict(), + "options": options.model_dump(),
233-244: Encrypt OAuth credentials at rest.Storing API keys and secrets in plaintext is a critical security risk.
🛠️ Suggested approach
- "apiKey": api_key, # Should be encrypted - "consumerKey": consumer_key, - "consumerSecret": consumer_secret, + "apiKey": encrypt_secret(api_key), + "consumerKey": encrypt_secret(consumer_key), + "consumerSecret": encrypt_secret(consumer_secret),
246-251: Keep a reference to background import tasks and capture failures.
asyncio.create_task()is fire-and-forget, so failures can be lost and tasks can’t be tracked or canceled.🛠️ Suggested fix
- asyncio.create_task( + task = asyncio.create_task( self._perform_import( import_job_id, user_id, api_key, consumer_key, consumer_secret, options ) ) + task.add_done_callback( + lambda t: logger.error(f"Import task failed: {t.exception()}") + if t.exception() + else None + )
415-417: Skip email lookups when email is missing.A
{"email": None}lookup can match unrelated users with missing emails.🛠️ Suggested fix
- existing = await self.users.find_one({"email": friend_data["email"]}) + existing = None + if friend_data.get("email"): + existing = await self.users.find_one({"email": friend_data["email"]})
674-679: Paginate Splitwise expenses instead of a fixed limit.A single
limit=1000can miss large datasets.
833-839: Harden expense date parsing to avoid skipping records.
fromisoformat()raises on non-ISO strings, causing the entire expense to be skipped.🛠️ Suggested fix
- "createdAt": ( - datetime.fromisoformat( - expense_data["date"].replace("Z", "+00:00") - ) - if expense_data.get("date") - else datetime.now(timezone.utc) - ), + "createdAt": ( + datetime.fromisoformat(expense_data["date"].replace("Z", "+00:00")) + if expense_data.get("date") + else datetime.now(timezone.utc) + ),Consider wrapping with a try/except and falling back to
datetime.now(timezone.utc)if parsing fails.
958-970: Rollback deletion order is nondeterministic.Iterating over
mappingsdoesn’t guarantee dependency order, and a partial failure can leave the system inconsistent.🛠️ Suggested fix
- # Delete in reverse order - for mapping in mappings: - entity_id = ObjectId(mapping["splitwiserId"]) - - if mapping["entityType"] == "expense": - await self.expenses.delete_one({"_id": entity_id}) - deleted_counts["expenses"] += 1 - elif mapping["entityType"] == "group": - await self.groups.delete_one({"_id": entity_id}) - deleted_counts["groups"] += 1 - elif mapping["entityType"] == "user": - await self.users.delete_one({"_id": entity_id}) - deleted_counts["users"] += 1 + # Delete by dependency order + for entity_type, collection in [ + ("expense", self.expenses), + ("group", self.groups), + ("user", self.users), + ]: + for mapping in [m for m in mappings if m["entityType"] == entity_type]: + entity_id = ObjectId(mapping["splitwiserId"]) + await collection.delete_one({"_id": entity_id}) + deleted_counts[f"{entity_type}s"] += 1
There was a problem hiding this comment.
Actionable comments posted: 2
🤖 Fix all issues with AI agents
In `@backend/tests/expenses/test_expense_service.py`:
- Around line 1175-1176: The groups membership check uses a loosened assertion
(mock_db.groups.find_one.assert_called_once()) while the settlement check uses
an exact assert_called_once_with; make these consistent by replacing the
loosened groups assertion with an exact call check: construct the same expected
query object you use for the settlement assertion (or reuse that variable) and
call mock_db.groups.find_one.assert_called_once_with(expected_query) so both
lookups are verified with the same level of specificity.
- Around line 1733-1734: The two tests are inconsistent about asserting
groups.find: in this test we call mock_db.groups.find.assert_called_once(),
while test_get_overall_balance_summary_success uses
mock_db.groups.find.assert_called_once_with({"members.userId": user_id}); decide
and make them consistent—either (A) tighten this test to
assert_called_once_with({"members.userId": user_id}) if the code path should
always query that exact shape, or (B) relax
test_get_overall_balance_summary_success to assert_called_once() if $or
membership queries affect all paths; if the difference is intentional, leave
both but add a clarifying comment in this file referencing
test_get_overall_balance_summary_success and explaining why one path may emit an
$or and the other will not so future readers understand the divergence.
| # groups.find_one is called (exact query format may vary due to $or support) | ||
| mock_db.groups.find_one.assert_called_once() |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Same loosened assertion pattern as noted above.
The group membership check assertion is loosened, while the settlement query assertion at lines 1177-1179 correctly remains exact. If intentional due to $or query variations, ensure this is applied consistently across all similar tests.
🤖 Prompt for AI Agents
In `@backend/tests/expenses/test_expense_service.py` around lines 1175 - 1176, The
groups membership check uses a loosened assertion
(mock_db.groups.find_one.assert_called_once()) while the settlement check uses
an exact assert_called_once_with; make these consistent by replacing the
loosened groups assertion with an exact call check: construct the same expected
query object you use for the settlement assertion (or reuse that variable) and
call mock_db.groups.find_one.assert_called_once_with(expected_query) so both
lookups are verified with the same level of specificity.
| # Verify mocks - groups.find is called (exact query format may vary due to $or support) | ||
| mock_db.groups.find.assert_called_once() |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Inconsistent with test_get_overall_balance_summary_success at line 1879.
This test loosens the groups.find assertion, but test_get_overall_balance_summary_success at line 1879 still uses an exact assertion:
mock_db.groups.find.assert_called_once_with({"members.userId": user_id})If $or query support affects all group membership lookups, consider updating both tests consistently. If only specific code paths use $or, add a comment explaining the difference.
🤖 Prompt for AI Agents
In `@backend/tests/expenses/test_expense_service.py` around lines 1733 - 1734, The
two tests are inconsistent about asserting groups.find: in this test we call
mock_db.groups.find.assert_called_once(), while
test_get_overall_balance_summary_success uses
mock_db.groups.find.assert_called_once_with({"members.userId": user_id}); decide
and make them consistent—either (A) tighten this test to
assert_called_once_with({"members.userId": user_id}) if the code path should
always query that exact shape, or (B) relax
test_get_overall_balance_summary_success to assert_called_once() if $or
membership queries affect all paths; if the difference is intentional, leave
both but add a clarifying comment in this file referencing
test_get_overall_balance_summary_success and explaining why one path may emit an
$or and the other will not so future readers understand the divergence.
|
@coderabbitai, review the website-related changes critically, as the new pages aren't consistent with the previous themeing guidelines, and the font, consistency we followed. So review it critically, and give review comments upto each line, and don't miss anything. The UI should feel the same at the end, and be consistent with all of it's before |
|
Tip For best results, initiate chat on the files or code changes. 🧩 Analysis chain🏁 Script executed: Length of output: 26270 🏁 Script executed: Length of output: 62073 🏁 Script executed: Length of output: 535 🏁 Script executed: Length of output: 2938 🏁 Script executed: Length of output: 9726 🏁 Script executed: Length of output: 10361
🔴 CRITICAL: SplitwiseCallback.tsx - Complete Design System ViolationThis page completely ignores your design system. It needs a full rewrite: Line-by-line Issues:Lines 1-5: ❌ Missing essential imports // MISSING: motion from framer-motion
// MISSING: THEMES from constants
// MISSING: useTheme hookLine 140: ❌ No container background theming // Current - generic, no theme awareness
<div className="min-h-screen bg-gray-50 dark:bg-gray-900 flex items-center justify-center px-4">
// Should be (like SplitwiseImport.tsx line 31):
<div className={`min-h-screen py-8 px-4 transition-colors duration-300 ${isNeo ? 'bg-[`#FFDEB4`]' : 'bg-gray-50 dark:bg-gray-900'}`}>Line 141: ❌ No motion.div animation // Current - static div
<div className="max-w-md w-full bg-white dark:bg-gray-800 rounded-lg shadow-lg p-8">
// Should be (like every other page):
<motion.div
initial={{ y: 20, opacity: 0 }}
animate={{ y: 0, opacity: 1 }}
className={`${isNeo
? 'bg-white border-4 border-black shadow-[8px_8px_0px_0px_rgba(0,0,0,1)] p-8 rounded-none'
: 'bg-white dark:bg-gray-800 rounded-xl shadow-lg p-8'}`}
>Line 143: ❌ Generic spinner - no theme awareness // Current
<div className="inline-block animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500 mb-4"></div>
// Should match SplitwiseImport.tsx line 67:
<div className={`animate-spin rounded-full h-12 w-12 border-4 ${isNeo ? 'border-black border-t-transparent' : 'border-blue-500 border-t-transparent'}`}></div>Line 144-145: ❌ Wrong typography scale // Current - too small, not bold enough
<h2 className="text-2xl font-bold text-gray-900 dark:text-white mb-2">
// Should be (compare with Groups.tsx line 122, GroupDetails.tsx line 427):
<h1 className={`text-4xl md:text-5xl font-black tracking-tighter ${isNeo ? 'text-black uppercase' : 'text-gray-900 dark:text-white'}`}>Line 146: ❌ Status text not bold enough // Current
<p className="text-gray-600 dark:text-gray-400">{status}</p>
// Should be:
<p className={`text-lg font-bold ${isNeo ? 'text-black/70' : 'text-gray-600 dark:text-gray-400'}`}>{status}</p>Line 151: ❌ Progress label styling inconsistent // Current
<span className="text-gray-600 dark:text-gray-400">Progress</span>
// Should be:
<span className={`text-sm font-bold uppercase tracking-wider ${isNeo ? 'text-black/70' : 'text-gray-600 dark:text-gray-400'}`}>Progress</span>Line 152-154: ❌ Progress percentage not emphasized // Current
<span className="font-medium text-gray-900 dark:text-white">
{progress.toFixed(0)}%
</span>
// Should be:
<span className={`text-2xl font-black ${isNeo ? 'text-black' : 'text-gray-900 dark:text-white'}`}>
{progress.toFixed(0)}%
</span>Line 156-161: ❌ Progress bar not theme-aware // Current - always rounded
<div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-3">
<div
className="bg-blue-500 h-3 rounded-full transition-all duration-300 ease-out"
style={{ width: `${progress}%` }}
/>
</div>
// Should be (with isNeo checks):
<div className={`w-full h-3 ${isNeo ? 'bg-gray-200 border-2 border-black' : 'bg-gray-200 dark:bg-gray-700 rounded-full'}`}>
<div
className={`h-3 transition-all duration-300 ${isNeo
? 'bg-blue-500 border-r-2 border-black'
: 'bg-blue-500 rounded-full'}`}
style={{ width: `${progress}%` }}
/>
</div>Line 165-168: ❌ Notice box styling inconsistent // Current
<div className="mt-6 bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded-lg p-4">
<p className="text-sm text-blue-800 dark:text-blue-200">
// Should match SplitwiseImport.tsx lines 85-86:
<div className={`mt-6 p-4 ${isNeo
? 'bg-blue-100 border-4 border-black rounded-none shadow-[4px_4px_0px_0px_rgba(0,0,0,1)]'
: 'bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded-lg'}`}>
<p className={`text-sm font-bold ${isNeo ? 'text-black' : 'text-blue-800 dark:text-blue-200'}`}>Summary for SplitwiseCallback.tsx:
|
| Element | SplitwiseImport | SplitwiseGroupSelection | SplitwiseCallback |
|---|---|---|---|
| ✅ Uses framer-motion | ✅ Yes | ✅ Yes | ❌ No |
| ✅ Theme-aware (isNeo) | ✅ Yes | ✅ Yes | ❌ No |
| ✅ Correct typography scale | ✅ Yes | ❌ No | |
| ✅ Neo shadows (8px/4px) | ✅ Yes | ✅ Yes | ❌ No |
| ✅ Neo borders (border-4) | ✅ Yes | ✅ Yes | ❌ No |
| ✅ Consistent animations | ✅ Yes | ✅ Yes | ❌ No |
| ✅ Bold font-black headings | ✅ Yes | ✅ Yes | ❌ No (font-bold only) |
| ✅ tracking-tighter on titles | ✅ Yes | ✅ Yes | ❌ No |
Compliance Score:
- SplitwiseImport.tsx: 95% ✅
- SplitwiseGroupSelection.tsx: 75%
⚠️ - SplitwiseCallback.tsx: 10% ❌
Would you like me to generate the corrected code for SplitwiseCallback.tsx that properly matches your design system?
|
@coderabbitai I've fixed the web related comments, please check them once |
|
Tip For best results, initiate chat on the files or code changes. 🧩 Analysis chainI'll check the updated web pages to verify your fixes! 🏁 Script executed: Length of output: 26545
✅ Verification ResultsSplitwiseCallback.tsx - Massive Improvement! ✅All critical issues have been resolved:
Compliance: 10% → 90% 🚀 SplitwiseGroupSelection.tsx - All Issues Resolved! ✅
Compliance: 75% → 95% 🎯 SplitwiseImport.tsx - Maintained Excellence! ✅
Compliance: 95% → 95% ⭐ 📊 Updated Design System Compliance
🎨 Final AssessmentAll three pages now properly follow your design system! The UI will feel consistent with the rest of the app across both neobrutalism and glass morphism themes. Great job addressing all the feedback! 🙌 The import flow is now ready from a frontend design perspective. If you found this review helpful, would you consider giving us a shout-out on X? Thank you for using CodeRabbit! |
|
Tip For best results, initiate chat on the files or code changes. 🧩 Analysis chainI'll verify the fixes you've made to the web pages. Let me check the current state of all three files. 🏁 Script executed: Length of output: 26518
✅ SplitwiseCallback.tsx - Transformed! (10% → 95% Compliance)What You Fixed Perfectly:✅ Line 1-8: Added all missing imports (motion, THEMES, useTheme) Tiny Refinements (Optional):The heading at line 156 uses Verdict: This page went from a complete rewrite needed to production-ready! 🚀 ✅ SplitwiseGroupSelection.tsx - Polished! (75% → 98% Compliance)What You Fixed:✅ Line 146: Fixed typo - "once" is now correctly "ones" Perfect as-is:The typography scale ( Verdict: This page is now fully compliant with the design system! ✨ ✅ SplitwiseImport.tsx - Unchanged (Already Perfect at 95%)No changes needed or made - this page was already excellent in the previous iteration. 📊 Final Compliance Scores
🎨 Design System Compliance Checklist
All three pages now maintain the app's bold, immersive, theme-aware design language! The UI will feel consistent across the entire application. Great job addressing every concern from the review! 👏 The Splitwise import flow is now production-ready from a design perspective. The pages properly support both neobrutalism and glass themes, include smooth animations, and maintain the app's visual identity. |
There was a problem hiding this comment.
Actionable comments posted: 2
🤖 Fix all issues with AI agents
In `@web/pages/SplitwiseCallback.tsx`:
- Around line 20-35: Move the React Strict Mode duplicate-guard (hasStartedRef)
above the skipOAuth branch inside the useEffect so the guard prevents any
duplicate execution before startProgressPolling can be called; specifically, in
the useEffect that reads location.state (skipOAuth and jobId), check and return
early if hasStartedRef.current is true (using the existing hasStartedRef
symbol), then set hasStartedRef.current = true, and only after that evaluate
state?.skipOAuth && state?.jobId to call startProgressPolling. Ensure you keep
the existing startProgressPolling and state extraction logic but reorder them so
the hasStartedRef guard runs first.
In `@web/pages/SplitwiseGroupSelection.tsx`:
- Around line 83-99: The code navigates using jobId without validating it;
update the block after calling handleSplitwiseCallback (the await call that sets
response and computes jobId) to check that jobId is present and valid before
calling navigate('/import/splitwise/callback', ...). If jobId is missing or
falsy, call setImporting(false) and show a user-facing toast/error (use your
existing toast utility) explaining the import failed and abort navigation;
otherwise proceed to navigate with state { jobId, skipOAuth: true }. Ensure this
change touches the async handler that uses setImporting,
handleSplitwiseCallback, selectedGroupIds, accessToken, and navigate so the
importing flag is always reset on error paths.
♻️ Duplicate comments (7)
web/pages/SplitwiseCallback.tsx (2)
20-97: Clear the polling interval on unmount.
Line 103 creates asetIntervalthat is only cleared on completion/failure; if the user navigates away, the interval keeps running. Track it in a ref and clear it in the effect cleanup.🧹 Proposed fix
export const SplitwiseCallback = () => { const navigate = useNavigate(); const location = useLocation(); const { addToast } = useToast(); const { style } = useTheme(); const isNeo = style === THEMES.NEOBRUTALISM; const [status, setStatus] = useState('Processing authorization...'); const [progress, setProgress] = useState(0); const [importing, setImporting] = useState(true); const hasStartedRef = useRef(false); + const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null); useEffect(() => { ... - handleCallback(); + handleCallback(); + return () => { + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + pollIntervalRef.current = null; + } + }; }, [navigate, addToast, location.state]); const startProgressPolling = (jobId: string) => { setStatus('Import started...'); // Poll for progress - const pollInterval = setInterval(async () => { + if (pollIntervalRef.current) clearInterval(pollIntervalRef.current); + pollIntervalRef.current = setInterval(async () => { try { const statusResponse = await getImportStatus(jobId); const statusData = statusResponse.data; ... if (statusData.status === 'completed') { - clearInterval(pollInterval); + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + pollIntervalRef.current = null; + } setImporting(false); addToast('Import completed successfully!', 'success'); setStatus('Completed! Redirecting to dashboard...'); setTimeout(() => navigate('/dashboard'), 2000); } else if (statusData.status === 'failed') { - clearInterval(pollInterval); + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + pollIntervalRef.current = null; + } setImporting(false); addToast('Import failed', 'error'); setStatus(`Failed: ${statusData.errors?.[0]?.message || 'Unknown error'}`); } } catch (error) { console.error('Error polling import status:', error); } }, 2000); };Also applies to: 99-140
31-120: Remove or guard debug console logs.
Lines 31, 42, 55, 57, 62, 80, 108, 119 log OAuth/status details. Please remove them or guard behind a dev-only check before release.🧹 Example fix (apply similarly to all console.log lines)
- console.log('OAuth callback - code:', code?.substring(0, 10), 'state:', state); - console.log('Exchanging OAuth code for token...'); - console.log('Token exchange response:', tokenResponse.data); - console.log('Navigating to group selection with', tokenResponse.data.groups.length, 'groups'); - console.log('Import job ID:', jobId); - console.log('Status response:', statusData); - console.log('Progress:', progressPercentage, '% -', currentStage, '- Status:', statusData.status);web/pages/SplitwiseImport.tsx (2)
56-64: Add explicit button type.
Line 57: the button defaults tosubmitif nested in a form. Addtype="button"to prevent unintended submissions.🔧 Proposed fix
- <button + <button + type="button" onClick={handleOAuthImport} disabled={loading} className={`w-full py-4 px-6 flex items-center justify-center gap-3 transition-all ${isNeo
88-92: Add accessible text for inline SVGs.
Lines 89 and 110 render SVGs without a<title>or aria label. Provide accessible text (or mark themaria-hiddenif decorative) to satisfy accessibility rules.♿ Proposed fix
- <svg className="w-3 h-3 text-white" fill="currentColor" viewBox="0 0 20 20"> + <svg className="w-3 h-3 text-white" fill="currentColor" viewBox="0 0 20 20" role="img" aria-label="Included"> + <title>Included</title> <path fillRule="evenodd" d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z" clipRule="evenodd" /> </svg> ... - <svg className={`w-5 h-5 ${isNeo ? 'text-black' : 'text-amber-600 dark:text-amber-500'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24"> + <svg className={`w-5 h-5 ${isNeo ? 'text-black' : 'text-amber-600 dark:text-amber-500'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24" role="img" aria-label="Important note"> + <title>Important note</title> <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" /> </svg>Also applies to: 109-112
web/pages/SplitwiseGroupSelection.tsx (3)
74-77: Remove auth-state debug logging.
Line 76 logs authentication presence; avoid shipping this in production.🧹 Proposed fix
- console.log('Auth token present:', !!token);
125-134: Settype="button"on non-submit buttons.
Lines 125, 161, and 257: add explicit types to avoid accidental form submissions.🔧 Proposed fix
- <button + <button + type="button" onClick={() => navigate('/import/splitwise')} className={`flex items-center gap-1 mb-4 text-sm font-medium transition-colors ${isNeo ... - <button + <button + type="button" onClick={handleSelectAll} className={`text-sm font-medium transition-colors ${isNeo ... - <button + <button + type="button" onClick={handleStartImport} disabled={importing || selectedGroupIds.size === 0} className={`w-full py-4 px-6 flex items-center justify-center gap-3 transition-all ${isNeoAlso applies to: 161-169, 257-264
232-238: Avoid hardcoding'en-IN'number formatting.
Line 235 forces Indian digit grouping; use the browser’s locale to match user preferences.🌐 Proposed fix
- {new Intl.NumberFormat('en-IN', { + {new Intl.NumberFormat(undefined, { minimumFractionDigits: 0, maximumFractionDigits: 0, }).format(group.totalAmount)}
| setImporting(true); | ||
| try { | ||
| // Call the import API with selected groups and access token | ||
| const response = await handleSplitwiseCallback( | ||
| undefined, // no code | ||
| undefined, // no state | ||
| Array.from(selectedGroupIds), | ||
| accessToken // pass stored access token | ||
| ); | ||
|
|
||
| const jobId = response.data.import_job_id || response.data.importJobId; | ||
|
|
||
| // Navigate to callback/progress page | ||
| navigate('/import/splitwise/callback', { | ||
| state: { jobId, skipOAuth: true } | ||
| }); | ||
|
|
There was a problem hiding this comment.
Handle missing import job ID before navigation.
Line 93 uses jobId without validation; if the backend omits it, the callback page fails and the user sees an auth error. Guard and reset importing with a toast.
🐛 Proposed fix
const jobId = response.data.import_job_id || response.data.importJobId;
+ if (!jobId) {
+ addToast('Failed to start import - no job ID returned', 'error');
+ setImporting(false);
+ return;
+ }
// Navigate to callback/progress page
navigate('/import/splitwise/callback', {
state: { jobId, skipOAuth: true }
});🤖 Prompt for AI Agents
In `@web/pages/SplitwiseGroupSelection.tsx` around lines 83 - 99, The code
navigates using jobId without validating it; update the block after calling
handleSplitwiseCallback (the await call that sets response and computes jobId)
to check that jobId is present and valid before calling
navigate('/import/splitwise/callback', ...). If jobId is missing or falsy, call
setImporting(false) and show a user-facing toast/error (use your existing toast
utility) explaining the import failed and abort navigation; otherwise proceed to
navigate with state { jobId, skipOAuth: true }. Ensure this change touches the
async handler that uses setImporting, handleSplitwiseCallback, selectedGroupIds,
accessToken, and navigate so the importing flag is always reset on error paths.
…ehensive validation with supporting scripts and UI.
There was a problem hiding this comment.
Actionable comments posted: 14
Caution
Some comments are outside the diff and can’t be posted inline due to platform limitations.
⚠️ Outside diff range comments (1)
backend/app/expenses/service.py (1)
959-976: Recalculate cached balances after settlement status changes/deletes
cachedBalancesstays stale when a settlement is marked completed or deleted. Add_recalculate_group_balances(group_id)on successful update/delete to keep balance reads correct.Based on balance caching plan.🛠️ Suggested fix
result = await self.settlements_collection.update_one( {"_id": ObjectId(settlement_id), "groupId": group_id}, {"$set": update_doc} ) if result.matched_count == 0: raise HTTPException(status_code=404, detail="Settlement not found") + + await self._recalculate_group_balances(group_id) # Get updated settlement settlement_doc = await self.settlements_collection.find_one( {"_id": ObjectId(settlement_id)} )result = await self.settlements_collection.delete_one( {"_id": ObjectId(settlement_id), "groupId": group_id} ) - return result.deleted_count > 0 + if result.deleted_count > 0: + await self._recalculate_group_balances(group_id) + return result.deleted_count > 0Also applies to: 992-996
🤖 Fix all issues with AI agents
In @.agent/artifacts/balance_caching_plan.md:
- Around line 10-33: The markdown has lint violations around headings and code
fences (e.g., "## Current Architecture", "### Data Flow", and the fenced block
starting with "```python"); fix by ensuring there is a blank line before and
after every heading and every fenced code block, and add explicit fence language
identifiers where missing (use ```text for plain blocks and keep ```python for
the Python schema) so MD022/MD031/MD040 are satisfied.
In `@backend/app/auth/service.py`:
- Around line 107-131: The response user object is missing DB fields set during
update (auth_provider and activated_at), so update the in-memory existing_user
to match the DB update: build an update_data dict (same keys as used in the
db.users.update_one call, e.g., "hashed_password", "name", "isPlaceholder",
"auth_provider", "activated_at") and apply those entries to existing_user after
calling get_password_hash and awaiting db.users.update_one in the signup/linking
flow (the block around get_password_hash, db.users.update_one, and existing_user
mutations); ensure existing_user contains the new "auth_provider" and
"activated_at" values before returning.
In `@backend/app/expenses/service.py`:
- Around line 1153-1155: Remove the unused local variable groups_map which is
assigned from groups but never read; locate the comprehension "groups_map =
{str(g['_id']): g.get('name', 'Unknown Group') for g in groups}" and delete that
line (or replace it with a comment if you want to document the groups
structure), ensuring no other references to groups_map remain in the surrounding
function or method.
- Around line 57-61: Replace each bare except used around ObjectId(user_id)
coercion with a narrow exception handler that catches bson.errors.InvalidId (and
optionally TypeError) so you don't swallow system exceptions; for each
occurrence where you assign user_obj_id = ObjectId(user_id) inside a try/except
(referenced by the ObjectId(...) calls and the user_obj_id variable), change the
except to "except (InvalidId, TypeError):" (or "except InvalidId:" if you
prefer) and ensure InvalidId is imported from bson.errors at the top of the
module; leave the fallback assignment user_obj_id = user_id unchanged.
In `@backend/app/groups/service.py`:
- Around line 303-333: The cascade deletes for expenses and settlements run
before deleting the group, risking partial data loss if db.groups.delete_one
fails; wrap all four operations (db.expenses.delete_many,
db.settlements.delete_many, db.groups.delete_one, and conditional
db.splitwise_id_mappings.delete_one) in a MongoDB transaction session (e.g.,
start a session via db.client.start_session() and use session.with_transaction
or pass session=session to each delete_* call) so they commit or abort
atomically, using the existing group_id, obj_id and is_imported variables; if
transactions are unavailable in this environment, implement a try/except that
performs the group deletion first or records compensating actions and rolls back
the prior deletes on failure.
In `@backend/app/integrations/service.py`:
- Around line 691-699: When skipping archived expenses due to
options.importArchivedExpenses being False and expense.getDeletedAt() returning
a value, increment the progress completed counter so progress stays consistent
with total; locate the loop handling expenses in service.py and, immediately
before the continue for deleted_at, update the same completed/progress counter
(e.g., increment the variable or call the existing progress update function that
other paths use) to match how non-skipped items advance progress.
- Around line 802-804: The current creation of new_expense sets payer_id =
creditors[0][0] if creditors else user_id which misattributes self-paid imports
when creditors is empty; instead derive the payer from paidShare: set payer_id =
creditors[0][0] if creditors else the user id key in paidShare with a positive
amount (e.g., next((uid for uid, amt in paidShare.items() if amt > 0),
user_id)), and ensure this payer_id is assigned to the new_expense['paidBy']
field so paidBy reflects the actual payer rather than defaulting to the
importing user.
In `@backend/migrations/003_add_currency_to_groups.py`:
- Line 23: Remove the unnecessary noqa directive from the import in the top of
the migration: edit the import line that references app.config and drop the
trailing "# noqa: E402" so it simply reads "from app.config import logger,
settings"; ensure no other noqa remains in this file and run the linter to
confirm no E402 suppression is needed for the logger/settings import.
- Line 31: The logger.info call that logs settings.mongodb_url exposes possible
credentials; update the logging in the connection flow to redact sensitive parts
instead of printing the full URL by parsing settings.mongodb_url (e.g., via
urllib.parse.urlparse) and logging only safe components such as scheme and
netloc without userinfo or just the hostname/port, or replace the
password/userinfo with a placeholder before calling logger.info; target the
logger.info(...) that currently uses settings.mongodb_url to implement this
redaction.
- Around line 58-60: In the except block handling exceptions in the migration
(the except Exception as e block that calls logger.error), change the f-string
to use the explicit conversion flag for the exception—replace f"❌ Migration
failed: {str(e)}" with f"❌ Migration failed: {e!s}" so Ruff RUF010 is satisfied;
keep the logger.error call and the subsequent raise intact.
- Around line 94-96: Replace the f-string that formats the caught exception in
the except block—currently logger.error(f"❌ Verification failed: {str(e)}")—to
use the explicit conversion flag: logger.error(f"❌ Verification failed: {e!s}");
this updates the exception formatting in the error log while keeping the
surrounding except Exception as e / raise behavior unchanged.
In `@backend/migrations/004_fix_member_userid_format.py`:
- Line 27: The import line "from app.config import logger, settings # noqa:
E402" includes an unused noqa directive; remove the trailing "# noqa: E402" so
the line reads simply "from app.config import logger, settings" and commit the
change in the migration module where that import appears to eliminate the lint
warning.
- Around line 35-36: The current logger.info call prints settings.mongodb_url
which may include credentials; modify the code so logger.info does not log the
full URI: parse settings.mongodb_url (used when creating AsyncIOMotorClient) and
redact any userinfo (username:password@) before logging, e.g., replace the
userinfo portion with a placeholder like "<redacted>" or remove it entirely,
then log the sanitized URI instead of settings.mongodb_url while still using
settings.mongodb_url unchanged for AsyncIOMotorClient.
In `@backend/migrations/005_init_cached_balances.py`:
- Around line 119-121: The logger currently prints the full MongoDB connection
string via settings.mongodb_url which can contain credentials; update the code
around the MongoDB connect logic (the logger.info call before AsyncIOMotorClient
instantiation) to avoid leaking secrets by either redacting credentials from
settings.mongodb_url or extracting and logging only safe parts (host and
database name) instead of the raw URL; ensure you still call
AsyncIOMotorClient(settings.mongodb_url) unchanged but change the logged value
to the sanitized/redacted string.
♻️ Duplicate comments (16)
backend/migrations/003_add_currency_to_groups.py (1)
83-83: Remove extraneousfprefix from string without placeholders.This string has no interpolation; use a plain string.
- logger.info(f"\n📊 Verification Results:") + logger.info("\n📊 Verification Results:")web/pages/SplitwiseCallback.tsx (2)
20-33: Move the Strict‑Mode guard before the skipOAuth branch.The skipOAuth path can start polling twice under React Strict Mode because it runs before the
hasStartedRefguard. Place the guard first.🔧 Proposed fix
useEffect(() => { - // Check if we're in progress tracking mode (skipOAuth from group selection) - const state = location.state as { jobId?: string; skipOAuth?: boolean }; - if (state?.skipOAuth && state?.jobId) { - // Start polling for existing job - startProgressPolling(state.jobId); - return; - } - // Prevent duplicate execution in React Strict Mode using ref if (hasStartedRef.current) { return; } hasStartedRef.current = true; + + // Check if we're in progress tracking mode (skipOAuth from group selection) + const state = location.state as { jobId?: string; skipOAuth?: boolean }; + if (state?.skipOAuth && state?.jobId) { + startProgressPolling(state.jobId); + return; + }
15-124: Ensure polling intervals are cleaned up on unmount.
setIntervalkeeps running if the component unmounts, which can leak and attempt state updates after unmount. Track the interval in a ref and clear it in the effect cleanup and terminal statuses.🔧 Proposed fix
const [status, setStatus] = useState('Processing authorization...'); const [progress, setProgress] = useState(0); const [importing, setImporting] = useState(true); const hasStartedRef = useRef(false); +const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null); ... const startProgressPolling = (jobId: string) => { setStatus('Import started...'); // Poll for progress - const pollInterval = setInterval(async () => { + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + } + pollIntervalRef.current = setInterval(async () => { try { const statusResponse = await getImportStatus(jobId); const statusData = statusResponse.data; ... if (statusData.status === 'completed') { - clearInterval(pollInterval); + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + pollIntervalRef.current = null; + } setImporting(false); addToast('Import completed successfully!', 'success'); setStatus('Completed! Redirecting to dashboard...'); setTimeout(() => navigate('/dashboard'), 2000); } else if (statusData.status === 'failed') { - clearInterval(pollInterval); + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + pollIntervalRef.current = null; + } setImporting(false); addToast('Import failed', 'error'); setStatus(`Failed: ${statusData.errors?.[0]?.message || 'Unknown error'}`); } } catch (error) { // Silently catch polling errors to avoid spamming console } }, 2000); }; ... useEffect(() => { ... handleCallback(); + return () => { + if (pollIntervalRef.current) { + clearInterval(pollIntervalRef.current); + pollIntervalRef.current = null; + } + }; }, [navigate, addToast, location.state]);web/pages/SplitwiseGroupSelection.tsx (1)
92-97: Guard against missing import job ID before navigation.If the backend doesn’t return
jobId, the callback page will fail. Add a guard, reset importing, and show a toast.🔧 Proposed fix
const jobId = response.data.import_job_id || response.data.importJobId; +if (!jobId) { + addToast('Failed to start import - no job ID returned', 'error'); + setImporting(false); + return; +} // Navigate to callback/progress page navigate('/import/splitwise/callback', { state: { jobId, skipOAuth: true } });backend/tests/test_splitwise_import.py (1)
236-237: Fix SettlementCalculator import path so pytest can resolve it.With
backend/onsys.path, the module should be imported from thetestspackage. The current import will fail.🔧 Proposed fix
- from test_settlement_calculation import SettlementCalculator + from tests.test_settlement_calculation import SettlementCalculator- from test_settlement_calculation import SettlementCalculator + from tests.test_settlement_calculation import SettlementCalculator- from test_settlement_calculation import SettlementCalculator + from tests.test_settlement_calculation import SettlementCalculatorAlso applies to: 268-269, 302-303
backend/app/integrations/router.py (1)
5-62: Persist and validate OAuth state server-side to prevent CSRF.The authorize endpoint returns the state secret to the client and the callback never validates it. Store the state server-side (cache/DB), validate
request.statebefore exchanging the code, and delete it after use.🔧 Proposed fix (outline)
+from datetime import datetime, timezone ... `@router.get`("/splitwise/authorize") -async def get_splitwise_oauth_url(current_user=Depends(get_current_user)): +async def get_splitwise_oauth_url( + current_user=Depends(get_current_user), + db: AsyncIOMotorDatabase = Depends(get_database), +): ... auth_url, secret = sObj.getOAuth2AuthorizeURL( redirect_uri=f"{settings.frontend_url}/#/import/splitwise/callback" ) - - # Store the secret temporarily (you may want to use Redis/cache instead) - # For now, we'll include it in the response for the callback to use - return { - "authorization_url": auth_url, - "state": secret, # This will be needed in the callback - } + await db.oauth_states.update_one( + {"userId": current_user["_id"], "provider": "splitwise"}, + {"$set": {"state": secret, "createdAt": datetime.now(timezone.utc)}}, + upsert=True, + ) + return {"authorization_url": auth_url} ... - elif request.code: + elif request.code: + stored_state = await db.oauth_states.find_one( + {"userId": current_user["_id"], "provider": "splitwise"} + ) + if not stored_state or stored_state.get("state") != request.state: + raise HTTPException(status_code=400, detail="Invalid OAuth state") + await db.oauth_states.delete_one({"_id": stored_state["_id"]}) # Exchange authorization code for access token logger.debug("Attempting OAuth token exchange (code present: True)")Also applies to: 65-108
backend/tests/test_settlement_calculation.py (1)
20-21: Prefer built‑in generics for Python 3.9+ type hints.
typing.Dict/List/Tupleare deprecated (UP035). Switch todict/list/tupleand update annotations throughout.♻️ Proposed change (apply pattern across the file)
-from typing import Any, Dict, List, Tuple +from typing import Any ... - def calculate_user_shares(expense: Dict[str, Any]) -> List[Dict[str, Any]]: + def calculate_user_shares(expense: dict[str, Any]) -> list[dict[str, Any]]:backend/app/integrations/schemas.py (1)
116-123: UseImportStatusenum for checkpoint fields.String defaults allow invalid values and drift from the rest of the status model.
♻️ Proposed change
class ImportStatusCheckpoint(BaseModel): """Checkpoint status for a stage.""" - user: str = "pending" - friends: str = "pending" - groups: str = "pending" - expenses: str = "pending" - settlements: str = "pending" + user: ImportStatus = ImportStatus.PENDING + friends: ImportStatus = ImportStatus.PENDING + groups: ImportStatus = ImportStatus.PENDING + expenses: ImportStatus = ImportStatus.PENDING + settlements: ImportStatus = ImportStatus.PENDINGbackend/app/integrations/service.py (8)
149-160: Mask or remove emails in warning payloads.The
email_conflictwarning exposes another user’s email address, which is PII leakage in API responses and stored job history.🔒 Proposed fix
- "message": f"Email {splitwise_user['email']} already exists in another account", + "message": "An account with this email already exists",
206-211: Usemodel_dump()with Pydantic v2 serialization.
.dict()is deprecated in v2.♻️ Proposed fix
- "options": options.dict(), + "options": options.model_dump(),
233-241: Encrypt OAuth credentials before persisting.Storing
apiKey/consumerSecretin plaintext is a critical security risk. Use your encryption/KMS helper before insert.🔐 Proposed fix (use your project’s encryption helper)
await self.oauth_tokens.insert_one( { "userId": ObjectId(user_id), "provider": provider.value, - "apiKey": api_key, # Should be encrypted - "consumerKey": consumer_key, - "consumerSecret": consumer_secret, + "apiKey": encrypt_secret(api_key), + "consumerKey": encrypt_secret(consumer_key), + "consumerSecret": encrypt_secret(consumer_secret), "importJobId": ObjectId(import_job_id), "createdAt": datetime.now(timezone.utc), } )
246-251: Keep a reference to background import tasks and surface failures.Discarding the task hides exceptions and prevents cancellation/monitoring.
🧵 Proposed fix
- asyncio.create_task( + task = asyncio.create_task( self._perform_import( import_job_id, user_id, api_key, consumer_key, consumer_secret, options ) ) + task.add_done_callback( + lambda t: logger.error(f"Import task failed: {t.exception()}") + if t.exception() + else None + ) + self._background_tasks[import_job_id] = taskConsider initializing
self._background_tasks = {}in__init__.
415-417: Guard email lookups when friend email is missing.Querying with
{"email": None}can match unrelated users and link the wrong account.🛠️ Proposed fix
- existing = await self.users.find_one({"email": friend_data["email"]}) + existing = None + if friend_data.get("email"): + existing = await self.users.find_one( + {"email": friend_data["email"]} + )
682-687: Paginate Splitwise expenses to avoid truncation.
limit=1000can miss expenses for large accounts; import becomes incomplete.📚 Proposed fix (verify client paging params)
- all_expenses = client.get_expenses(limit=1000) + all_expenses = [] + offset = 0 + limit = 500 + while True: + batch = client.get_expenses(limit=limit, offset=offset) + if not batch: + break + all_expenses.extend(batch) + if len(batch) < limit: + break + offset += limit
842-847: Guardfromisoformatto avoid dropping expenses.Non‑ISO strings raise
ValueError, which skips the entire expense.🛡️ Proposed fix
- new_expense = { + created_at = datetime.now(timezone.utc) + if expense_data.get("date"): + try: + created_at = datetime.fromisoformat( + expense_data["date"].replace("Z", "+00:00") + ) + except ValueError: + logger.warning( + "Invalid date format for Splitwise expense %s", + expense_data.get("splitwiseExpenseId"), + ) + + new_expense = { ... - "createdAt": ( - datetime.fromisoformat( - expense_data["date"].replace("Z", "+00:00") - ) - if expense_data.get("date") - else datetime.now(timezone.utc) - ), + "createdAt": created_at,
966-978: Deletion order isn’t guaranteed; enforce dependency order.Iterating
mappingsdoesn’t ensure reverse order. Delete expenses → groups → users explicitly.🧹 Proposed fix
- # Delete in reverse order - for mapping in mappings: - entity_id = ObjectId(mapping["splitwiserId"]) - - if mapping["entityType"] == "expense": - await self.expenses.delete_one({"_id": entity_id}) - deleted_counts["expenses"] += 1 - elif mapping["entityType"] == "group": - await self.groups.delete_one({"_id": entity_id}) - deleted_counts["groups"] += 1 - elif mapping["entityType"] == "user": - await self.users.delete_one({"_id": entity_id}) - deleted_counts["users"] += 1 + # Delete in dependency order: expenses → groups → users + for entity_type, collection in [ + ("expense", self.expenses), + ("group", self.groups), + ("user", self.users), + ]: + for mapping in [m for m in mappings if m["entityType"] == entity_type]: + entity_id = ObjectId(mapping["splitwiserId"]) + await collection.delete_one({"_id": entity_id}) + deleted_counts[f"{entity_type}s"] += 1
| # Check if it's a placeholder from import | ||
| if existing_user.get("isPlaceholder"): | ||
| # Link this signup to the placeholder account | ||
| logger.info( | ||
| f"Linking signup to placeholder account for user_id={existing_user['_id']}" | ||
| ) | ||
| hashed_password = get_password_hash(password) | ||
| await db.users.update_one( | ||
| {"_id": existing_user["_id"]}, | ||
| { | ||
| "$set": { | ||
| "hashed_password": hashed_password, | ||
| "name": name, # Update with new name if provided | ||
| "isPlaceholder": False, | ||
| "auth_provider": "email", | ||
| "activated_at": datetime.now(timezone.utc), | ||
| } | ||
| }, | ||
| ) | ||
|
|
||
| # Return the linked account | ||
| existing_user["hashed_password"] = hashed_password | ||
| existing_user["name"] = name | ||
| existing_user["isPlaceholder"] = False | ||
|
|
There was a problem hiding this comment.
Keep returned placeholder user in sync with DB updates
The DB update sets auth_provider and activated_at, but the response only updates hashed_password, name, and isPlaceholder, so the client receives stale fields. Consider reusing an update_data dict and applying it to existing_user before returning.
🛠️ Suggested fix
- hashed_password = get_password_hash(password)
- await db.users.update_one(
- {"_id": existing_user["_id"]},
- {
- "$set": {
- "hashed_password": hashed_password,
- "name": name, # Update with new name if provided
- "isPlaceholder": False,
- "auth_provider": "email",
- "activated_at": datetime.now(timezone.utc),
- }
- },
- )
+ hashed_password = get_password_hash(password)
+ activated_at = datetime.now(timezone.utc)
+ update_data = {
+ "hashed_password": hashed_password,
+ "name": name, # Update with new name if provided
+ "isPlaceholder": False,
+ "auth_provider": "email",
+ "activated_at": activated_at,
+ }
+ await db.users.update_one(
+ {"_id": existing_user["_id"]},
+ {"$set": update_data},
+ )
- existing_user["hashed_password"] = hashed_password
- existing_user["name"] = name
- existing_user["isPlaceholder"] = False
+ existing_user.update(update_data)🤖 Prompt for AI Agents
In `@backend/app/auth/service.py` around lines 107 - 131, The response user object
is missing DB fields set during update (auth_provider and activated_at), so
update the in-memory existing_user to match the DB update: build an update_data
dict (same keys as used in the db.users.update_one call, e.g.,
"hashed_password", "name", "isPlaceholder", "auth_provider", "activated_at") and
apply those entries to existing_user after calling get_password_hash and
awaiting db.users.update_one in the signup/linking flow (the block around
get_password_hash, db.users.update_one, and existing_user mutations); ensure
existing_user contains the new "auth_provider" and "activated_at" values before
returning.
| # Query for both string and ObjectId userId formats for compatibility with imported groups | ||
| try: | ||
| user_obj_id = ObjectId(user_id) | ||
| except: | ||
| user_obj_id = user_id |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
# First, check if the file exists and get its total line count
ls -la backend/app/expenses/service.py 2>/dev/null && wc -l backend/app/expenses/service.pyRepository: Devasy/splitwiser
Length of output: 179
🏁 Script executed:
# Read the specific lines mentioned in the review comment
echo "=== Lines 57-61 ==="
sed -n '57,61p' backend/app/expenses/service.py
echo "=== Lines 195-199 ==="
sed -n '195,199p' backend/app/expenses/service.py
echo "=== Lines 303-307 ==="
sed -n '303,307p' backend/app/expenses/service.py
echo "=== Lines 747-751 ==="
sed -n '747,751p' backend/app/expenses/service.py
echo "=== Lines 858-862 ==="
sed -n '858,862p' backend/app/expenses/service.py
echo "=== Lines 918-922 ==="
sed -n '918,922p' backend/app/expenses/service.pyRepository: Devasy/splitwiser
Length of output: 1244
🏁 Script executed:
# Check the imports at the top of the file to see what's available
head -30 backend/app/expenses/service.pyRepository: Devasy/splitwiser
Length of output: 746
🏁 Script executed:
# Search for all bare except blocks in the file
rg "except:\s*$" backend/app/expenses/service.py -A 1 -B 1 -nRepository: Devasy/splitwiser
Length of output: 708
🏁 Script executed:
# Check what's imported regarding ObjectId and errors
rg "from.*import|import.*" backend/app/expenses/service.py | head -20Repository: Devasy/splitwiser
Length of output: 486
Replace bare except when coercing user IDs
These except: blocks will swallow KeyboardInterrupt and SystemExit. Catch errors.InvalidId (and optionally TypeError) to scope the fallback to invalid ObjectId values.
All 6 occurrences need fixing:
🛠️ Suggested fix
- try:
- user_obj_id = ObjectId(user_id)
- except:
- user_obj_id = user_id
+ try:
+ user_obj_id = ObjectId(user_id)
+ except (errors.InvalidId, TypeError):
+ user_obj_id = user_idLines: 57–61, 195–199, 303–307, 747–751, 858–862, 918–922
🧰 Tools
🪛 Ruff (0.14.13)
60-60: Do not use bare except
(E722)
🤖 Prompt for AI Agents
In `@backend/app/expenses/service.py` around lines 57 - 61, Replace each bare
except used around ObjectId(user_id) coercion with a narrow exception handler
that catches bson.errors.InvalidId (and optionally TypeError) so you don't
swallow system exceptions; for each occurrence where you assign user_obj_id =
ObjectId(user_id) inside a try/except (referenced by the ObjectId(...) calls and
the user_obj_id variable), change the except to "except (InvalidId, TypeError):"
(or "except InvalidId:" if you prefer) and ensure InvalidId is imported from
bson.errors at the top of the module; leave the fallback assignment user_obj_id
= user_id unchanged.
| # Build group map for name lookup | ||
| groups_map = {str(g["_id"]): g.get("name", "Unknown Group") for g in groups} | ||
|
|
There was a problem hiding this comment.
Remove unused groups_map
groups_map is assigned but never used (Ruff F841). Please remove it to keep the method tidy.
🧰 Tools
🪛 Ruff (0.14.13)
1154-1154: Local variable groups_map is assigned to but never used
Remove assignment to unused variable groups_map
(F841)
🤖 Prompt for AI Agents
In `@backend/app/expenses/service.py` around lines 1153 - 1155, Remove the unused
local variable groups_map which is assigned from groups but never read; locate
the comprehension "groups_map = {str(g['_id']): g.get('name', 'Unknown Group')
for g in groups}" and delete that line (or replace it with a comment if you want
to document the groups structure), ensuring no other references to groups_map
remain in the surrounding function or method.
| # Result is True if delete was successful | ||
| # Cascade delete related entries if delete was successful | ||
| # 1. Delete all expenses related to this group | ||
| # 2. Delete all settlements related to this group | ||
| # 3. Delete related ID mappings only if it was an imported group | ||
|
|
||
| # Check if imported | ||
| is_imported = group.get("importedFrom") == "splitwise" | ||
|
|
||
| # Delete expenses | ||
| # Note: groupId in expenses is stored as string | ||
| await db.expenses.delete_many({"groupId": group_id}) | ||
|
|
||
| # Delete settlements | ||
| await db.settlements.delete_many({"groupId": group_id}) | ||
|
|
||
| # Delete the group itself | ||
| result = await db.groups.delete_one({"_id": obj_id}) | ||
| return result.deleted_count == 1 | ||
|
|
||
| if result.deleted_count == 1: | ||
| if is_imported: | ||
| # Remove ID mapping for this group | ||
| # We do NOT remove the user mappings because users might be in other groups | ||
| # We do NOT remove import jobs because history is useful | ||
| await db.splitwise_id_mappings.delete_one( | ||
| {"entityType": "group", "splitwiserId": group_id} | ||
| ) | ||
|
|
||
| return True | ||
|
|
||
| return False |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
find backend -name "service.py" -type f | head -20Repository: Devasy/splitwiser
Length of output: 214
🏁 Script executed:
wc -l backend/app/groups/service.pyRepository: Devasy/splitwiser
Length of output: 94
🏁 Script executed:
sed -n '303,333p' backend/app/groups/service.pyRepository: Devasy/splitwiser
Length of output: 1265
🏁 Script executed:
# Search for MongoDB transaction/session usage in the codebase
rg "async.*with.*session|ClientSession|start_session" backend --type py -A 3 -B 1Repository: Devasy/splitwiser
Length of output: 43
🏁 Script executed:
# Look for delete_one, delete_many patterns and error handling
rg "delete_one|delete_many" backend/app --type py -B 2 -A 2 | head -100Repository: Devasy/splitwiser
Length of output: 4443
🏁 Script executed:
# Get the delete_group function with context
sed -n '280,340p' backend/app/groups/service.pyRepository: Devasy/splitwiser
Length of output: 2284
🏁 Script executed:
# Check if there's any transaction wrapper or error handling in the function
sed -n '260,345p' backend/app/groups/service.pyRepository: Devasy/splitwiser
Length of output: 3123
🏁 Script executed:
# Search for try-catch patterns in delete_group or similar cascade delete patterns
rg "async def delete_group|async def delete_expense" backend/app --type py -A 30 | head -80Repository: Devasy/splitwiser
Length of output: 5390
Wrap cascade delete operations in a MongoDB transaction or error-handling block to prevent partial data loss
The cascade deletions of expenses and settlements execute before the group deletion. If the group deletion fails at line 318, the financial records are already gone while the group persists—creating a data inconsistency. Implement either: (1) a MongoDB transaction session wrapping all four delete operations, or (2) error handling that rolls back cascade deletes if the group deletion fails.
🤖 Prompt for AI Agents
In `@backend/app/groups/service.py` around lines 303 - 333, The cascade deletes
for expenses and settlements run before deleting the group, risking partial data
loss if db.groups.delete_one fails; wrap all four operations
(db.expenses.delete_many, db.settlements.delete_many, db.groups.delete_one, and
conditional db.splitwise_id_mappings.delete_one) in a MongoDB transaction
session (e.g., start a session via db.client.start_session() and use
session.with_transaction or pass session=session to each delete_* call) so they
commit or abort atomically, using the existing group_id, obj_id and is_imported
variables; if transactions are unavailable in this environment, implement a
try/except that performs the group deletion first or records compensating
actions and rolls back the prior deletes on failure.
| except Exception as e: | ||
| logger.error(f"❌ Migration failed: {str(e)}") | ||
| raise |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Use explicit conversion flag for exception formatting.
Per Ruff RUF010, prefer {e!s} over str(e) in f-strings.
- logger.error(f"❌ Migration failed: {str(e)}")
+ logger.error(f"❌ Migration failed: {e!s}")📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| except Exception as e: | |
| logger.error(f"❌ Migration failed: {str(e)}") | |
| raise | |
| except Exception as e: | |
| logger.error(f"❌ Migration failed: {e!s}") | |
| raise |
🧰 Tools
🪛 Ruff (0.14.13)
59-59: Use explicit conversion flag
Replace with conversion flag
(RUF010)
🤖 Prompt for AI Agents
In `@backend/migrations/003_add_currency_to_groups.py` around lines 58 - 60, In
the except block handling exceptions in the migration (the except Exception as e
block that calls logger.error), change the f-string to use the explicit
conversion flag for the exception—replace f"❌ Migration failed: {str(e)}" with
f"❌ Migration failed: {e!s}" so Ruff RUF010 is satisfied; keep the logger.error
call and the subsequent raise intact.
| except Exception as e: | ||
| logger.error(f"❌ Verification failed: {str(e)}") | ||
| raise |
There was a problem hiding this comment.
🧹 Nitpick | 🔵 Trivial
Use explicit conversion flag for exception formatting.
Per Ruff RUF010, prefer {e!s} over str(e) in f-strings.
- logger.error(f"❌ Verification failed: {str(e)}")
+ logger.error(f"❌ Verification failed: {e!s}")🧰 Tools
🪛 Ruff (0.14.13)
95-95: Use explicit conversion flag
Replace with conversion flag
(RUF010)
🤖 Prompt for AI Agents
In `@backend/migrations/003_add_currency_to_groups.py` around lines 94 - 96,
Replace the f-string that formats the caught exception in the except
block—currently logger.error(f"❌ Verification failed: {str(e)}")—to use the
explicit conversion flag: logger.error(f"❌ Verification failed: {e!s}"); this
updates the exception formatting in the error log while keeping the surrounding
except Exception as e / raise behavior unchanged.
| # Add parent directory to path for imports | ||
| sys.path.insert(0, str(Path(__file__).parent.parent)) | ||
|
|
||
| from app.config import logger, settings # noqa: E402 |
There was a problem hiding this comment.
Remove unused noqa directive.
Ruff flags the # noqa: E402 as unused, so it can be safely dropped to keep lint noise down.
🔧 Suggested cleanup
-from app.config import logger, settings # noqa: E402
+from app.config import logger, settings📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| from app.config import logger, settings # noqa: E402 | |
| from app.config import logger, settings |
🧰 Tools
🪛 Ruff (0.14.13)
27-27: Unused noqa directive (non-enabled: E402)
Remove unused noqa directive
(RUF100)
🤖 Prompt for AI Agents
In `@backend/migrations/004_fix_member_userid_format.py` at line 27, The import
line "from app.config import logger, settings # noqa: E402" includes an unused
noqa directive; remove the trailing "# noqa: E402" so the line reads simply
"from app.config import logger, settings" and commit the change in the migration
module where that import appears to eliminate the lint warning.
| logger.info(f"Connecting to MongoDB at {settings.mongodb_url}") | ||
| client = AsyncIOMotorClient(settings.mongodb_url) |
There was a problem hiding this comment.
Avoid logging full MongoDB URI (may leak credentials).
Line 35 logs the raw connection string, which can contain username/password. Please redact before logging.
🔒 Proposed fix (redact credentials)
-import sys
+import sys
+import re
@@
-from app.config import logger, settings # noqa: E402
+from app.config import logger, settings
+
+_MONGO_URI_CREDENTIALS_RE = re.compile(r"//([^:/]+):([^@]+)@")
+
+def _redact_mongo_uri(uri: str) -> str:
+ return _MONGO_URI_CREDENTIALS_RE.sub(r"//\1:****@", uri)
@@
- logger.info(f"Connecting to MongoDB at {settings.mongodb_url}")
+ logger.info(
+ f"Connecting to MongoDB at {_redact_mongo_uri(settings.mongodb_url)}"
+ )🤖 Prompt for AI Agents
In `@backend/migrations/004_fix_member_userid_format.py` around lines 35 - 36, The
current logger.info call prints settings.mongodb_url which may include
credentials; modify the code so logger.info does not log the full URI: parse
settings.mongodb_url (used when creating AsyncIOMotorClient) and redact any
userinfo (username:password@) before logging, e.g., replace the userinfo portion
with a placeholder like "<redacted>" or remove it entirely, then log the
sanitized URI instead of settings.mongodb_url while still using
settings.mongodb_url unchanged for AsyncIOMotorClient.
| # Connect to MongoDB | ||
| logger.info(f"Connecting to MongoDB at {settings.mongodb_url}") | ||
| client = AsyncIOMotorClient(settings.mongodb_url) |
There was a problem hiding this comment.
Don’t log the raw MongoDB URL
Line 120 logs settings.mongodb_url, which may include credentials. Please redact or log only the host/DB name to avoid leaking secrets.
🔒 Suggested fix
- logger.info(f"Connecting to MongoDB at {settings.mongodb_url}")
+ logger.info("Connecting to MongoDB (URL redacted)")📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| # Connect to MongoDB | |
| logger.info(f"Connecting to MongoDB at {settings.mongodb_url}") | |
| client = AsyncIOMotorClient(settings.mongodb_url) | |
| # Connect to MongoDB | |
| logger.info("Connecting to MongoDB (URL redacted)") | |
| client = AsyncIOMotorClient(settings.mongodb_url) |
🤖 Prompt for AI Agents
In `@backend/migrations/005_init_cached_balances.py` around lines 119 - 121, The
logger currently prints the full MongoDB connection string via
settings.mongodb_url which can contain credentials; update the code around the
MongoDB connect logic (the logger.info call before AsyncIOMotorClient
instantiation) to avoid leaking secrets by either redacting credentials from
settings.mongodb_url or extracting and logging only safe parts (host and
database name) instead of the raw URL; ensure you still call
AsyncIOMotorClient(settings.mongodb_url) unchanged but change the logged value
to the sanitized/redacted string.
Add integration for importing data from Splitwise, including OAuth authentication and API endpoints, along with UI components for user interaction.
@coderabbitai review
Summary by CodeRabbit
New Features
Improvements
Documentation
Chores
Tests
✏️ Tip: You can customize this high-level summary in your review settings.