@finos/legend-extension-dsl-data-space 10.4.190 → 10.4.192

package/src/stores/query-builder/DataSpaceQueryBuilderState.ts

@@ -14,18 +14,15 @@
  * limitations under the License.
  */
 
-import {
-  APPLICATION_EVENT,
-  type GenericLegendApplicationStore,
-} from '@finos/legend-application';
+import { type GenericLegendApplicationStore } from '@finos/legend-application';
 import {
   type QueryBuilderConfig,
-  type QuerySDLC,
   type QueryBuilderWorkflowState,
   type QueryBuilderActionConfig,
   QueryBuilderState,
   type QueryBuilderExtraFunctionAnalysisInfo,
   QUERY_BUILDER_LAMBDA_WRITER_MODE,
+  type ExtraOptionsConfig,
 } from '@finos/legend-query-builder';
 import {
   type Class,
@@ -34,51 +31,39 @@ import {
   type Runtime,
   type Mapping,
   type FunctionAnalysisInfo,
-  type GraphData,
   getMappingCompatibleClasses,
   Package,
   QueryDataSpaceExecutionContext,
   elementBelongsToPackage,
-  GraphDataWithOrigin,
-  LegendSDLC,
-  InMemoryGraphData,
 } from '@finos/legend-graph';
-import {
-  type DepotServerClient,
-  type StoredEntity,
-  DepotScope,
-  resolveVersion,
-  SNAPSHOT_VERSION_ALIAS,
-} from '@finos/legend-server-depot';
 import {
   type GeneratorFn,
   ActionState,
-  assertErrorThrown,
   filterByType,
-  LogEvent,
   uniq,
 } from '@finos/legend-shared';
-import { action, flow, makeObservable, observable } from 'mobx';
-import { renderDataSpaceQueryBuilderSetupPanelContent } from '../../components/query-builder/DataSpaceQueryBuilder.js';
+import { action, computed, flow, makeObservable, observable } from 'mobx';
+import {
+  renderDataSpaceQueryBuilderSetupPanelContent,
+  type DataSpaceOption,
+} from '../../components/query-builder/DataSpaceQueryBuilder.js';
 import {
   type DataSpaceElement,
   type DataSpaceExecutionContext,
   DataSpace,
 } from '../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
-import { DATA_SPACE_ELEMENT_CLASSIFIER_PATH } from '../../graph-manager/protocol/pure/DSL_DataSpace_PureProtocolProcessorPlugin.js';
-import { DataSpaceAdvancedSearchState } from '../query/DataSpaceAdvancedSearchState.js';
+import type { DataSpaceAdvancedSearchState } from '../query/DataSpaceAdvancedSearchState.js';
 import {
   type DataSpaceAnalysisResult,
   type DataSpaceExecutableAnalysisResult,
-  DataSpaceServiceExecutableInfo,
 } from '../../graph-manager/action/analytics/DataSpaceAnalysis.js';
-import {
-  type DataSpaceInfo,
-  extractDataSpaceInfo,
-} from '../shared/DataSpaceInfo.js';
-import type { ProjectGAVCoordinates } from '@finos/legend-storage';
-import { generateDataSpaceTemplateQueryCreatorRoute } from '../../__lib__/to-delete/DSL_DataSpace_LegendQueryNavigation_to_delete.js';
+import { ResolvedDataSpaceEntityWithOrigin } from '../shared/DataSpaceInfo.js';
+import type {
+  DepotEntityWithOrigin,
+  QueryableSourceInfo,
+} from '@finos/legend-storage';
 import { buildDataSpaceExecutableAnalysisResultFromExecutable } from '../../graph-manager/action/analytics/DataSpaceAnalysisHelper.js';
+import { compareLabelFn } from '@finos/legend-art';
 
 const matchesDataElement = (
   _class: Class,
@@ -142,242 +127,34 @@ export const resolveUsableDataSpaceClasses = (
   return compatibleClasses;
 };
 
-export interface DataSpaceQuerySDLC extends QuerySDLC {
+export interface DataSpaceQuerySDLC extends QueryableSourceInfo {
   groupId: string;
   artifactId: string;
   versionId: string;
   dataSpace: string;
 }
 
-// could be abstracted for element
-export abstract class DataSpacesBuilderRepoistory {
-  readonly applicationStore: GenericLegendApplicationStore;
-  readonly graphManagerState: GraphManagerState;
-  readonly loadDataSpacesState = ActionState.create();
-  dataSpaces: DataSpaceInfo[] | undefined;
-  prioritizeDataSpaceFunc?: ((val: DataSpaceInfo) => boolean) | undefined;
-
-  constructor(
-    applicatonstore: GenericLegendApplicationStore,
-    graphManagerState: GraphManagerState,
-    prioritizeDataSpaceFunc?: ((val: DataSpaceInfo) => boolean) | undefined,
-  ) {
-    this.applicationStore = applicatonstore;
-    this.graphManagerState = graphManagerState;
-    this.prioritizeDataSpaceFunc = prioritizeDataSpaceFunc;
-  }
-
-  get isAdvancedDataSpaceSearchEnabled(): boolean {
-    return false;
-  }
-
-  get canVisitTemplateQuery(): boolean {
-    return false;
-  }
-
-  abstract loadDataSpaces(): GeneratorFn<void>;
-  abstract visitTemplateQuery(
-    dataSpace: DataSpace,
-    template: DataSpaceExecutableAnalysisResult,
-  ): void;
-
-  configureDataSpaceOptions(val: DataSpaceInfo[]): void {
-    this.dataSpaces = val;
-  }
-}
-
-export class DataSpacesGraphRepoistory extends DataSpacesBuilderRepoistory {
-  constructor(
-    applicatonstore: GenericLegendApplicationStore,
-    graphManagerState: GraphManagerState,
-    prioritizeDataSpaceFunc?: ((val: DataSpaceInfo) => boolean) | undefined,
-  ) {
-    super(applicatonstore, graphManagerState, prioritizeDataSpaceFunc);
-    makeObservable(this, {
-      dataSpaces: observable,
-      loadDataSpaces: flow,
-      configureDataSpaceOptions: action,
-    });
-  }
-
-  *loadDataSpaces(): GeneratorFn<void> {
-    this.dataSpaces = this.graphManagerState.graph.allOwnElements
-      .filter(filterByType(DataSpace))
-      .map(
-        (e) =>
-          ({
-            groupId: undefined,
-            artifactId: undefined,
-            versionId: undefined,
-            path: e.path,
-            name: e.name,
-            title: e.title,
-            defaultExecutionContext: e.defaultExecutionContext.title,
-          }) as DataSpaceInfo,
-      );
-  }
-
-  override visitTemplateQuery(
-    dataSpace: DataSpace,
-    template: DataSpaceExecutableAnalysisResult,
-  ): void {
-    throw new Error('Method not implemented.');
-  }
-}
-
-export class DataSpacesDepotRepository extends DataSpacesBuilderRepoistory {
-  readonly depotServerClient: DepotServerClient;
-  readonly project: ProjectGAVCoordinates;
-  readonly viewProject: (
-    groupId: string,
-    artifactId: string,
-    versionId: string,
-    entityPath: string | undefined,
-  ) => void;
-  readonly viewSDLCProject: (
-    groupId: string,
-    artifactId: string,
-    entityPath: string | undefined,
-  ) => Promise<void>;
-  advancedSearchState?: DataSpaceAdvancedSearchState | undefined;
-
-  constructor(
-    depotServerClient: DepotServerClient,
-    applicatonstore: GenericLegendApplicationStore,
-    graphManagerState: GraphManagerState,
-    project: ProjectGAVCoordinates,
-    viewProject: (
-      groupId: string,
-      artifactId: string,
-      versionId: string,
-      entityPath: string | undefined,
-    ) => void,
-    viewSDLCProject: (
-      groupId: string,
-      artifactId: string,
-      entityPath: string | undefined,
-    ) => Promise<void>,
-    prioritizeDataSpaceFunc?: ((val: DataSpaceInfo) => boolean) | undefined,
-  ) {
-    super(applicatonstore, graphManagerState, prioritizeDataSpaceFunc);
-    makeObservable(this, {
-      advancedSearchState: observable,
-      dataSpaces: observable,
-      showAdvancedSearchPanel: action,
-      hideAdvancedSearchPanel: action,
-      visitTemplateQuery: action,
-      configureDataSpaceOptions: action,
-      loadDataSpaces: flow,
-    });
-    this.depotServerClient = depotServerClient;
-    this.project = project;
-    this.viewProject = viewProject;
-    this.viewSDLCProject = viewSDLCProject;
-  }
-
-  override get isAdvancedDataSpaceSearchEnabled(): boolean {
-    return true;
-  }
-
-  override get canVisitTemplateQuery(): boolean {
-    return true;
-  }
-
-  override visitTemplateQuery(
-    dataSpace: DataSpace,
-    template: DataSpaceExecutableAnalysisResult,
-  ): void {
-    let templateId;
-    if (template.info) {
-      if (template.info.id) {
-        templateId = template.info.id;
-      } else if (template.info instanceof DataSpaceServiceExecutableInfo) {
-        templateId = template.executable ?? template.info.pattern;
-      }
-    }
-    if (!templateId) {
-      this.applicationStore.notificationService.notifyWarning(
-        `Can't visit tempalte query without a Id`,
-      );
-    } else {
-      this.applicationStore.navigationService.navigator.visitAddress(
-        this.applicationStore.navigationService.navigator.generateAddress(
-          generateDataSpaceTemplateQueryCreatorRoute(
-            this.project.groupId,
-            this.project.artifactId,
-            this.project.versionId,
-            dataSpace.path,
-            templateId,
-          ),
-        ),
-      );
-    }
-  }
-
-  showAdvancedSearchPanel(dataSpace: DataSpace): void {
-    this.advancedSearchState = new DataSpaceAdvancedSearchState(
-      this.applicationStore,
-      this.graphManagerState,
-      this.depotServerClient,
-      {
-        viewProject: this.viewProject,
-        viewSDLCProject: this.viewSDLCProject,
-      },
-      {
-        groupId: this.project.groupId,
-        artifactId: this.project.artifactId,
-        versionId: this.project.versionId,
-        title: dataSpace.title,
-        name: dataSpace.name,
-        path: dataSpace.path,
-        defaultExecutionContext: dataSpace.defaultExecutionContext.name,
-      },
-      this.project.versionId === SNAPSHOT_VERSION_ALIAS,
-    );
-  }
-
-  hideAdvancedSearchPanel(): void {
-    this.advancedSearchState = undefined;
-  }
-
-  *loadDataSpaces(): GeneratorFn<void> {
-    if (this.dataSpaces === undefined) {
-      this.loadDataSpacesState.inProgress();
-      const toGetSnapShot = this.project.versionId === SNAPSHOT_VERSION_ALIAS;
-      try {
-        this.dataSpaces = (
-          (yield this.depotServerClient.getEntitiesByClassifier(
-            DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
-            {
-              scope: toGetSnapShot ? DepotScope.SNAPSHOT : DepotScope.RELEASES,
-            },
-          )) as StoredEntity[]
-        ).map((storedEntity) =>
-          extractDataSpaceInfo(storedEntity, toGetSnapShot),
-        );
-        this.loadDataSpacesState.pass();
-      } catch (error) {
-        assertErrorThrown(error);
-        this.loadDataSpacesState.fail();
-        this.applicationStore.notificationService.notifyError(error);
-        this.applicationStore.logService.error(
-          LogEvent.create(APPLICATION_EVENT.GENERIC_FAILURE),
-          error,
-        );
-      }
-    }
-  }
-}
+export const buildDataSpaceOption = (
+  value: ResolvedDataSpaceEntityWithOrigin,
+): DataSpaceOption => ({
+  label: value.title ?? value.name,
+  value,
+});
 
 export class DataSpaceQueryBuilderState extends QueryBuilderState {
-  readonly onDataSpaceChange: (val: DataSpaceInfo) => Promise<void>;
+  readonly onDataSpaceChange: (
+    val: ResolvedDataSpaceEntityWithOrigin,
+  ) => Promise<void>;
   readonly onExecutionContextChange?:
     | ((val: DataSpaceExecutionContext) => void)
     | undefined;
   readonly onRuntimeChange?: ((val: Runtime) => void) | undefined;
   readonly onClassChange?: ((val: Class) => void) | undefined;
   readonly dataSpaceAnalysisResult?: DataSpaceAnalysisResult | undefined;
-  readonly dataSpaceRepo: DataSpacesBuilderRepoistory;
+  readonly extraOptionsConfig?:
+    | ExtraOptionsConfig<DepotEntityWithOrigin>
+    | undefined;
+  entities: ResolvedDataSpaceEntityWithOrigin[] | undefined;
 
   override TEMPORARY__setupPanelContentRenderer = (): React.ReactNode =>
     renderDataSpaceQueryBuilderSetupPanelContent(this);
@@ -388,6 +165,11 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   isTemplateQueryDialogOpen = false;
   isLightGraphEnabled!: boolean;
   displayedTemplateQueries: DataSpaceExecutableAnalysisResult[] | undefined;
+  advancedSearchState?: DataSpaceAdvancedSearchState | undefined;
+  loadEntitiesState = ActionState.create();
+  prioritizeEntityFunc?:
+    | ((val: ResolvedDataSpaceEntityWithOrigin) => boolean)
+    | undefined;
 
   constructor(
     applicationStore: GenericLegendApplicationStore,
@@ -397,8 +179,12 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     dataSpace: DataSpace,
     executionContext: DataSpaceExecutionContext,
     isLightGraphEnabled: boolean,
-    dataSpaceRepo: DataSpacesBuilderRepoistory | undefined,
-    onDataSpaceChange: (val: DataSpaceInfo) => Promise<void>,
+    prioritizeEntityFunc:
+      | ((val: ResolvedDataSpaceEntityWithOrigin) => boolean)
+      | undefined,
+    onDataSpaceChange: (
+      val: ResolvedDataSpaceEntityWithOrigin,
+    ) => Promise<void>,
     dataSpaceAnalysisResult?: DataSpaceAnalysisResult | undefined,
     onExecutionContextChange?:
       | ((val: DataSpaceExecutionContext) => void)
@@ -406,7 +192,8 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     onRuntimeChange?: ((val: Runtime) => void) | undefined,
     onClassChange?: ((val: Class) => void) | undefined,
     config?: QueryBuilderConfig | undefined,
-    sourceInfo?: QuerySDLC | undefined,
+    sourceInfo?: QueryableSourceInfo | undefined,
+    extraOptionsConfig?: ExtraOptionsConfig<DepotEntityWithOrigin> | undefined,
   ) {
     super(applicationStore, graphManagerState, workflow, config, sourceInfo);
 
@@ -416,11 +203,15 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
       isTemplateQueryDialogOpen: observable,
       isLightGraphEnabled: observable,
       displayedTemplateQueries: observable,
+      advancedSearchState: observable,
+      selectedDataSpaceOption: computed,
       setExecutionContext: action,
       setShowRuntimeSelector: action,
       setTemplateQueryDialogOpen: action,
       setIsLightGraphEnabled: action,
       intialize: flow,
+      loadEntities: flow,
+      entities: observable,
     });
 
     this.dataSpace = dataSpace;
@@ -429,15 +220,11 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     this.onExecutionContextChange = onExecutionContextChange;
     this.onRuntimeChange = onRuntimeChange;
     this.onClassChange = onClassChange;
-    this.dataSpaceRepo =
-      dataSpaceRepo ??
-      new DataSpacesGraphRepoistory(
-        this.applicationStore,
-        this.graphManagerState,
-      );
     this.dataSpaceAnalysisResult = dataSpaceAnalysisResult;
     this.workflowState.updateActionConfig(actionConfig);
     this.isLightGraphEnabled = isLightGraphEnabled;
+    this.prioritizeEntityFunc = prioritizeEntityFunc;
+    this.extraOptionsConfig = extraOptionsConfig;
     if (dataSpaceAnalysisResult?.__INTERNAL__useRelationTDS) {
       this.setLambdaWriteMode(
         QUERY_BUILDER_LAMBDA_WRITER_MODE.TYPED_FETCH_STRUCTURE,
@@ -445,6 +232,23 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     }
   }
 
+  get dataSpaceOptions(): DataSpaceOption[] {
+    const sortedAllOptions = (this.entities ?? [])
+      .map(buildDataSpaceOption)
+      .sort(compareLabelFn);
+
+    return this.prioritizeEntityFunc
+      ? [
+          ...sortedAllOptions.filter((val) =>
+            this.prioritizeEntityFunc?.(val.value),
+          ),
+          ...sortedAllOptions.filter(
+            (val) => !this.prioritizeEntityFunc?.(val.value),
+          ),
+        ]
+      : sortedAllOptions;
+  }
+
   override get sideBarClassName(): string | undefined {
     return this.showRuntimeSelector
       ? 'query-builder__setup__data-space--with-runtime'
@@ -458,6 +262,65 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     return queryExeContext;
   }
 
+  get isAdvancedDataSpaceSearchEnabled(): boolean {
+    return false;
+  }
+
+  get isDataSpaceLinkable(): boolean {
+    return false;
+  }
+
+  copyDataSpaceLinkToClipboard(): void {
+    if (!this.isDataSpaceLinkable) {
+      this.applicationStore.notificationService.notifyError(
+        'Data space link is not available.',
+      );
+    }
+  }
+
+  get selectedDataSpaceOption(): DataSpaceOption {
+    return {
+      label: this.dataSpace.title ?? this.dataSpace.name,
+      value: new ResolvedDataSpaceEntityWithOrigin(
+        undefined,
+        this.dataSpace.title,
+        this.dataSpace.name,
+        this.dataSpace.path,
+        this.dataSpace.defaultExecutionContext.title ??
+          this.dataSpace.defaultExecutionContext.name,
+      ),
+    };
+  }
+
+  get canVisitTemplateQuery(): boolean {
+    return false;
+  }
+
+  protected getElementType(): typeof DataSpace {
+    return DataSpace;
+  }
+
+  *loadEntities(): GeneratorFn<void> {
+    this.loadEntitiesState.inProgress();
+    this.entities = this.graphManagerState.graph.allOwnElements
+      .filter(filterByType(this.getElementType()))
+      .map((element) => this.transformElement(element));
+    this.loadEntitiesState.complete();
+  }
+
+  protected transformElement(
+    element: DataSpace,
+  ): ResolvedDataSpaceEntityWithOrigin {
+    return new ResolvedDataSpaceEntityWithOrigin(
+      undefined,
+      element.title,
+      element.name,
+      element.path,
+      element.defaultExecutionContext.title ??
+        element.defaultExecutionContext.name,
+    );
+  }
+
   setTemplateQueryDialogOpen(val: boolean): void {
     this.isTemplateQueryDialogOpen = val;
   }
@@ -500,18 +363,6 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     };
   }
 
-  override getGraphData(): GraphData {
-    if (this.dataSpaceRepo instanceof DataSpacesDepotRepository) {
-      const option = new LegendSDLC(
-        this.dataSpaceRepo.project.groupId,
-        this.dataSpaceRepo.project.artifactId,
-        resolveVersion(this.dataSpaceRepo.project.versionId),
-      );
-      return new GraphDataWithOrigin(option);
-    }
-    return new InMemoryGraphData(this.graphManagerState.graph);
-  }
-
   *intialize(): GeneratorFn<void> {
     this.displayedTemplateQueries =
       this.dataSpace.executables && this.dataSpace.executables.length > 0
@@ -524,4 +375,23 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
             (ex) => ex.info !== undefined,
           );
   }
