@finos/legend-application-marketplace 0.2.3 → 0.2.4

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;
+  }
+}

package/src/stores/lakehouse/LegendMarketplaceProductViewerStore.ts

@@ -55,7 +55,6 @@ import {
   V1_DataProductArtifact,
   V1_dataProductModelSchema,
   V1_entitlementsDataProductDetailsResponseToDataProductDetails,
-  V1_ModelAccessPointGroup,
   V1_PureGraphManager,
   V1_SdlcDeploymentDataProductOrigin,
   V1_TerminalModelSchema,
@@ -393,26 +392,22 @@ export class LegendMarketplaceProductViewerStore {
               }
             : undefined,
           // TODO: improve with class opening
-          openQuery: projectGAV
-            ? (): void => {
-                const modelAPG = v1DataProduct.accessPointGroups.find(
-                  (apg) => apg instanceof V1_ModelAccessPointGroup,
-                );
-                if (modelAPG) {
-                  this.marketplaceBaseStore.applicationStore.navigationService.navigator.visitAddress(
-                    EXTERNAL_APPLICATION_NAVIGATION__generateDataProductModelQueryUrl(
-                      this.marketplaceBaseStore.applicationStore.config
-                        .queryApplicationUrl,
-                      projectGAV.groupId,
-                      projectGAV.artifactId,
-                      projectGAV.versionId,
-                      v1DataProduct.path,
-                      modelAPG.id,
-                    ),
-                  );
-                }
-              }
-            : undefined,
+          openQuery: (gav, type, id) => {
+            if (id) {
+              this.marketplaceBaseStore.applicationStore.navigationService.navigator.visitAddress(
+                EXTERNAL_APPLICATION_NAVIGATION__generateDataProductModelQueryUrl(
+                  this.marketplaceBaseStore.applicationStore.config
+                    .queryApplicationUrl,
+                  gav.groupId,
+                  gav.artifactId,
+                  gav.versionId,
+                  type,
+                  v1DataProduct.path,
+                  id,
+                ),
+              );
+            }
+          },
         },
         this.marketplaceBaseStore.registryServerClient,
       );
@@ -616,20 +611,18 @@ export class LegendMarketplaceProductViewerStore {
                     ),
                   );
                 },
