[WEB-1986] fix: remove the user favourites when archived a particular entity#5388
[WEB-1986] fix: remove the user favourites when archived a particular entity#5388
Conversation
WalkthroughThis update enhances data integrity by automatically deleting user favorites when cycles, modules, projects, and pages are archived. It also introduces a structured error handling system that centralizes error codes for improved maintainability. Overall, these modifications streamline the management of user favorites and bolster the application's robustness. Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant CycleModule
participant UserFavorite
User->>CycleModule: Archive Cycle
CycleModule->>UserFavorite: Delete associated favorites
UserFavorite->>UserFavorite: Confirm deletion
CycleModule->>User: Confirm Cycle archived
sequenceDiagram
participant User
participant ModuleModule
participant UserFavorite
User->>ModuleModule: Archive Module
ModuleModule->>UserFavorite: Delete associated favorites
UserFavorite->>UserFavorite: Confirm deletion
ModuleModule->>User: Confirm Module archived
Thank you for using CodeRabbit. We offer it for free to the OSS community and would appreciate your support in helping us grow. If you find it useful, would you consider giving us a shout-out on your favorite social media? TipsChatThere are 3 ways to chat with CodeRabbit:
Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (invoked as PR comments)
Additionally, you can add CodeRabbit Configuration File (
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 4
Outside diff range, codebase verification and nitpick comments (4)
web/core/components/workspace/sidebar/favorites/favorites-menu.tsx (2)
Line range hint
173-204: Simplify conditional rendering.The conditional rendering of
groupedFavoritescan be simplified by directly checking its length. This improves readability.- {Object.keys(groupedFavorites).length === 0 ? ( + {Object.keys(groupedFavorites).length ? (
36-36: Update variable names consistently across the codebase.The variable
favoriteMapis still being used in several files, includingweb/core/store/favorite.store.ts,web/core/components/workspace/sidebar/favorites/favorites.helpers.ts, andweb/core/components/workspace/sidebar/favorites/favorite-items/root.tsx. Ensure that all instances are updated togroupedFavoritesto maintain consistency and prevent potential issues.
web/core/store/favorite.store.tsweb/core/components/workspace/sidebar/favorites/favorites.helpers.tsweb/core/components/workspace/sidebar/favorites/favorite-items/root.tsxAnalysis chain
Update variable names consistently.
The variable
favoriteMaphas been updated togroupedFavorites. Ensure that all references tofavoriteMapare updated throughout the codebase to prevent any potential issues.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify all references to `favoriteMap` are updated to `groupedFavorites`. # Test: Search for occurrences of `favoriteMap`. Expect: No results. rg --type tsx 'favoriteMap'Length of output: 55
Script:
#!/bin/bash # Description: Verify all references to `favoriteMap` are updated to `groupedFavorites`. # Test: Search for occurrences of `favoriteMap`. Expect: No results. rg 'favoriteMap'Length of output: 4469
web/core/store/favorite.store.ts (1)
85-100: Optimize deep copy operation.The deep copy operation using
JSON.parse(JSON.stringify(...))can be inefficient for large datasets. Consider using a more efficient method if performance becomes an issue.web/core/components/workspace/sidebar/favorites/favorite-folder.tsx (1)
41-41: Instances offavoriteMapStill ExistThe renaming from
favoriteMaptogroupedFavoritesis incomplete. There are multiple instances offavoriteMapstill present in the codebase. Please ensure that all occurrences are updated togroupedFavoritesto prevent any potential errors.
- File:
web/core/store/favorite.store.ts- File:
web/core/components/workspace/sidebar/favorites/favorites-menu.tsx- File:
web/core/components/workspace/sidebar/favorites/favorites.helpers.ts- File:
web/core/components/workspace/sidebar/favorites/favorite-items/root.tsxAnalysis chain
Renaming
favoriteMaptogroupedFavorites.The renaming of
favoriteMaptogroupedFavoritesis consistent throughout the file. Ensure that all references are updated to prevent errors.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify all instances of `favoriteMap` have been renamed to `groupedFavorites`. # Test: Search for any remaining instances of `favoriteMap`. Expect: No results. rg --type typescript 'favoriteMap'Length of output: 69
Script:
#!/bin/bash # Description: Verify all instances of `favoriteMap` have been renamed to `groupedFavorites`. # Test: Search for any remaining instances of `favoriteMap`. Expect: No results. rg --type ts 'favoriteMap'Length of output: 4479
Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Files selected for processing (14)
- apiserver/plane/api/views/cycle.py (1 hunks)
- apiserver/plane/api/views/module.py (1 hunks)
- apiserver/plane/api/views/project.py (1 hunks)
- apiserver/plane/app/views/cycle/archive.py (1 hunks)
- apiserver/plane/app/views/issue/archive.py (2 hunks)
- apiserver/plane/app/views/issue/bulk_operations.py (4 hunks)
- apiserver/plane/app/views/module/archive.py (1 hunks)
- apiserver/plane/app/views/page/base.py (4 hunks)
- apiserver/plane/app/views/project/base.py (1 hunks)
- apiserver/plane/utils/error_codes.py (1 hunks)
- web/core/components/workspace/sidebar/favorites/favorite-folder.tsx (5 hunks)
- web/core/components/workspace/sidebar/favorites/favorites-menu.tsx (5 hunks)
- web/core/store/favorite.store.ts (11 hunks)
- web/core/store/project/project.store.ts (1 hunks)
Files skipped from review due to trivial changes (1)
- apiserver/plane/utils/error_codes.py
Additional context used
Biome
web/core/store/favorite.store.ts
[error] 240-240: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 317-321: Change to an optional chain.
Unsafe fix: Change to an optional chain.
(lint/complexity/useOptionalChain)
Additional comments not posted (20)
apiserver/plane/app/views/issue/bulk_operations.py (4)
24-24: Good practice: Centralized error codes.Importing
ERROR_CODEScentralizes error management, enhancing maintainability and readability. This is a positive change.
169-171: Ensure all error codes are defined.The error code
INVALID_ISSUE_TARGET_DATEis used here. Verify that it is defined inERROR_CODESto prevent runtime errors.Verification successful
Error code
INVALID_ISSUE_TARGET_DATEis defined. The error codeINVALID_ISSUE_TARGET_DATEis correctly defined inapiserver/plane/utils/error_codes.pywith the value 4102. There are no issues related to its definition.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify that `INVALID_ISSUE_TARGET_DATE` is defined in `ERROR_CODES`. # Test: Search for `INVALID_ISSUE_TARGET_DATE` in error_codes. Expect: At least one result. rg 'INVALID_ISSUE_TARGET_DATE' --type pyLength of output: 352
76-78: Ensure all error codes are defined.The error code
INVALID_ISSUE_DATESis used here. Verify that it is defined inERROR_CODESto prevent runtime errors.Verification successful
Error code
INVALID_ISSUE_DATESis defined. The error codeINVALID_ISSUE_DATESis correctly defined inERROR_CODESwith a value of 4100, ensuring no runtime errors related to undefined error codes.
- Location:
apiserver/plane/utils/error_codes.pyScripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify that `INVALID_ISSUE_DATES` is defined in `ERROR_CODES`. # Test: Search for `INVALID_ISSUE_DATES` in error_codes. Expect: At least one result. rg 'INVALID_ISSUE_DATES' --type pyLength of output: 344
133-135: Ensure all error codes are defined.The error code
INVALID_ISSUE_START_DATEis used here. Verify that it is defined inERROR_CODESto prevent runtime errors.Verification successful
Error code
INVALID_ISSUE_START_DATEis defined.The error code
INVALID_ISSUE_START_DATEis correctly defined inERROR_CODESwithinapiserver/plane/utils/error_codes.py. No further action is required.
- Definition found in
apiserver/plane/utils/error_codes.py.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify that `INVALID_ISSUE_START_DATE` is defined in `ERROR_CODES`. # Test: Search for `INVALID_ISSUE_START_DATE` in error_codes. Expect: At least one result. rg 'INVALID_ISSUE_START_DATE' --type pyLength of output: 348
web/core/store/favorite.store.ts (1)
21-21: EnsuregroupedFavoritesis correctly implemented.The
groupedFavoritesproperty has been added to the interface. Ensure that its implementation is consistent across the codebase.Verification successful
Implementation of
groupedFavoritesis consistent and correct.The
groupedFavoritesproperty is consistently used across multiple components as a computed property. Its implementation and usage align with its intended design, ensuring proper management of favorites.
File:
web/core/store/favorite.store.ts
- Declared as a computed property.
- Accessed using
get groupedFavorites().Components:
favorites-menu.tsxandfavorite-folder.tsx:
- Correctly access
groupedFavoritesfrom the store.- Utilize it for rendering and logic, consistent with its design.
Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify `groupedFavorites` is implemented consistently across the codebase. # Test: Search for `groupedFavorites` usage. Expect: Consistent implementation. rg --type ts 'groupedFavorites'Length of output: 1653
apiserver/plane/app/views/issue/archive.py (2)
50-50: Good practice: Centralized error codes.Importing
ERROR_CODEScentralizes error management, enhancing maintainability and readability. This is a positive change.
349-351: Ensure all error codes are defined.The error code
INVALID_ARCHIVE_STATE_GROUPis used here. Verify that it is defined inERROR_CODESto prevent runtime errors.Verification successful
Error code
INVALID_ARCHIVE_STATE_GROUPis defined.The error code
INVALID_ARCHIVE_STATE_GROUPis correctly defined in theERROR_CODESdictionary, preventing potential runtime errors. No further action is required.
- Definition found in
apiserver/plane/utils/error_codes.py.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify that `INVALID_ARCHIVE_STATE_GROUP` is defined in `ERROR_CODES`. # Test: Search for `INVALID_ARCHIVE_STATE_GROUP` in error_codes. Expect: At least one result. rg 'INVALID_ARCHIVE_STATE_GROUP' --type pyLength of output: 336
apiserver/plane/api/views/project.py (1)
380-383: Ensure deletion operation aligns with business logic.The deletion of user favorites associated with the project is correctly placed after the project is archived. Verify that this operation aligns with the overall business logic and does not inadvertently affect other functionalities.
web/core/components/workspace/sidebar/favorites/favorite-folder.tsx (2)
8-8: Use ofuniqByto filter duplicates.The addition of
uniqByeffectively filters out duplicate favorites based on theidproperty, which enhances data integrity and user experience.
319-326: EnsuregroupedFavoritesis correctly used.The use of
groupedFavoritesin the mapping of child favorites ensures that the updated data structure is consistently applied. Verify that this change does not affect the logic elsewhere in the component.Verification successful
groupedFavoritesis consistently used across components.The
groupedFavoritesvariable is used consistently in the codebase, primarily for managing favorite items and passing them as props. There are no indications of logic errors or misuse affecting other components.
- Files where
groupedFavoritesis used:
web/core/store/favorite.store.tsweb/core/components/workspace/sidebar/favorites/favorites-menu.tsxweb/core/components/workspace/sidebar/favorites/favorite-folder.tsxScripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify the usage of `groupedFavorites` in related components. # Test: Search for all uses of `groupedFavorites`. Expect: Consistent application across components. rg --type typescript 'groupedFavorites'Length of output: 74
Script:
#!/bin/bash # Description: Verify the usage of `groupedFavorites` in the codebase. # Test: Search for all occurrences of `groupedFavorites` in the codebase. rg 'groupedFavorites'Length of output: 1643
web/core/store/project/project.store.ts (1)
421-421: Remove project from favorites when archived.The addition of
removeFavoriteFromStoreensures that a project is removed from favorites when archived. This change aligns with the intended functionality and maintains data integrity.apiserver/plane/app/views/page/base.py (4)
489-493: Improved error handling for missing pages.The addition of a 404 response for missing pages improves error handling by providing clearer feedback to the client.
528-532: Structured error response for locked pages.The use of
ERROR_CODESfor locked pages provides a standardized error response, enhancing clarity and maintainability.
537-541: Structured error response for archived pages.The use of
ERROR_CODESfor archived pages ensures consistent and clear error handling.
308-313: Ensure deletion of user favorites is correctly implemented.The deletion of user favorites associated with a page is correctly placed before archiving. Verify that this operation aligns with the business logic and does not introduce unintended side effects.
apiserver/plane/app/views/module/archive.py (1)
578-583: LGTM! But verify the impact of theUserFavoritedeletion logic.The code changes are approved.
However, ensure that the deletion of
UserFavoriteentries does not have unintended side effects elsewhere in the application.apiserver/plane/app/views/cycle/archive.py (1)
610-615: LGTM! But verify the impact of theUserFavoritedeletion logic.The code changes are approved.
However, ensure that the deletion of
UserFavoriteentries does not have unintended side effects elsewhere in the application.Verification successful
Deletion of
UserFavoriteentries is a common practice across the codebase.The
UserFavorite.objects.filter(...).delete()pattern is consistently used in various modules and views for different entity types, indicating that this is a standard approach for handling user favorites. This suggests that the impact of such deletions is likely well-managed within the application.
- Occurrences found in multiple files such as
favorite.py,workspace/favorite.py,module/base.py,project/base.py,view/base.py,page/base.py,cycle/base.py,cycle/archive.py, and several others.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify the usage of `UserFavorite` deletion logic. # Test: Search for the `UserFavorite` deletion logic. Expect: Occurrences where the logic is used or referenced. rg --type python -A 5 $'UserFavorite.objects.filter'Length of output: 82
Script:
#!/bin/bash # Description: Verify the usage of `UserFavorite` deletion logic. # Test: Search for the `UserFavorite` deletion logic in Python files. rg --glob '*.py' -A 5 $'UserFavorite.objects.filter'Length of output: 12052
apiserver/plane/api/views/module.py (1)
637-642: LGTM! But verify the impact of theUserFavoritedeletion logic.The code changes are approved.
However, ensure that the deletion of
UserFavoriteentries does not have unintended side effects elsewhere in the application.apiserver/plane/app/views/project/base.py (1)
496-499: LGTM! But verify the impact of theUserFavoritedeletion logic.The code changes are approved.
However, ensure that the deletion of
UserFavoriteentries does not have unintended side effects elsewhere in the application.Verification successful
Verification Successful: Consistent Use of
UserFavoriteDeletion LogicThe deletion of
UserFavoriteentries is a common operation across various modules, indicating that the change is consistent with existing patterns in the codebase. No unintended side effects were found.
- Locations include modules, cycles, projects, views, and workspaces.
Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify the usage of `UserFavorite` deletion logic. # Test: Search for the `UserFavorite` deletion logic. Expect: Occurrences where the logic is used or referenced. rg --type python -A 5 $'UserFavorite.objects.filter'Length of output: 82
Script:
#!/bin/bash # Description: Verify the usage of `UserFavorite` deletion logic. # Test: Search for the `UserFavorite` deletion logic. Expect: Occurrences where the logic is used or referenced. rg 'UserFavorite.objects.filter' --glob '*.py' -A 5Length of output: 12052
apiserver/plane/api/views/cycle.py (1)
547-552: Verify the necessity of deleting user favorites.Ensure that removing user favorites when a cycle is archived aligns with the intended functionality. Confirm that this operation is necessary and doesn't inadvertently remove favorites that should remain for other purposes.
| import { combine } from "@atlaskit/pragmatic-drag-and-drop/combine"; | ||
| import { dropTargetForElements } from "@atlaskit/pragmatic-drag-and-drop/element/adapter"; | ||
| import { orderBy, uniqBy } from "lodash"; | ||
| import { orderBy } from "lodash"; |
There was a problem hiding this comment.
Remove unused import.
The import statement for orderBy from lodash is present but not used in the file. Consider removing it to clean up the code.
-import { orderBy } from "lodash";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.
| import { orderBy } from "lodash"; |
| const sourceId = source?.data?.id as string | undefined; | ||
| console.log({ sourceId }); | ||
| if (!sourceId || !favoriteMap[sourceId].parent) return; | ||
| if (!sourceId || !groupedFavorites[sourceId].parent) return; |
There was a problem hiding this comment.
Ensure groupedFavorites access is safe.
The code assumes that groupedFavorites[sourceId] exists. Consider adding a check to ensure sourceId is valid and groupedFavorites contains it to prevent runtime errors.
- if (!sourceId || !groupedFavorites[sourceId].parent) return;
+ if (!sourceId || !groupedFavorites[sourceId] || !groupedFavorites[sourceId].parent) return;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.
| if (!sourceId || !groupedFavorites[sourceId].parent) return; | |
| if (!sourceId || !groupedFavorites[sourceId] || !groupedFavorites[sourceId].parent) return; |
web/core/store/favorite.store.ts
Outdated
| return (this.cycleStore.cycleMap[entity_identifier].is_favorite = false); | ||
| case "project": | ||
| return (this.projectStore.projectMap[entity_identifier].is_favorite = false); | ||
| return (this.projectStore.projectMap[entity_identifier]!.is_favorite = false); |
There was a problem hiding this comment.
Avoid assignment in expressions.
The assignment within the return statement can be confusing. Consider refactoring to improve clarity.
- return (this.projectStore.projectMap[entity_identifier]!.is_favorite = false);
+ this.projectStore.projectMap[entity_identifier]!.is_favorite = false;
+ return;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.
| return (this.projectStore.projectMap[entity_identifier]!.is_favorite = false); | |
| this.projectStore.projectMap[entity_identifier]!.is_favorite = false; | |
| return; |
Tools
Biome
[error] 240-240: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
| projectData && | ||
| projectData.forEach(async (fav) => { | ||
| this.removeFavoriteFromStore(fav.entity_identifier!); | ||
| this.removeFavoriteEntityFromStore(fav.entity_identifier!, fav.entity_type); | ||
| }); |
There was a problem hiding this comment.
Use optional chaining for safety.
The code can be made safer by using optional chaining to avoid potential runtime errors if projectData is undefined.
- projectData &&
- projectData.forEach(async (fav) => {
+ projectData?.forEach(async (fav) => {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.
| projectData && | |
| projectData.forEach(async (fav) => { | |
| this.removeFavoriteFromStore(fav.entity_identifier!); | |
| this.removeFavoriteEntityFromStore(fav.entity_identifier!, fav.entity_type); | |
| }); | |
| projectData?.forEach(async (fav) => { | |
| this.removeFavoriteFromStore(fav.entity_identifier!); | |
| this.removeFavoriteEntityFromStore(fav.entity_identifier!, fav.entity_type); | |
| }); |
Tools
Biome
[error] 317-321: Change to an optional chain.
Unsafe fix: Change to an optional chain.
(lint/complexity/useOptionalChain)
There was a problem hiding this comment.
Actionable comments posted: 2
Outside diff range, codebase verification and nitpick comments (1)
web/core/store/favorite.store.ts (1)
Ensure safe access to
groupedFavoritesThe direct access to
groupedFavorites[favoriteId].childreninfavorite.store.tscould lead to runtime errors ifgroupedFavorites[favoriteId]is undefined. Consider adding a check to ensuregroupedFavorites[favoriteId]is defined before accessing its properties.
- Location:
web/core/store/favorite.store.ts: Access togroupedFavorites[favoriteId].childrenwithout a safety check.Analysis chain
Line range hint
265-283: EnsuregroupedFavoritesusage is safe.The
groupedFavoritesproperty is used to access children. Ensure that it is correctly populated and used safely to avoid runtime errors.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify safe usage of `groupedFavorites`. # Test: Search for `groupedFavorites` usage. Expect: Safe access and handling of potential undefined values. rg --type typescript 'this.groupedFavorites'Length of output: 79
Script:
#!/bin/bash # Description: Verify safe usage of `groupedFavorites`. # Test: Search for `groupedFavorites` usage in TypeScript files. Expect: Safe access and handling of potential undefined values. rg --type-add 'ts:*.ts' --type ts 'this.groupedFavorites'Length of output: 155
Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Files selected for processing (5)
- web/core/components/dropdowns/member/member-options.tsx (1 hunks)
- web/core/store/cycle.store.ts (1 hunks)
- web/core/store/favorite.store.ts (11 hunks)
- web/core/store/module.store.ts (1 hunks)
- web/core/store/pages/page.ts (1 hunks)
Files skipped from review due to trivial changes (1)
- web/core/components/dropdowns/member/member-options.tsx
Additional context used
Biome
web/core/store/favorite.store.ts
[error] 233-233: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 238-238: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 241-241: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 245-245: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 250-250: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 325-329: Change to an optional chain.
Unsafe fix: Change to an optional chain.
(lint/complexity/useOptionalChain)
Additional comments not posted (6)
web/core/store/favorite.store.ts (3)
325-329: Use optional chaining for safety.The code can be made safer by using optional chaining to avoid potential runtime errors if
projectDatais undefined.- projectData && - projectData.forEach(async (fav) => { + projectData?.forEach(async (fav) => {Tools
Biome
[error] 325-329: Change to an optional chain.
Unsafe fix: Change to an optional chain.
(lint/complexity/useOptionalChain)
61-61: EnsuregroupedFavoritesis properly computed.The
groupedFavoritesis marked as a computed property. Ensure it is correctly computed and used without side effects.Verification successful
groupedFavoritesis correctly computed and used without side effects.The
groupedFavoritesproperty is defined as a computed property and is used appropriately across the codebase. It is computed by transformingfavoriteMapinto a structured object, and its usage in components is read-only, focusing on rendering and UI logic.
- Definition: The getter method for
groupedFavoritesprocessesfavoriteMapto create a structured object without side effects.- Usage: In components like
favorites-menu.tsxandfavorite-folder.tsx, it is used for rendering and conditional logic, ensuring no side effects occur.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify computation of `groupedFavorites`. # Test: Search for `groupedFavorites` computation. Expect: Proper computation without side effects. rg --type typescript 'get groupedFavorites'Length of output: 80
Script:
#!/bin/bash # Description: Verify computation of `groupedFavorites`. # Search for the definition of `groupedFavorites` as a computed property in TypeScript files. rg 'groupedFavorites' --type-add 'ts:*.ts' --type ts -A 5 # Search for the usage of `groupedFavorites` in the codebase to ensure it is used without side effects. rg 'groupedFavorites' --type-add 'ts:*.ts' --type ts -A 5Length of output: 15423
21-21: EnsuregroupedFavoritesis correctly initialized.The
groupedFavoritesproperty is introduced in the interface and class. Verify that it is correctly initialized and used throughout the codebase.web/core/store/pages/page.ts (1)
446-446: Ensure removal of page from favorites is correct.The conditional statement checks if the page is in the favorites before removing it. Verify that this logic integrates well with the existing favorite management system.
Verification successful
Integration of
removeFavoriteFromStoreis correct.The
removeFavoriteFromStoremethod is well-integrated with the favorite management system, handling the removal of favorites appropriately by updating relevant data structures. The conditional check ensures the method is invoked only when the entity is present in the favorites. No issues found.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify removal of page from favorites when archived. # Test: Search for `removeFavoriteFromStore` usage in the context of pages. Expect: Proper integration with the favorite management system. rg --type typescript 'removeFavoriteFromStore.*this\.id'Length of output: 93
Script:
#!/bin/bash # Description: Verify removal of page from favorites when archived. # Test: Search for `removeFavoriteFromStore` usage in the context of pages. Expect: Proper integration with the favorite management system. rg 'removeFavoriteFromStore.*this\.id'Length of output: 179
Script:
#!/bin/bash # Description: Find the implementation of `removeFavoriteFromStore` to verify its integration with the favorite management system. # Search for the implementation of `removeFavoriteFromStore`. ast-grep --lang typescript --pattern 'removeFavoriteFromStore($_)'Length of output: 68
Script:
#!/bin/bash # Description: Search for the definition of `removeFavoriteFromStore` to verify its integration with the favorite management system. # Search for the definition of `removeFavoriteFromStore`. rg 'removeFavoriteFromStore' -A 10Length of output: 8653
web/core/store/module.store.ts (1)
560-560: Ensure removal of module from favorites is correct.The conditional statement checks if the module is in the favorites before removing it. Verify that this logic integrates well with the existing favorite management system.
Verification successful
Removal of module from favorites is correctly integrated.
The logic to remove a module from favorites is appropriately safeguarded by checking its presence in the
entityMapbefore invokingremoveFavoriteFromStore. This ensures proper integration with the favorite management system.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify removal of module from favorites when archived. # Test: Search for `removeFavoriteFromStore` usage in the context of modules. Expect: Proper integration with the favorite management system. rg --type typescript 'removeFavoriteFromStore.*moduleId'Length of output: 93
Script:
#!/bin/bash # Description: Verify removal of module from favorites when archived. # Test: Search for `removeFavoriteFromStore` usage in the context of modules. Expect: Proper integration with the favorite management system. rg 'removeFavoriteFromStore.*moduleId' --glob '*.ts'Length of output: 350
web/core/store/cycle.store.ts (1)
627-627: Ensure removal of cycle from favorites is correct.The conditional statement checks if the cycle is in the favorites before removing it. Verify that this logic integrates well with the existing favorite management system.
Verification successful
Verified: Removal of cycle from favorites is correctly integrated.
The
removeFavoriteFromStoremethod is used with a conditional check to ensure a cycle is in the favorites before removal. This logic is consistent and appears to be well-integrated with the favorite management system.Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify removal of cycle from favorites when archived. # Test: Search for `removeFavoriteFromStore` usage in the context of cycles. Expect: Proper integration with the favorite management system. rg --type typescript 'removeFavoriteFromStore.*cycleId'Length of output: 92
Script:
#!/bin/bash # Description: Verify removal of cycle from favorites when archived. # Test: Search for `removeFavoriteFromStore` usage in TypeScript files. Expect: Proper integration with the favorite management system. rg 'removeFavoriteFromStore.*cycleId' --glob '*.ts' -A 5Length of output: 849
| get groupedFavorites() { | ||
| const data: { [favoriteId: string]: IFavorite } = JSON.parse(JSON.stringify(this.favoriteMap)); | ||
|
|
||
| Object.values(data).forEach((fav) => { | ||
| if (fav.parent && data[fav.parent]) { | ||
| if (data[fav.parent].children) { | ||
| if (!data[fav.parent].children.some((f) => f.id === fav.id)) { | ||
| data[fav.parent].children.push(fav); | ||
| } | ||
| } else { | ||
| data[fav.parent].children = [fav]; | ||
| } | ||
| } | ||
| }); | ||
| return data; | ||
| } |
There was a problem hiding this comment.
Optimize groupedFavorites computation.
The computation of groupedFavorites could be optimized by reducing the number of operations within the loop. Consider using a map to store parent-child relationships more efficiently.
get groupedFavorites() {
const data: { [favoriteId: string]: IFavorite } = JSON.parse(JSON.stringify(this.favoriteMap));
const parentMap: { [parentId: string]: IFavorite[] } = {};
Object.values(data).forEach((fav) => {
if (fav.parent) {
if (!parentMap[fav.parent]) {
parentMap[fav.parent] = [];
}
parentMap[fav.parent].push(fav);
}
});
Object.keys(parentMap).forEach((parentId) => {
data[parentId].children = parentMap[parentId];
});
return data;
}| this.viewStore.viewMap[entity_identifier] && (this.viewStore.viewMap[entity_identifier].is_favorite = false) | ||
| ); | ||
| case "module": | ||
| return (this.moduleStore.moduleMap[entity_identifier].is_favorite = false); | ||
| return ( | ||
| this.moduleStore.moduleMap[entity_identifier] && | ||
| (this.moduleStore.moduleMap[entity_identifier].is_favorite = false) | ||
| ); | ||
| case "page": | ||
| return (this.pageStore.data[entity_identifier].is_favorite = false); | ||
| return this.pageStore.data[entity_identifier] && (this.pageStore.data[entity_identifier].is_favorite = false); | ||
| case "cycle": | ||
| return (this.cycleStore.cycleMap[entity_identifier].is_favorite = false); | ||
| return ( | ||
| this.cycleStore.cycleMap[entity_identifier] && | ||
| (this.cycleStore.cycleMap[entity_identifier].is_favorite = false) | ||
| ); | ||
| case "project": | ||
| return (this.projectStore.projectMap[entity_identifier].is_favorite = false); | ||
| return ( | ||
| this.projectStore.projectMap[entity_identifier] && | ||
| (this.projectStore.projectMap[entity_identifier].is_favorite = false) | ||
| ); |
There was a problem hiding this comment.
Avoid assignment in expressions.
Assignments within expressions can be confusing and error-prone. Refactor to separate the assignment from the return statement for clarity.
- return (
- this.viewStore.viewMap[entity_identifier] && (this.viewStore.viewMap[entity_identifier].is_favorite = false)
- );
+ if (this.viewStore.viewMap[entity_identifier]) {
+ this.viewStore.viewMap[entity_identifier].is_favorite = false;
+ }
+ return;Apply similar changes to other cases in this switch statement.
Committable suggestion was skipped due to low confidence.
Tools
Biome
[error] 233-233: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 238-238: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 241-241: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 245-245: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
[error] 250-250: The assignment should not be in an expression.
The use of assignments in expressions is confusing.
Expressions are often considered as side-effect free.(lint/suspicious/noAssignInExpressions)
NarayanBavisetti
changed the base branch from
preview
to
chore/project-archive
web/core/components/workspace/sidebar/favorites/favorites-menu.tsx
Outdated
Show resolved
Hide resolved
…into fix-fav-archive
There was a problem hiding this comment.
Actionable comments posted: 0
Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Files selected for processing (1)
- web/core/components/workspace/sidebar/favorites/favorites-menu.tsx (5 hunks)
Files skipped from review as they are similar to previous changes (1)
- web/core/components/workspace/sidebar/favorites/favorites-menu.tsx
4 participants
fix:
This pull request implements the functionality to automatically remove user favourites when a project is archived.
Issue Link: WEB-1986
Summary by CodeRabbit
New Features
FavoriteFolderandSidebarFavoritesMenucomponents, improving duplicate management and rendering logic.Bug Fixes
Refactor
FavoriteStore,ProjectStore, andCycleStore, optimizing performance and reducing complexity.SidebarFavoritesMenuto streamline the management and display of favorites.Chores