+
+  visitTemplateQuery(
+    dataSpace: DataSpace,
+    template: DataSpaceExecutableAnalysisResult,
+  ): void {
+    this.applicationStore.notificationService.notifyError(
+      'Visiting template query is not supported yet.',
+    );
+  }
+
+  hideAdvancedSearchPanel(): void {
+    this.advancedSearchState = undefined;
+  }
+
+  showAdvancedSearchPanel(dataSpace: DataSpace): void {
+    this.applicationStore.notificationService.notifyError(
+      'Advanced search panel not supported.',
+    );
+  }
 }

package/src/stores/shared/DataSpaceInfo.ts

@@ -19,39 +19,52 @@ import {
   type StoredEntity,
 } from '@finos/legend-server-depot';
 import { isString } from '@finos/legend-shared';
-import { extractEntityNameFromPath } from '@finos/legend-storage';
+import {
+  DepotEntityWithOrigin,
+  extractEntityNameFromPath,
+  type ProjectGAVCoordinates,
+} from '@finos/legend-storage';
+import { DATA_SPACE_ELEMENT_CLASSIFIER_PATH } from '../../graph-manager/protocol/pure/DSL_DataSpace_PureProtocolProcessorPlugin.js';
 
-export interface DataSpaceInfo {
-  groupId: string | undefined;
-  artifactId: string | undefined;
-  versionId: string | undefined;
+export class ResolvedDataSpaceEntityWithOrigin extends DepotEntityWithOrigin {
   title: string | undefined;
-  name: string;
-  path: string;
   /**
    * NOTE: technically, this should be always available, but we must not
-   * assume that no data product is marlformed, so we leave it as optional
+   * assume that no data product is malformed, so we leave it as optional
    */
   defaultExecutionContext: string | undefined;
+
+  constructor(
+    origin: ProjectGAVCoordinates | undefined,
+    title: string | undefined,
+    name: string,
+    path: string,
+    defaultExecutionContext: string | undefined,
+  ) {
+    super(origin, name, path, DATA_SPACE_ELEMENT_CLASSIFIER_PATH);
+    this.title = title;
+    this.defaultExecutionContext = defaultExecutionContext;
+  }
 }
 
 export const extractDataSpaceInfo = (
   storedEntity: StoredEntity,
   isSnapshot: boolean,
-): DataSpaceInfo => ({
-  groupId: storedEntity.groupId,
-  artifactId: storedEntity.artifactId,
-  versionId: isSnapshot ? SNAPSHOT_VERSION_ALIAS : storedEntity.versionId,
-  path: storedEntity.entity.path,
-  name: extractEntityNameFromPath(storedEntity.entity.path),
-  title: isString(storedEntity.entity.content.title)
-    ? storedEntity.entity.content.title
-    : undefined,
-  // NOTE: we don't want to assert the existence of this field even when it
-  // is required in the specification of data product, so we don't throw error here
-  defaultExecutionContext: isString(
-    storedEntity.entity.content.defaultExecutionContext,
-  )
-    ? storedEntity.entity.content.defaultExecutionContext
-    : undefined,
-});
+): ResolvedDataSpaceEntityWithOrigin =>
+  new ResolvedDataSpaceEntityWithOrigin(
+    {
+      groupId: storedEntity.groupId,
+      artifactId: storedEntity.artifactId,
+      versionId: isSnapshot ? SNAPSHOT_VERSION_ALIAS : storedEntity.versionId,
+    },
+    isString(storedEntity.entity.content.title)
+      ? storedEntity.entity.content.title
+      : undefined,
+    extractEntityNameFromPath(storedEntity.entity.path),
+    storedEntity.entity.path,
+    // NOTE: we don't want to assert the existence of this field even when it
+    // is required in the specification of data product, so we don't throw error here
+    isString(storedEntity.entity.content.defaultExecutionContext)
+      ? storedEntity.entity.content.defaultExecutionContext
+      : undefined,
+  );