-                openQuery: (): void => {
-                  const modelAPG = v1DataProduct.accessPointGroups.find(
-                    (apg) => apg instanceof V1_ModelAccessPointGroup,
-                  );
-                  if (modelAPG) {
+                openQuery: (_gav, type, id): void => {
+                  if (id) {
                     this.marketplaceBaseStore.applicationStore.navigationService.navigator.visitAddress(
                       EXTERNAL_APPLICATION_NAVIGATION__generateDataProductModelQueryUrl(
                         this.marketplaceBaseStore.applicationStore.config
                           .queryApplicationUrl,
-                        projectData.groupId,
-                        projectData.artifactId,
-                        projectData.versionId,
+                        _gav.groupId,
+                        _gav.artifactId,
+                        _gav.versionId,
+                        type,
                         v1DataProduct.path,
-                        modelAPG.id,
+                        id,
                       ),
                     );
                   }

package/src/stores/lakehouse/fieldSearch/FieldSearchResultState.ts

@@ -0,0 +1,122 @@
+/**
+ * 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 {
+  DataProductSearchResultDetailsType,
+  type GroupedFieldSearchDataProduct,
+  type GroupedFieldSearchResultEntry,
+} from '@finos/legend-server-marketplace';
+import { DataProductTypeFilter } from '../LegendMarketplaceSearchResultsStore.js';
+import { generateGAVCoordinates } from '@finos/legend-storage';
+import {
+  generateLakehouseDataProductPath,
+  generateLegacyDataProductPath,
+} from '../../../__lib__/LegendMarketplaceNavigation.js';
+
+const PRODUCT_TYPE_FILTER_MAP: Record<
+  DataProductSearchResultDetailsType,
+  DataProductTypeFilter
+> = {
+  [DataProductSearchResultDetailsType.LEGACY]: DataProductTypeFilter.LEGACY,
+  [DataProductSearchResultDetailsType.LAKEHOUSE]:
+    DataProductTypeFilter.LAKEHOUSE,
+  [DataProductSearchResultDetailsType.ERROR]: DataProductTypeFilter.LEGACY,
+};
+
+const getDataProductName = (path: string): string =>
+  path.split('::').at(-1) ?? path;
+
+const getOwningDataProductPath = (
+  dataProduct: GroupedFieldSearchDataProduct,
+): string => {
+  if (
+    dataProduct.productType === DataProductSearchResultDetailsType.LEGACY &&
+    dataProduct.groupId
+  ) {
+    return generateLegacyDataProductPath(
+      generateGAVCoordinates(
+        dataProduct.groupId,
+        dataProduct.artifactId ?? '',
+        dataProduct.versionId ?? '',
+      ),
+      dataProduct.path,
+    );
+  }
+  if (
+    dataProduct.productType === DataProductSearchResultDetailsType.LAKEHOUSE &&
+    dataProduct.dataProductId &&
+    dataProduct.deploymentId !== undefined
+  ) {
+    return generateLakehouseDataProductPath(
+      dataProduct.dataProductId,
+      dataProduct.deploymentId,
+    );
+  }
+  return '';
+};
+
+export class FieldSearchDataProductEntry {
+  readonly name: string;
+  readonly datasetName: string | undefined;
+  readonly modelPath: string | undefined;
+  readonly path: string;
+  readonly entityPath: string;
+  readonly dataProductId: string | undefined;
+  readonly deploymentId: number | undefined;
+  readonly groupId: string | undefined;
+  readonly artifactId: string | undefined;
+  readonly versionId: string | undefined;
+  readonly productType: DataProductTypeFilter | undefined;
+
+  constructor(dataProduct: GroupedFieldSearchDataProduct) {
+    const productType = PRODUCT_TYPE_FILTER_MAP[dataProduct.productType];
+    const dataProductName = getDataProductName(dataProduct.path);
+
+    this.name = dataProductName;
+    this.datasetName = dataProduct.datasetName;
+    this.modelPath = dataProduct.modelPath;
+    this.path = getOwningDataProductPath(dataProduct);
+    this.entityPath = dataProduct.path;
+    this.dataProductId = dataProduct.dataProductId ?? dataProductName;
+    this.deploymentId = dataProduct.deploymentId;
+    this.groupId = dataProduct.groupId;
+    this.artifactId = dataProduct.artifactId;
+    this.versionId = dataProduct.versionId;
+    this.productType = productType;
+  }
+}
+
+export class FieldSearchResultState {
+  readonly id: string;
+  readonly fieldName: string;
+  readonly fieldType: string;
+  readonly fieldDescription: string;
+  readonly dataProducts: FieldSearchDataProductEntry[];
+
+  constructor(result: GroupedFieldSearchResultEntry) {
+    this.fieldName = result.fieldName;
+    this.fieldType = result.fieldType ?? 'Unknown';
+    this.fieldDescription = result.fieldDescription ?? '-';
+    this.id = JSON.stringify([
+      this.fieldName,
+      this.fieldType,
+      this.fieldDescription,
+    ]);
+    this.dataProducts = result.dataProducts.map(
+      (dp) => new FieldSearchDataProductEntry(dp),
+    );
+  }
+}

package/tsconfig.json

@@ -71,12 +71,14 @@
     "./src/stores/cart/CartStore.ts",
     "./src/stores/dataAPIs/LegendMarketplaceDataAPIsStore.ts",
     "./src/stores/lakehouse/LakehouseDataProductService.ts",
+    "./src/stores/lakehouse/LegendMarketplaceFieldSearchResultsStore.ts",
     "./src/stores/lakehouse/LegendMarketplaceProductViewerStore.ts",
     "./src/stores/lakehouse/LegendMarketplaceSearchResultsStore.ts",
     "./src/stores/lakehouse/admin/LakehouseAdminStore.ts",
     "./src/stores/lakehouse/dataProducts/ProductCardState.ts",
     "./src/stores/lakehouse/entitlements/EntitlementsDashboardState.ts",
     "./src/stores/lakehouse/entitlements/LakehouseEntitlementsStore.ts",
+    "./src/stores/lakehouse/fieldSearch/FieldSearchResultState.ts",
     "./src/stores/orders/OrderHelpers.ts",
     "./src/stores/orders/OrderStore.ts",
     "./src/stores/subscriptions/SubscriptionStore.ts",
@@ -87,6 +89,7 @@
     "./src/application/providers/LakehouseAdminStoreProvider.tsx",
     "./src/application/providers/LakehouseEntitlementsStoreProvider.tsx",
     "./src/application/providers/LegendMarketplaceDataAPIsStoreProvider.tsx",
+    "./src/application/providers/LegendMarketplaceFieldSearchResultsStoreProvider.tsx",
     "./src/application/providers/LegendMarketplaceFrameworkProvider.tsx",
     "./src/application/providers/LegendMarketplaceProductViewerStoreProvider.tsx",
     "./src/application/providers/LegendMarketplaceSearchResultsStoreProvider.tsx",
@@ -99,6 +102,7 @@
     "./src/components/ComingSoon/ComingSoonDisplay.tsx",
     "./src/components/DataAPIsFiltersPanel/DataAPIsFiltersPanel.tsx",
     "./src/components/Feedback/FeedbackWidget.tsx",
+    "./src/components/FieldSearchFiltersPanel/FieldSearchFiltersPanel.tsx",
     "./src/components/Header/CartBadge.tsx",
     "./src/components/Header/LegendMarketplaceAppInfo.tsx",
     "./src/components/Header/LegendMarketplaceHeader.tsx",
@@ -110,6 +114,7 @@
     "./src/components/LegendServiceCard/LegendServiceCard.tsx",
     "./src/components/LegendServiceCard/LegendServiceGrid.tsx",
     "./src/components/LegendServiceCard/LegendServiceListRow.tsx",
+    "./src/components/MarketplaceCard/FieldSearchResultListItem.tsx",
     "./src/components/MarketplaceCard/LegendMarketplaceCard.tsx",
     "./src/components/MarketplaceCard/LegendMarketplaceListItem.tsx",
     "./src/components/MarketplaceSearchFiltersPanel/MarketplaceSearchFiltersPanel.tsx",
@@ -140,6 +145,7 @@
     "./src/pages/Lakehouse/entitlements/LakehouseDataContract.tsx",
     "./src/pages/Lakehouse/entitlements/LakehouseEntitlements.tsx",
     "./src/pages/Lakehouse/entitlements/WorkflowDataAccessRequest.tsx",
+    "./src/pages/Lakehouse/searchResults/LegendMarketplaceFieldSearchResults.tsx",
     "./src/pages/Lakehouse/searchResults/LegendMarketplaceSearchResults.tsx",
     "./src/pages/Profile/LegendMarketplaceSubscriptions.tsx",
     "./src/pages/Profile/LegendMarketplaceYourOrders.tsx",