@finos/legend-application-marketplace 0.2.2 → 0.2.4

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) {

package/src/stores/dataAPIs/LegendMarketplaceDataAPIsStore.ts

@@ -19,6 +19,7 @@ import type { LegendMarketplaceBaseStore } from '../LegendMarketplaceBaseStore.j
 import {
   ActionState,
   assertErrorThrown,
+  isString,
   type GeneratorFn,
 } from '@finos/legend-shared';
 import {
@@ -38,6 +39,7 @@ export enum LegendServiceSort {
 export enum ServicesViewMode {
   LIST = 'list',
   TILE = 'tile',
+  GRID = 'grid',
 }
 
 export class LegendServiceCardState {
@@ -119,6 +121,10 @@ const LEGEND_MARKETPLACE_SETTING_KEY_SERVICES_VIEW_MODE =
   'marketplace.data-apis.viewMode';
 const LEGEND_MARKETPLACE_SETTING_KEY_SHOW_OWN_SERVICES =
   'marketplace.data-apis.showOwnServicesOnly';
+const LEGEND_MARKETPLACE_SETTING_KEY_FAVORITES =
+  'marketplace.data-apis.favorites';
+const LEGEND_MARKETPLACE_SETTING_KEY_ITEMS_PER_PAGE =
+  'marketplace.data-apis.itemsPerPage';
 
 export class LegendMarketplaceDataAPIsStore {
   readonly marketplaceBaseStore: LegendMarketplaceBaseStore;
@@ -127,12 +133,15 @@ export class LegendMarketplaceDataAPIsStore {
   sort: LegendServiceSort = LegendServiceSort.DEFAULT;
   viewMode: ServicesViewMode;
   showOwnServicesOnly: boolean;
+  showFavoritesOnly = false;
+  favoritePatterns: Set<string>;
   serviceCardStates: LegendServiceCardState[] = [];
   page = 1;
-  itemsPerPage = 12;
+  itemsPerPage: number;
 
   ownerFilters: string[] = [];
   deploymentIdFilters: string[] = [];
+  favorites: Set<string> = new Set();
 
   readonly fetchingServicesState = ActionState.create();
 
@@ -164,20 +173,37 @@ export class LegendMarketplaceDataAPIsStore {
       );
     this.showOwnServicesOnly = persistedShowOwn ?? false;
 
+    const persistedFavorites =
+      (this.marketplaceBaseStore.applicationStore.settingService.getObjectValue(
+        LEGEND_MARKETPLACE_SETTING_KEY_FAVORITES,
+      ) as string[] | undefined) ?? [];
+    this.favoritePatterns = new Set(persistedFavorites.filter(isString));
+
+    const persistedItemsPerPage =
+      this.marketplaceBaseStore.applicationStore.settingService.getNumericValue(
+        LEGEND_MARKETPLACE_SETTING_KEY_ITEMS_PER_PAGE,
+      );
+    this.itemsPerPage = persistedItemsPerPage ?? 12;
+
     makeObservable(this, {
       searchQuery: observable,
       sort: observable,
       viewMode: observable,
       showOwnServicesOnly: observable,
+      showFavoritesOnly: observable,
+      favoritePatterns: observable.shallow,
       serviceCardStates: observable,
       page: observable,
       itemsPerPage: observable,
       ownerFilters: observable,
       deploymentIdFilters: observable,
+      favorites: observable,
       setSearchQuery: action,
       setSort: action,
       setViewMode: action,
       setShowOwnServicesOnly: action,
+      setShowFavoritesOnly: action,
+      toggleFavorite: action,
       setPage: action,
       setItemsPerPage: action,
       addOwnerFilter: action,
@@ -220,13 +246,37 @@ export class LegendMarketplaceDataAPIsStore {
     );
   }
 
+  setShowFavoritesOnly(value: boolean): void {
+    this.showFavoritesOnly = value;
+    this.page = 1;
+  }
+
+  isFavorite(pattern: string): boolean {
+    return this.favoritePatterns.has(pattern);
+  }
+
+  toggleFavorite(pattern: string): void {
+    if (this.favoritePatterns.has(pattern)) {
+      this.favoritePatterns.delete(pattern);
+    } else {
+      this.favoritePatterns.add(pattern);
+    }
+    this.marketplaceBaseStore.applicationStore.settingService.persistValue(
+      LEGEND_MARKETPLACE_SETTING_KEY_FAVORITES,
+      Array.from(this.favoritePatterns),
+    );
+  }
+
   setPage(value: number): void {
     this.page = value;
   }
 
   setItemsPerPage(value: number): void {
     this.itemsPerPage = value;
-    this.page = 1;
+    this.marketplaceBaseStore.applicationStore.settingService.persistValue(
+      LEGEND_MARKETPLACE_SETTING_KEY_ITEMS_PER_PAGE,
+      value,
+    );
   }
 
   private persistOwnerFilters(): void {
@@ -320,6 +370,12 @@ export class LegendMarketplaceDataAPIsStore {
   get filteredSortedServices(): LegendServiceCardState[] {
     let results = this.serviceCardStates;
 
+    if (this.showFavoritesOnly) {
+      results = results.filter((card) =>
+        this.favoritePatterns.has(card.service.pattern),
+      );
+    }
+
     if (this.showOwnServicesOnly) {
       const currentUser =
         this.marketplaceBaseStore.applicationStore.identityService.currentUser;

package/src/stores/lakehouse/LegendMarketplaceFieldSearchResultsStore.ts

@@ -0,0 +1,309 @@
+/**
+ * Copyright (c) 2026-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 { action, computed, flow, makeObservable, observable } from 'mobx';
+import type { LegendMarketplaceBaseStore } from '../LegendMarketplaceBaseStore.js';
+import {
+  ActionState,
+  assertErrorThrown,
+  isNonEmptyString,
+  LogEvent,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  FieldSearchType,
+  type FieldSearchRequest,
+  GroupedFieldSearchResponse,
+  type GroupedFieldSearchResponseMetadata,
+} from '@finos/legend-server-marketplace';
+import type { DataProductTypeFilter } from './LegendMarketplaceSearchResultsStore.js';
+import { LEGEND_MARKETPLACE_APP_EVENT } from '../../__lib__/LegendMarketplaceAppEvent.js';
+import { LegendMarketplaceTelemetryHelper } from '../../__lib__/LegendMarketplaceTelemetryHelper.js';
+import { FieldSearchResultState } from './fieldSearch/FieldSearchResultState.js';
+
+export class LegendMarketplaceFieldSearchResultsStore {
+  readonly marketplaceBaseStore: LegendMarketplaceBaseStore;
+  searchQuery: string | undefined = undefined;
+  fieldSearchResultStates: FieldSearchResultState[] = [];
+  responseMetadata: GroupedFieldSearchResponseMetadata | undefined = undefined;
+  page = 1;
+  itemsPerPage = 12;
+  errorMessage: string | undefined = undefined;
+  selectedProductTypes: Set<DataProductTypeFilter> =
+    new Set<DataProductTypeFilter>();
+  expandedRows: Set<string> = new Set<string>();
+  readonly loadState = ActionState.create();
+  private _currentFetchToken = 0;
+  private _abortController: AbortController | undefined = undefined;
+
+  constructor(marketplaceBaseStore: LegendMarketplaceBaseStore) {
+    this.marketplaceBaseStore = marketplaceBaseStore;
+
+    makeObservable<
+      LegendMarketplaceFieldSearchResultsStore,
+      '_currentFetchToken' | '_abortController'
+    >(this, {
+      searchQuery: observable,
+      fieldSearchResultStates: observable,
+      responseMetadata: observable,
+      page: observable,
+      itemsPerPage: observable,
+      errorMessage: observable,
+      selectedProductTypes: observable,
+      expandedRows: observable,
+      _currentFetchToken: false,
+      _abortController: false,
+      setSearchQuery: action,
+      setFieldSearchResultStates: action,
+      setResponseMetadata: action,
+      setPage: action,
+      setItemsPerPage: action,
+      setErrorMessage: action,
+      toggleProductType: action,
+      clearAllFilters: action,
+      toggleExpandRow: action,
+      clearExpandedRows: action,
+      fieldSearchRequest: computed,
+      tableRows: computed,
+      totalItems: computed,
+      totalFieldMatches: computed,
+      lakehouseCount: computed,
+      legacyCount: computed,
+      hasActiveFilters: computed,
+      isLoading: computed,
+      hasFailed: computed,
+      executeSearch: flow,
+      changePageAndFetch: flow,
+      changeItemsPerPageAndFetch: flow,
+      toggleProductTypeAndFetch: flow,
+      clearAllFiltersAndFetch: flow,
+    });
+  }
+
+  setSearchQuery(query: string | undefined): void {
+    this.searchQuery = query;
+    this.page = 1;
+  }
+
+  setFieldSearchResultStates(results: FieldSearchResultState[]): void {
+    this.fieldSearchResultStates = results;
+  }
+
+  setResponseMetadata(
+    value: GroupedFieldSearchResponseMetadata | undefined,
+  ): void {
+    this.responseMetadata = value;
+  }
+
+  setPage(value: number): void {
+    this.page = value;
+  }
+
+  setItemsPerPage(value: number): void {
+    this.itemsPerPage = value;
+    this.page = 1;
+  }
+
+  setErrorMessage(value: string | undefined): void {
+    this.errorMessage = value;
+  }
+
+  toggleProductType(productType: DataProductTypeFilter): void {
+    const wasSelected = this.selectedProductTypes.has(productType);
+    if (wasSelected) {
+      this.selectedProductTypes.delete(productType);
+    } else {
+      this.selectedProductTypes.add(productType);
+    }
+    this.page = 1;
+    LegendMarketplaceTelemetryHelper.logEvent_ApplySearchFilter(
+      this.marketplaceBaseStore.applicationStore.telemetryService,
+      'dataProductType',
+      productType,
+      wasSelected ? 'deselect' : 'select',
+      this.searchQuery,
+    );
+  }
+
+  clearAllFilters(): void {
+    this.selectedProductTypes.clear();
+    this.page = 1;
+    LegendMarketplaceTelemetryHelper.logEvent_ClearSearchFilters(
+      this.marketplaceBaseStore.applicationStore.telemetryService,
+      this.searchQuery,
+    );
+  }
+
+  toggleExpandRow(rowId: string): void {
+    if (this.expandedRows.has(rowId)) {
+      this.expandedRows.delete(rowId);
+    } else {
+      this.expandedRows.add(rowId);
+    }
+  }
+
+  clearExpandedRows(): void {
+    this.expandedRows.clear();
+  }
+
+  isRowExpanded(rowId: string): boolean {
+    return this.expandedRows.has(rowId);
+  }
+
+  get fieldSearchRequest(): FieldSearchRequest | undefined {
+    if (!isNonEmptyString(this.searchQuery)) {
+      return undefined;
+    }
+    return {
+      query: this.searchQuery,
+      searchType: FieldSearchType.HYBRID,
+      pageSize: this.itemsPerPage,
+      pageNumber: this.page,
+      ...(this.selectedProductTypes.size > 0
+        ? { dataProductTypes: Array.from(this.selectedProductTypes) }
+        : {}),
+    };
+  }
+
+  get tableRows(): FieldSearchResultState[] {
+    return this.fieldSearchResultStates;
+  }
+
+  get totalItems(): number {
+    return this.responseMetadata?.total_count ?? 0;
+  }
+
+  get totalFieldMatches(): number {
+    return this.responseMetadata?.total_field_matches ?? 0;
+  }
+
+  get lakehouseCount(): number {
+    return this.responseMetadata?.lakehouse_count ?? 0;
+  }
+
+  get legacyCount(): number {
+    return this.responseMetadata?.legacy_count ?? 0;
+  }
+
+  get hasActiveFilters(): boolean {
+    return this.selectedProductTypes.size > 0;
+  }
+
+  get isLoading(): boolean {
+    return (
+      isNonEmptyString(this.searchQuery) &&
+      (this.loadState.isInInitialState || this.loadState.isInProgress)
+    );
+  }
+
+  get hasFailed(): boolean {
+    return this.loadState.hasFailed;
+  }
+
+  *executeSearch(): GeneratorFn<void> {
+    yield* this.fetchFieldSearchResultsInternal();
+  }
+
+  *changePageAndFetch(page: number): GeneratorFn<void> {
+    this.setPage(page);
+    yield* this.fetchFieldSearchResultsInternal();
+  }
+
+  *changeItemsPerPageAndFetch(itemsPerPage: number): GeneratorFn<void> {
+    this.setItemsPerPage(itemsPerPage);
+    yield* this.fetchFieldSearchResultsInternal();
+  }
+
+  *toggleProductTypeAndFetch(
+    productType: DataProductTypeFilter,
+  ): GeneratorFn<void> {
+    this.toggleProductType(productType);
+    yield* this.fetchFieldSearchResultsInternal();
+  }
+
+  *clearAllFiltersAndFetch(): GeneratorFn<void> {
+    this.clearAllFilters();
+    yield* this.fetchFieldSearchResultsInternal();
+  }
+
+  private *fetchFieldSearchResultsInternal(): GeneratorFn<void> {
+    const request = this.fieldSearchRequest;
+    const fetchToken = ++this._currentFetchToken;
+
+    if (!request) {
+      this.setFieldSearchResultStates([]);
+      this.setResponseMetadata(undefined);
+      this.setErrorMessage(undefined);
+      this.clearExpandedRows();
+      this.loadState.complete();
+      return;
+    }
+
+    this._abortController?.abort();
+    this._abortController = new AbortController();
+    const { signal } = this._abortController;
+
+    this.loadState.inProgress();
+    this.setErrorMessage(undefined);
+    this.clearExpandedRows();
+
+    try {
+      const rawResponse =
+        (yield this.marketplaceBaseStore.marketplaceServerClient.fieldSearch(
+          this.marketplaceBaseStore.envState.lakehouseEnvironment,
+          request,
+          signal,
+        )) as PlainObject<GroupedFieldSearchResponse>;
+
+      if (fetchToken !== this._currentFetchToken) {
+        return;
+      }
+
+      const response =
+        GroupedFieldSearchResponse.serialization.fromJson(rawResponse);
+      const results = response.results.map(
+        (entry) => new FieldSearchResultState(entry),
+      );
+
+      this.setFieldSearchResultStates(results);
+      this.setResponseMetadata(response.metadata);
+      this.loadState.complete();
+    } catch (error: unknown) {
+      if (fetchToken !== this._currentFetchToken) {
+        return;
+      }
+
+      assertErrorThrown(error);
+      this.marketplaceBaseStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_MARKETPLACE_APP_EVENT.FIELD_SEARCH_FAILURE),
+        error,
+      );
+      this.marketplaceBaseStore.applicationStore.notificationService.notifyError(
+        `Error fetching field search results: ${error.message}`,
+      );
+      this.setFieldSearchResultStates([]);
+      this.setResponseMetadata(undefined);
+      this.setErrorMessage(error.message);
+      this.loadState.fail();
+    }
+  }
+
+  dispose(): void {
+    this._abortController?.abort();
+    this._abortController = undefined;
+  }
+}