@finos/legend-application-marketplace 0.2.3 → 0.2.4

package/src/pages/Lakehouse/searchResults/LegendMarketplaceFieldSearchResults.tsx

@@ -0,0 +1,380 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Container, Paper, Typography } from '@mui/material';
+import { observer } from 'mobx-react-lite';
+import { flowResult } from 'mobx';
+import { useCallback, useEffect, useRef } from 'react';
+import { useSyncStateAndSearchParam } from '@finos/legend-application';
+import { useSearchParams } from '@finos/legend-application/browser';
+import { isNonEmptyString } from '@finos/legend-shared';
+import {
+  CubesLoadingIndicator,
+  CubesLoadingIndicatorIcon,
+} from '@finos/legend-art';
+import { DATAPRODUCT_TYPE } from '@finos/legend-extension-dsl-data-product';
+import {
+  LEGEND_MARKETPLACE_FIELD_SEARCH_RESULTS_QUERY_PARAM_TOKEN,
+  generateLakehouseSearchResultsRoute,
+} from '../../../__lib__/LegendMarketplaceNavigation.js';
+import {
+  LEGEND_MARKETPLACE_PAGE,
+  LegendMarketplaceTelemetryHelper,
+} from '../../../__lib__/LegendMarketplaceTelemetryHelper.js';
+import {
+  useLegendMarketplaceFieldSearchResultsStore,
+  withLegendMarketplaceFieldSearchResultsStore,
+} from '../../../application/providers/LegendMarketplaceFieldSearchResultsStoreProvider.js';
+import { FieldSearchFiltersPanel } from '../../../components/FieldSearchFiltersPanel/FieldSearchFiltersPanel.js';
+import { FieldSearchResultListRow } from '../../../components/MarketplaceCard/FieldSearchResultListItem.js';
+import { LegendMarketplaceSearchBar } from '../../../components/SearchBar/LegendMarketplaceSearchBar.js';
+import { PaginationControls } from '../../../components/Pagination/PaginationControls.js';
+import { LegendMarketplacePage } from '../../LegendMarketplacePage.js';
+import { DataProductTypeFilter } from '../../../stores/lakehouse/LegendMarketplaceSearchResultsStore.js';
+import type { LegendMarketplaceFieldSearchResultsStore } from '../../../stores/lakehouse/LegendMarketplaceFieldSearchResultsStore.js';
+import { type FieldSearchDataProductEntry } from '../../../stores/lakehouse/fieldSearch/FieldSearchResultState.js';
+
+const FieldSearchResultsContent = observer(
+  (props: {
+    fieldSearchResultsStore: LegendMarketplaceFieldSearchResultsStore;
+    handlePageChange: (page: number) => void;
+    handleItemsPerPageChange: (itemsPerPage: number) => void;
+    handleToggleExpandRow: (rowId: string) => void;
+    handleOpenDataProduct: (dataProduct: FieldSearchDataProductEntry) => void;
+  }) => {
+    const {
+      fieldSearchResultsStore,
+      handlePageChange,
+      handleItemsPerPageChange,
+      handleToggleExpandRow,
+      handleOpenDataProduct,
+    } = props;
+
+    if (fieldSearchResultsStore.isLoading) {
+      return (
+        <div className="marketplace-lakehouse-search-results__loading-container">
+          <CubesLoadingIndicator isLoading={true}>
+            <CubesLoadingIndicatorIcon />
+          </CubesLoadingIndicator>
+        </div>
+      );
+    }
+
+    if (fieldSearchResultsStore.hasFailed) {
+      return (
+        <div className="marketplace-lakehouse-search-results__empty-state">
+          <Typography
+            variant="h5"
+            className="marketplace-lakehouse-search-results__empty-state__title"
+          >
+            Field search failed
+          </Typography>
+          <Typography
+            variant="body1"
+            className="marketplace-lakehouse-search-results__empty-state__message"
+          >
+            {fieldSearchResultsStore.errorMessage}
+          </Typography>
+        </div>
+      );
+    }
+
+    if (
+      fieldSearchResultsStore.hasActiveFilters &&
+      fieldSearchResultsStore.totalItems === 0
+    ) {
+      return (
+        <div className="marketplace-lakehouse-search-results__empty-state">
+          <Typography
+            variant="h5"
+            className="marketplace-lakehouse-search-results__empty-state__title"
+          >
+            No fields match the current filters
+          </Typography>
+          <Typography
+            variant="body1"
+            className="marketplace-lakehouse-search-results__empty-state__message"
+          >
+            Clear one or more filters to see results again.
+          </Typography>
+        </div>
+      );
+    }
+
+    if (
+      !fieldSearchResultsStore.hasActiveFilters &&
+      isNonEmptyString(fieldSearchResultsStore.searchQuery) &&
+      fieldSearchResultsStore.totalItems === 0
+    ) {
+      return (
+        <div className="marketplace-lakehouse-search-results__empty-state">
+          <Typography
+            variant="h5"
+            className="marketplace-lakehouse-search-results__empty-state__title"
+          >
+            No fields found
+          </Typography>
+          <Typography
+            variant="body1"
+            className="marketplace-lakehouse-search-results__empty-state__message"
+          >
+            Try a broader query or switch back to product search.
+          </Typography>
+        </div>
+      );
+    }
+
+    if (fieldSearchResultsStore.tableRows.length === 0) {
+      return null;
+    }
+
+    return (
+      <>
+        <Paper
+          elevation={1}
+          className="marketplace-lakehouse-field-search-results__list"
+        >
+          <div className="marketplace-lakehouse-field-search-results__list-header">
+            <Typography className="marketplace-lakehouse-field-search-results__list-header-cell">
+              Field Name
+            </Typography>
+            <Typography className="marketplace-lakehouse-field-search-results__list-header-cell">
+              Type
+            </Typography>
+            <Typography className="marketplace-lakehouse-field-search-results__list-header-cell">
+              Description
+            </Typography>
+            <Typography className="marketplace-lakehouse-field-search-results__list-header-cell">
+              Data Products
+            </Typography>
+          </div>
+          <div className="marketplace-lakehouse-field-search-results__list-body">
+            {fieldSearchResultsStore.tableRows.map((row) => (
+              <FieldSearchResultListRow
+                key={row.id}
+                fieldSearchResultState={row}
+                expanded={fieldSearchResultsStore.isRowExpanded(row.id)}
+                onToggleExpanded={handleToggleExpandRow}
+                onOpenDataProduct={handleOpenDataProduct}
+              />
+            ))}
+          </div>
+        </Paper>
+        <PaginationControls
+          totalItems={fieldSearchResultsStore.totalItems}
+          itemsPerPage={fieldSearchResultsStore.itemsPerPage}
+          page={fieldSearchResultsStore.page}
+          onPageChange={handlePageChange}
+          onItemsPerPageChange={handleItemsPerPageChange}
+          disabled={fieldSearchResultsStore.isLoading}
+        />
+      </>
+    );
+  },
+);
+
+const LegendMarketplaceFieldSearchResultsPage = observer(() => {
+  const fieldSearchResultsStore = useLegendMarketplaceFieldSearchResultsStore();
+  const marketplaceBaseStore = fieldSearchResultsStore.marketplaceBaseStore;
+  const applicationStore = marketplaceBaseStore.applicationStore;
+  const [searchParams, setSearchParams] = useSearchParams();
+  const pageRef = useRef<HTMLDivElement>(null);
+
+  useSyncStateAndSearchParam(
+    fieldSearchResultsStore.searchQuery,
+    useCallback(
+      (val: string | null) => {
+        if (val === null) {
+          return;
+        }
+        fieldSearchResultsStore.setSearchQuery(val);
+      },
+      [fieldSearchResultsStore],
+    ),
+    LEGEND_MARKETPLACE_FIELD_SEARCH_RESULTS_QUERY_PARAM_TOKEN.QUERY,
+    searchParams.get(
+      LEGEND_MARKETPLACE_FIELD_SEARCH_RESULTS_QUERY_PARAM_TOKEN.QUERY,
+    ),
+    setSearchParams,
+    useCallback(() => true, []),
+  );
+
+  useEffect(() => {
+    flowResult(fieldSearchResultsStore.executeSearch()).catch(
+      applicationStore.alertUnhandledError,
+    );
+  }, [
+    applicationStore,
+    fieldSearchResultsStore,
+    fieldSearchResultsStore.searchQuery,
+  ]);
+
+  const handlePageChange = useCallback(
+    (page: number) => {
+      pageRef.current?.scrollIntoView({ behavior: 'smooth' });
+      flowResult(fieldSearchResultsStore.changePageAndFetch(page)).catch(
+        applicationStore.alertUnhandledError,
+      );
+    },
+    [fieldSearchResultsStore, applicationStore],
+  );
+
+  const handleItemsPerPageChange = useCallback(
+    (itemsPerPage: number) => {
+      flowResult(
+        fieldSearchResultsStore.changeItemsPerPageAndFetch(itemsPerPage),
+      ).catch(applicationStore.alertUnhandledError);
+    },
+    [fieldSearchResultsStore, applicationStore],
+  );
+
+  const handleToggleProductType = useCallback(
+    (productType: DataProductTypeFilter) => {
+      flowResult(
+        fieldSearchResultsStore.toggleProductTypeAndFetch(productType),
+      ).catch(applicationStore.alertUnhandledError);
+    },
+    [fieldSearchResultsStore, applicationStore],
+  );
+
+  const handleClearFilters = useCallback(() => {
+    flowResult(fieldSearchResultsStore.clearAllFiltersAndFetch()).catch(
+      applicationStore.alertUnhandledError,
+    );
+  }, [fieldSearchResultsStore, applicationStore]);
+
+  const handleSearch = useCallback(
+    (
+      query: string | undefined,
+      useProducerSearch: boolean,
+      useFieldSearch: boolean,
+    ) => {
+      if (!isNonEmptyString(query)) {
+        return;
+      }
+      if (!useFieldSearch) {
+        applicationStore.navigationService.navigator.goToLocation(
+          generateLakehouseSearchResultsRoute(query, useProducerSearch),
+        );
+        return;
+      }
+      fieldSearchResultsStore.setSearchQuery(query);
+      LegendMarketplaceTelemetryHelper.logEvent_SearchQuery(
+        applicationStore.telemetryService,
+        query,
+        false,
+        LEGEND_MARKETPLACE_PAGE.SEARCH_RESULTS_PAGE,
+        true,
+      );
+    },
+    [applicationStore, fieldSearchResultsStore],
+  );
+
+  const handleOpenDataProduct = useCallback(
+    (dataProduct: FieldSearchDataProductEntry) => {
+      LegendMarketplaceTelemetryHelper.logEvent_ClickingDataProductCard(
+        applicationStore.telemetryService,
+        {
+          origin:
+            dataProduct.productType === DataProductTypeFilter.LEGACY
+              ? {
+                  type: DATAPRODUCT_TYPE.SDLC,
+                  groupId: dataProduct.groupId,
+                  artifactId: dataProduct.artifactId,
+                  versionId: dataProduct.versionId,
+                  path: dataProduct.entityPath,
+                }
+              : {
+                  type: DATAPRODUCT_TYPE.ADHOC,
+                },
+          dataProductId: dataProduct.dataProductId,
+          name: dataProduct.name,
+          deploymentId: dataProduct.deploymentId,
+        },
+        LEGEND_MARKETPLACE_PAGE.SEARCH_RESULTS_PAGE,
+      );
+      applicationStore.navigationService.navigator.visitAddress(
+        applicationStore.navigationService.navigator.generateAddress(
+          dataProduct.path,
+        ),
+      );
+    },
+    [applicationStore],
+  );
+
+  const handleToggleExpandRow = useCallback(
+    (rowId: string) => {
+      fieldSearchResultsStore.toggleExpandRow(rowId);
+    },
+    [fieldSearchResultsStore],
+  );
+
+  return (
+    <LegendMarketplacePage className="marketplace-lakehouse-search-results marketplace-lakehouse-field-search-results">
+      <div ref={pageRef} />
+      <Container className="marketplace-lakehouse-search-results__search-container">
+        <LegendMarketplaceSearchBar
+          showSettings={true}
+          onSearch={handleSearch}
+          stateSearchQuery={fieldSearchResultsStore.searchQuery}
+          stateUseProducerSearch={false}
+          stateUseFieldSearch={true}
+          placeholder="Search Marketplace fields"
+          className="marketplace-lakehouse-search-results__search-bar"
+          enableAutosuggest={false}
+        />
+      </Container>
+      <div className="legend-marketplace-search-results__sort-bar">
+        <div className="legend-marketplace-search-results__sort-bar__container">
+          <Typography
+            variant="h4"
+            className="marketplace-lakehouse-search-results__subtitles"
+          >
+            {fieldSearchResultsStore.totalFieldMatches} Fields
+          </Typography>
+        </div>
+      </div>
+      <Container
+        maxWidth="xxxl"
+        className="marketplace-lakehouse-search-results__results-container"
+      >
+        <div className="marketplace-lakehouse-search-results__results-layout">
+          <div className="marketplace-lakehouse-search-results__sidebar">
+            <FieldSearchFiltersPanel
+              store={fieldSearchResultsStore}
+              onToggleProductType={handleToggleProductType}
+              onClearFilters={handleClearFilters}
+            />
+          </div>
+          <div className="marketplace-lakehouse-search-results__main-content">
+            <FieldSearchResultsContent
+              fieldSearchResultsStore={fieldSearchResultsStore}
+              handlePageChange={handlePageChange}
+              handleItemsPerPageChange={handleItemsPerPageChange}
+              handleToggleExpandRow={handleToggleExpandRow}
+              handleOpenDataProduct={handleOpenDataProduct}
+            />
+          </div>
+        </div>
+      </Container>
+    </LegendMarketplacePage>
+  );
+});
+
+export const LegendMarketplaceFieldSearchResults =
+  withLegendMarketplaceFieldSearchResultsStore(
+    LegendMarketplaceFieldSearchResultsPage,
+  );

package/src/pages/Lakehouse/searchResults/LegendMarketplaceSearchResults.tsx

@@ -45,7 +45,10 @@ import {
   SearchResultsViewMode,
   type LegendMarketplaceSearchResultsStore,
 } from '../../../stores/lakehouse/LegendMarketplaceSearchResultsStore.js';
-import { LEGEND_MARKETPLACE_LAKEHOUSE_SEARCH_RESULTS_QUERY_PARAM_TOKEN } from '../../../__lib__/LegendMarketplaceNavigation.js';
+import {
+  generateFieldSearchResultsRoute,
+  LEGEND_MARKETPLACE_LAKEHOUSE_SEARCH_RESULTS_QUERY_PARAM_TOKEN,
+} from '../../../__lib__/LegendMarketplaceNavigation.js';
 import { LegendMarketplaceSearchBar } from '../../../components/SearchBar/LegendMarketplaceSearchBar.js';
 import { LegendMarketplacePage } from '../../LegendMarketplacePage.js';
 import { useAuth } from 'react-oidc-context';
@@ -265,8 +268,22 @@ export const LegendMarketplaceSearchResults =
       const handleSearch = (
         _query: string | undefined,
         _useProducerSearch: boolean,
+        _useFieldSearch: boolean,
       ): void => {
         if (isNonEmptyString(_query)) {
+          if (_useFieldSearch) {
+            applicationStore.navigationService.navigator.goToLocation(
+              generateFieldSearchResultsRoute(_query),
+            );
+            LegendMarketplaceTelemetryHelper.logEvent_SearchQuery(
+              applicationStore.telemetryService,
+              _query,
+              false,
+              LEGEND_MARKETPLACE_PAGE.SEARCH_RESULTS_PAGE,
+              true,
+            );
+            return;
+          }
           searchResultsStore.setSearchQuery(_query);
           searchResultsStore.setUseProducerSearch(_useProducerSearch);
           LegendMarketplaceTelemetryHelper.logEvent_SearchQuery(
@@ -349,6 +366,7 @@ export const LegendMarketplaceSearchResults =
               onSearch={handleSearch}
               stateSearchQuery={searchResultsStore.searchQuery}
               stateUseProducerSearch={searchResultsStore.useProducerSearch}
+              stateUseFieldSearch={false}
               placeholder="Search Legend Marketplace"
               className="marketplace-lakehouse-search-results__search-bar"
               enableAutosuggest={false}

package/src/pages/TerminalsAddons/LegendMarketplaceTerminalsAddons.tsx

@@ -311,10 +311,14 @@ export const LegendMarketplaceVendorData = withLegendMarketplaceVendorDataStore(
                 setUserValue={(_user: LegendUser): void => {
                   if (!_user.id) {
                     marketPlaceVendorDataStore.resetSelectedUser();
-                    cartStore.setTargetUser(undefined);
+                    flowResult(cartStore.setTargetUser(undefined)).catch(
+                      marketplaceStore.applicationStore.alertUnhandledError,
+                    );
                   } else {
                     marketPlaceVendorDataStore.setSelectedUser(_user);
-                    cartStore.setTargetUser(_user.id);
+                    flowResult(cartStore.setTargetUser(_user.id)).catch(
+                      marketplaceStore.applicationStore.alertUnhandledError,
+                    );
                   }
                 }}
                 userSearchService={marketplaceStore.userSearchService}

package/src/stores/cart/CartStore.ts

@@ -14,7 +14,14 @@
  * limitations under the License.
  */
 
-import { makeObservable, observable, action, flow, flowResult } from 'mobx';
+import {
+  makeObservable,
+  observable,
+  action,
+  flow,
+  flowResult,
+  computed,
+} from 'mobx';
 import {
   LogEvent,
   type GeneratorFn,
@@ -22,6 +29,7 @@ import {
   ActionState,
 } from '@finos/legend-shared';
 import {
+  TerminalItemType,
   type CartItem,
   type CartItemRequest,
   type CartItemResponse,
@@ -64,8 +72,10 @@ export class CartStore {
       businessReason: observable,
       open: observable,
       cartSummary: observable,
+      cartUser: computed,
+      cartItemIds: computed,
       setOpen: action,
-      setTargetUser: action,
+      setTargetUser: flow,
       setBusinessReason: action,
       initialize: flow,
       submitOrder: flow,
@@ -81,12 +91,50 @@ export class CartStore {
     return this.baseStore.applicationStore.identityService.currentUser;
   }
 
+  get cartUser(): string {
+    return this.targetUser ?? this.currentUser;
+  }
+
+  get cartItemIds(): Set<number> {
+    const ids = new Set<number>();
+    for (const vendorProfileId in this.items) {
+      if (Object.prototype.hasOwnProperty.call(this.items, vendorProfileId)) {
+        const cartItems = this.items[Number(vendorProfileId)];
+        if (cartItems) {
+          for (const item of cartItems) {
+            ids.add(item.id);
+          }
+        }
+      }
+    }
+    return ids;
+  }
+
   setOpen(val: boolean): void {
     this.open = val;
   }
 
-  setTargetUser(val: string | undefined): void {
+  *setTargetUser(val: string | undefined): GeneratorFn<void> {
+    this.loadingState.inProgress();
     this.targetUser = val;
+    this.items = {};
+    this.cartSummary = {
+      total_items: 0,
+      total_cost: 0,
+      formatted_total_cost: '$0.00',
+    };
+    this.businessReason = undefined;
+    try {
+      yield flowResult(this.refresh());
+      this.loadingState.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.baseStore.applicationStore.logService.error(
+        LogEvent.create(APPLICATION_EVENT.IDENTITY_AUTO_FETCH__FAILURE),
+        `Failed to load cart for user: ${error.message}`,
+      );
+      this.loadingState.fail();
+    }
   }
 
   setBusinessReason(val: string | undefined): void {
@@ -94,23 +142,39 @@ export class CartStore {
   }
 
   isItemInCart(itemId: number): boolean {
+    return this.cartItemIds.has(itemId);
+  }
+
+  /**
+   * Returns the add-on items that depend on the given cart item.
+   * When a Terminal is deleted, its associated add-ons (same vendor) must also be removed.
+   */
+  getDependentAddOns(cartId: number): CartItem[] {
     for (const vendorProfileId in this.items) {
       if (Object.prototype.hasOwnProperty.call(this.items, vendorProfileId)) {
         const cartItems = this.items[Number(vendorProfileId)];
-        if (cartItems?.some((item) => item.id === itemId)) {
-          return true;
+        if (cartItems) {
+          const target = cartItems.find((item) => item.cartId === cartId);
+          if (target && target.category === TerminalItemType.TERMINAL) {
+            return cartItems.filter(
+              (item) =>
+                item.cartId !== cartId &&
+                item.category === TerminalItemType.ADD_ON,
+            );
+          }
         }
       }
     }
-    return false;
+    return [];
   }
 
   *addToCartWithAPI(cartItemData: CartItemRequest): GeneratorFn<{
     success: boolean;
     recommendations?: TerminalResult[];
     message: string;
+    totalCount?: number | null;
   }> {
-    const user = this.currentUser;
+    const user = this.cartUser;
 
     if (!user) {
       const message = 'User not authenticated';
@@ -125,11 +189,6 @@ export class CartStore {
         cartItemData,
       )) as CartItemResponse;
 
-      this.cartSummary =
-        (yield this.baseStore.marketplaceServerClient.getCartSummary(
-          user,
-        )) as CartSummary;
-
       yield flowResult(this.refresh());
 
       const responseMessage: string = response.message;
@@ -159,6 +218,7 @@ export class CartStore {
         success: true,
         recommendations,
         message: responseMessage,
+        totalCount: response.total_count,
       };
     } catch (error) {
       assertErrorThrown(error);
@@ -195,7 +255,7 @@ export class CartStore {
     }
     this.initState.inProgress();
     try {
-      this.refresh();
+      yield flowResult(this.refresh());
       this.initState.complete();
     } catch (error) {
       assertErrorThrown(error);
@@ -208,7 +268,7 @@ export class CartStore {
   }
 
   *refresh(): GeneratorFn<void> {
-    const user = this.currentUser;
+    const user = this.cartUser;
     if (!user) {
       return;
     }
@@ -231,31 +291,6 @@ export class CartStore {
     }
   }
 
-  *getCartSummary(): GeneratorFn<void> {
-    const user = this.currentUser;
-    if (!user) {
-      return;
-    }
-    try {
-      const cartSummary =
-        (yield this.baseStore.marketplaceServerClient.getCartSummary(
-          user,
-        )) as CartSummary;
-      this.cartSummary = cartSummary;
-    } catch (error) {
-      assertErrorThrown(error);
-      this.cartSummary = {
-        total_items: 0,
-        total_cost: 0,
-        formatted_total_cost: '$0.00',
-      };
-      this.baseStore.applicationStore.logService.error(
-        LogEvent.create(APPLICATION_EVENT.IDENTITY_AUTO_FETCH__FAILURE),
-        `Failed to get cart summary: ${error.message}`,
-      );
-    }
-  }
-
   *submitOrder(): GeneratorFn<void> {
     if (!this.businessReason) {
       toastManager.warning(
@@ -277,18 +312,16 @@ export class CartStore {
     try {
       const orderData: OrderDetails = {
         ordered_by: user,
-        kerberos: this.targetUser ?? user,
+        kerberos: this.cartUser,
         order_items: this.items,
         business_justification: this.businessReason,
       };
 
       yield this.baseStore.marketplaceServerClient.submitOrder(user, orderData);
 
-      this.getCartSummary();
-
       toastManager.notify('Order created successfully!', 'success');
 
-      this.refresh();
+      yield flowResult(this.refresh());
       this.setBusinessReason(undefined);
       this.open = false;
       this.submitState.complete();
@@ -301,7 +334,7 @@ export class CartStore {
   }
 
   *clearCart(): GeneratorFn<void> {
-    const user = this.currentUser;
+    const user = this.cartUser;
     if (!user) {
       toastManager.error('User not authenticated');
       return;
@@ -310,8 +343,7 @@ export class CartStore {
     this.loadingState.inProgress();
     try {
       yield this.baseStore.marketplaceServerClient.clearCart(user);
-      this.refresh();
-      this.getCartSummary();
+      yield flowResult(this.refresh());
       toastManager.success('Cart cleared successfully');
       this.loadingState.complete();
     } catch (error) {
@@ -322,8 +354,8 @@ export class CartStore {
     }
   }
 
-  *deleteCartItem(cartId: number): GeneratorFn<void> {
-    const user = this.currentUser;
+  *deleteCartItem(cartId: number, confirmDelete?: boolean): GeneratorFn<void> {
+    const user = this.cartUser;
     if (!user) {
       toastManager.error('User not authenticated');
       return;
@@ -331,10 +363,13 @@ export class CartStore {
 
     this.loadingState.inProgress();
     try {
-      yield this.baseStore.marketplaceServerClient.deleteCartItem(user, cartId);
+      yield this.baseStore.marketplaceServerClient.deleteCartItem(
+        user,
+        cartId,
+        confirmDelete,
+      );
 
-      this.getCartSummary();
-      this.refresh();
+      yield flowResult(this.refresh());
       toastManager.success('Item removed successfully');
       this.loadingState.complete();
     } catch (error) {