@finos/legend-extension-dsl-data-space 10.3.81 → 10.3.83

package/src/components/query-builder/DataSpaceQueryBuilderTemplateQueryPanelContent.tsx

@@ -22,26 +22,23 @@ import {
   TagIcon,
 } from '@finos/legend-art';
 import { observer } from 'mobx-react-lite';
-import { useRef } from 'react';
+import { useEffect, useRef } from 'react';
 import {
   ActionAlertActionType,
   ActionAlertType,
   useApplicationStore,
 } from '@finos/legend-application';
 import { DocumentationLink } from '@finos/legend-lego/application';
-import type { DataSpaceExecutable } from '../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import type { DataSpaceQueryBuilderState } from '../../stores/query-builder/DataSpaceQueryBuilderState.js';
 import { DSL_DATA_SPACE_LEGEND_QUERY_DOCUMENTATION_KEY } from '../../__lib__/query/DSL_DataSpace_LegendQueryDocumentation.js';
-import {
-  getExecutionContextFromDataspaceExecutable,
-  getQueryFromDataspaceExecutable,
-} from '../../graph-manager/DSL_DataSpace_GraphManagerHelper.js';
+import { flowResult } from 'mobx';
+import type { DataSpaceExecutableAnalysisResult } from '../../graph-manager/action/analytics/DataSpaceAnalysis.js';
 
 const DataSpaceTemplateQueryDialog = observer(
   (props: {
     triggerElement: HTMLElement | null;
     queryBuilderState: DataSpaceQueryBuilderState;
-    templateQueries: DataSpaceExecutable[];
+    templateQueries: DataSpaceExecutableAnalysisResult[];
   }) => {
     const { triggerElement, queryBuilderState, templateQueries } = props;
     const applicationStore = useApplicationStore();
@@ -49,42 +46,43 @@ const DataSpaceTemplateQueryDialog = observer(
       queryBuilderState.setTemplateQueryDialogOpen(false);
     };
 
-    const loadTemplateQuery = (template: DataSpaceExecutable): void => {
-      const executionContext = getExecutionContextFromDataspaceExecutable(
-        queryBuilderState.dataSpace,
-        template,
-      );
-      if (!executionContext) {
-        applicationStore.notificationService.notifyError(
-          'Unable find an executionContext of this template query within current dataspace',
-        );
+    const loadTemplateQuery = async (
+      template: DataSpaceExecutableAnalysisResult,
+    ): Promise<void> => {
+      let query;
+      if (template.info) {
+        query =
+          await queryBuilderState.graphManagerState.graphManager.pureCodeToLambda(
+            template.info.query,
+          );
       }
-      const query = getQueryFromDataspaceExecutable(
-        template,
-        queryBuilderState.graphManagerState,
-      );
       if (!query) {
         applicationStore.notificationService.notifyError(
           'Unable get a query from this template query',
         );
-      }
-      if (
-        query &&
-        executionContext &&
-        executionContext.hashCode !==
-          queryBuilderState.executionContext.hashCode
-      ) {
-        queryBuilderState.setExecutionContext(executionContext);
-        queryBuilderState.propagateExecutionContextChange(executionContext);
-        queryBuilderState.initializeWithQuery(query);
-        queryBuilderState.onExecutionContextChange?.(executionContext);
-      } else if (query) {
-        queryBuilderState.initializeWithQuery(query);
+      } else {
+        const executionContext =
+          queryBuilderState.dataSpace.executionContexts.filter(
+            (ex) => ex.name === template.info?.executionContextKey,
+          )[0];
+        if (
+          executionContext &&
+          executionContext.name !== queryBuilderState.executionContext.name
+        ) {
+          queryBuilderState.setExecutionContext(executionContext);
+          queryBuilderState.propagateExecutionContextChange(executionContext);
+          queryBuilderState.initializeWithQuery(query);
+          queryBuilderState.onExecutionContextChange?.(executionContext);
+        } else {
+          queryBuilderState.initializeWithQuery(query);
+        }
       }
       handleClose();
     };
 
-    const loadQuery = (template: DataSpaceExecutable): void => {
+    const loadQuery = async (
+      template: DataSpaceExecutableAnalysisResult,
+    ): Promise<void> => {
       if (queryBuilderState.changeDetectionState.hasChanged) {
         applicationStore.alertService.setActionAlertInfo({
           message:
@@ -94,7 +92,9 @@ const DataSpaceTemplateQueryDialog = observer(
             {
               label: 'Proceed',
               type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-              handler: (): void => loadTemplateQuery(template),
+              handler: (): void => {
+                flowResult(loadTemplateQuery(template));
+              },
             },
             {
               label: 'Abort',
@@ -104,11 +104,13 @@ const DataSpaceTemplateQueryDialog = observer(
           ],
         });
       } else {
-        loadTemplateQuery(template);
+        flowResult(loadTemplateQuery(template));
       }
     };
 
-    const visitTemplateQuery = (template: DataSpaceExecutable): void => {
+    const visitTemplateQuery = (
+      template: DataSpaceExecutableAnalysisResult,
+    ): void => {
       if (queryBuilderState.dataSpaceRepo.canVisitTemplateQuery) {
         queryBuilderState.dataSpaceRepo.visitTemplateQuery(
           queryBuilderState.dataSpace,
@@ -157,7 +159,9 @@ const DataSpaceTemplateQueryDialog = observer(
                   <button
                     className="query-builder__data-space__template-query-panel__query__entry"
                     title="click to load template query"
-                    onClick={() => loadQuery(query)}
+                    onClick={() => {
+                      flowResult(loadQuery(query));
+                    }}
                   >
                     <div className="query-builder__data-space__template-query-panel__query__entry__content">
                       <div className="query-builder__data-space__template-query-panel__query__entry__content__title">
@@ -196,12 +200,17 @@ const DataSpaceTemplateQueryDialog = observer(
 const DataSpaceQueryBuilderTemplateQueryPanel = observer(
   (props: { queryBuilderState: DataSpaceQueryBuilderState }) => {
     const { queryBuilderState } = props;
+    const applicationStore = useApplicationStore();
     const templateQueryButtonRef = useRef<HTMLButtonElement>(null);
-    const templateQueries = queryBuilderState.dataSpace.executables;
-
     const showTemplateQueries = (): void => {
       queryBuilderState.setTemplateQueryDialogOpen(true);
     };
+    const templateQueries = queryBuilderState.displayedTemplateQueries;
+    useEffect(() => {
+      flowResult(queryBuilderState.intialize()).catch(
+        applicationStore.alertUnhandledError,
+      );
+    }, [queryBuilderState, applicationStore.alertUnhandledError]);
 
     return (
       <>

package/src/graph-manager/action/analytics/DataSpaceAnalysis.ts

@@ -21,6 +21,7 @@ import type {
   PureModel,
   DatasetSpecification,
   MappingModelCoverageAnalysisResult,
+  FunctionAnalysisInfo,
 } from '@finos/legend-graph';
 import { prettyCONSTName, uuid } from '@finos/legend-shared';
 import type { DataSpaceSupportInfo } from '../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
@@ -221,6 +222,9 @@ export class DataSpaceAnalysisResult {
     MappingModelCoverageAnalysisResult
   >;
 
+  functionInfos?: Map<string, FunctionAnalysisInfo>;
+  dependencyFunctionInfos?: Map<string, FunctionAnalysisInfo>;
+
   get displayName(): string {
     return this.title ?? prettyCONSTName(this.name);
   }

package/src/graph-manager/action/analytics/DataSpaceAnalysisHelper.ts

@@ -14,13 +14,31 @@
  * limitations under the License.
  */
 
-import { getExpectedArtifactGenerationExtensionOutputPath } from '@finos/legend-graph';
+import {
+  type GraphManagerState,
+  ConcreteFunctionDefinition,
+  getExpectedArtifactGenerationExtensionOutputPath,
+  Service,
+} from '@finos/legend-graph';
 import type {
   DepotServerClient,
   StoreProjectData,
 } from '@finos/legend-server-depot';
-import type { PlainObject } from '@finos/legend-shared';
-import type { DataSpaceAnalysisResult } from './DataSpaceAnalysis.js';
+import { isNonNullable, type PlainObject } from '@finos/legend-shared';
+import {
+  type DataSpaceAnalysisResult,
+  DataSpaceExecutableAnalysisResult,
+  DataSpaceFunctionPointerExecutableInfo,
+  DataSpaceServiceExecutableInfo,
+  DataSpaceTemplateExecutableInfo,
+} from './DataSpaceAnalysis.js';
+import {
+  type DataSpaceExecutable,
+  type DataSpace,
+  DataSpaceExecutableTemplate,
+  DataSpacePackageableElementExecutable,
+} from '../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
+import { getQueryFromDataspaceExecutable } from '../../DSL_DataSpace_GraphManagerHelper.js';
 
 const DATASPACE_ANALYTICS_FILE_NAME = 'AnalyticsResult.json';
 const V1_DATASPACE_ANALYTICS_ARTIFACT_EXTENSION_KEY = 'dataSpace-analytics';
@@ -42,3 +60,52 @@ export const retrieveAnalyticsResultCache = async (
       ),
     ),
   );
+
+export const buildDataSpaceExecutableAnalysisResultFromExecutable = async (
+  dataspace: DataSpace,
+  executables: DataSpaceExecutable[],
+  graphManagerState: GraphManagerState,
+): Promise<DataSpaceExecutableAnalysisResult[]> =>
+  (
+    await Promise.all(
+      executables.map(async (executable) => {
+        const result = new DataSpaceExecutableAnalysisResult();
+        result.title = executable.title;
+        result.description = executable.description;
+        let info;
+        const query = getQueryFromDataspaceExecutable(
+          executable,
+          graphManagerState,
+        );
+        if (executable instanceof DataSpaceExecutableTemplate) {
+          info = new DataSpaceTemplateExecutableInfo();
+          if (executable.id) {
+            info.id = executable.id;
+          }
+        } else if (
+          executable instanceof DataSpacePackageableElementExecutable
+        ) {
+          if (executable.executable.value instanceof Service) {
+            info = new DataSpaceServiceExecutableInfo();
+            info.id = executable.id ?? executable.executable.value.path;
+          } else if (
+            executable.executable.value instanceof ConcreteFunctionDefinition
+          ) {
+            info = new DataSpaceFunctionPointerExecutableInfo();
+            info.id = executable.id ?? executable.executable.value.path;
+          }
+        }
+        if (info) {
+          info.executionContextKey =
+            executable.executionContextKey ??
+            dataspace.defaultExecutionContext.name;
+          if (query) {
+            info.query =
+              await graphManagerState.graphManager.lambdaToPureCode(query);
+          }
+        }
+        result.info = info;
+        return result;
+      }),
+    )
+  ).filter(isNonNullable);

package/src/graph-manager/index.ts

@@ -21,6 +21,8 @@ export * from '../graph/DSL_DataSpace_MetaModelConst.js';
 
 export * from './DSL_DataSpace_GraphManagerPreset.js';
 
+export { V1_DataSpaceAnalysisResult } from './protocol/pure/v1/engine/analytics/V1_DataSpaceAnalysis.js';
+
 export {
   DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
   DATA_SPACE_ELEMENT_POINTER,

package/src/graph-manager/protocol/pure/DSL_DataSpace_PureGraphManagerExtension.ts

@@ -16,6 +16,7 @@
 
 import {
   type AbstractPureGraphManager,
+  type PureProtocolProcessorPlugin,
   AbstractPureGraphManagerExtension,
   type QueryInfo,
 } from '@finos/legend-graph';
@@ -26,6 +27,7 @@ import {
   type PlainObject,
 } from '@finos/legend-shared';
 import type { DataSpaceAnalysisResult } from '../../action/analytics/DataSpaceAnalysis.js';
+import type { V1_DataSpaceAnalysisResult } from './v1/engine/analytics/V1_DataSpaceAnalysis.js';
 
 export abstract class DSL_DataSpace_PureGraphManagerExtension extends AbstractPureGraphManagerExtension {
   abstract analyzeDataSpace(
@@ -51,6 +53,11 @@ export abstract class DSL_DataSpace_PureGraphManagerExtension extends AbstractPu
   ): Promise<Entity>;
 
   abstract IsTemplateQueryIdValid(dataSpaceEntity: Entity, id: string): boolean;
+
+  abstract buildDataSpaceAnalytics(
+    json: PlainObject<V1_DataSpaceAnalysisResult>,
+    plugins: PureProtocolProcessorPlugin[],
+  ): Promise<DataSpaceAnalysisResult>;
 }
 
 export const DSL_DataSpace_getGraphManagerExtension = (

package/src/graph-manager/protocol/pure/v1/V1_DSL_DataSpace_PureGraphManagerExtension.ts

@@ -255,7 +255,7 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     return cacheResult;
   }
 
-  private async buildDataSpaceAnalytics(
+  async buildDataSpaceAnalytics(
     json: PlainObject<V1_DataSpaceAnalysisResult>,
     plugins: PureProtocolProcessorPlugin[],
   ): Promise<DataSpaceAnalysisResult> {

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

@@ -21,19 +21,20 @@ import {
   type QueryBuilderWorkflowState,
   type QueryBuilderActionConfig,
   QueryBuilderState,
+  type QueryBuilderExtraFunctionAnalysisInfo,
 } from '@finos/legend-query-builder';
 import {
   type Class,
   type GraphManagerState,
-  getMappingCompatibleClasses,
-  RuntimePointer,
   type QueryExecutionContext,
   type Runtime,
   type Mapping,
+  type FunctionAnalysisInfo,
+  getMappingCompatibleClasses,
   Package,
   QueryDataSpaceExecutionContext,
-  Service,
   elementBelongsToPackage,
+  RuntimePointer,
 } from '@finos/legend-graph';
 import {
   type DepotServerClient,
@@ -45,27 +46,30 @@ import {
   type GeneratorFn,
   ActionState,
   assertErrorThrown,
-  getNullableFirstEntry,
   filterByType,
+  getNullableFirstEntry,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import { renderDataSpaceQueryBuilderSetupPanelContent } from '../../components/query-builder/DataSpaceQueryBuilder.js';
 import {
+  type DataSpaceElement,
   type DataSpaceExecutionContext,
-  type DataSpaceExecutable,
   DataSpace,
-  DataSpacePackageableElementExecutable,
-  type DataSpaceElement,
 } 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 { DataSpaceAnalysisResult } from '../../graph-manager/action/analytics/DataSpaceAnalysis.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 { buildDataSpaceExecutableAnalysisResultFromExecutable } from '../../graph-manager/action/analytics/DataSpaceAnalysisHelper.js';
 
 const matchesDataElement = (
   _class: Class,
@@ -106,6 +110,7 @@ export const resolveUsableDataSpaceClasses = (
   }
   return compatibleClasses;
 };
+
 export interface DataSpaceQuerySDLC extends QuerySDLC {
   groupId: string;
   artifactId: string;
@@ -142,7 +147,7 @@ export abstract class DataSpacesBuilderRepoistory {
   abstract loadDataSpaces(): GeneratorFn<void>;
   abstract visitTemplateQuery(
     dataSpace: DataSpace,
-    template: DataSpaceExecutable,
+    template: DataSpaceExecutableAnalysisResult,
   ): void;
 
   configureDataSpaceOptions(val: DataSpaceInfo[]): void {
@@ -183,7 +188,7 @@ export class DataSpacesGraphRepoistory extends DataSpacesBuilderRepoistory {
 
   override visitTemplateQuery(
     dataSpace: DataSpace,
-    template: DataSpaceExecutable,
+    template: DataSpaceExecutableAnalysisResult,
   ): void {
     throw new Error('Method not implemented.');
   }
@@ -249,24 +254,21 @@ export class DataSpacesDepotRepository extends DataSpacesBuilderRepoistory {
 
   override visitTemplateQuery(
     dataSpace: DataSpace,
-    template: DataSpaceExecutable,
+    template: DataSpaceExecutableAnalysisResult,
   ): void {
-    if (template.id) {
-      this.applicationStore.navigationService.navigator.visitAddress(
-        this.applicationStore.navigationService.navigator.generateAddress(
-          generateDataSpaceTemplateQueryCreatorRoute(
-            this.project.groupId,
-            this.project.artifactId,
-            this.project.versionId,
-            dataSpace.path,
-            template.id,
-          ),
-        ),
+    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 if (
-      template instanceof DataSpacePackageableElementExecutable &&
-      template.executable.value instanceof Service
-    ) {
+    } else {
       this.applicationStore.navigationService.navigator.visitAddress(
         this.applicationStore.navigationService.navigator.generateAddress(
           generateDataSpaceTemplateQueryCreatorRoute(
@@ -274,14 +276,10 @@ export class DataSpacesDepotRepository extends DataSpacesBuilderRepoistory {
             this.project.artifactId,
             this.project.versionId,
             dataSpace.path,
-            template.executable.value.path,
+            templateId,
           ),
         ),
       );
-    } else {
-      this.applicationStore.notificationService.notifyWarning(
-        `Can't visit tempalte query without a Id`,
-      );
     }
   }
 
@@ -353,6 +351,7 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   executionContext!: DataSpaceExecutionContext;
   showRuntimeSelector = false;
   isTemplateQueryDialogOpen = false;
+  displayedTemplateQueries: DataSpaceExecutableAnalysisResult[] | undefined;
 
   constructor(
     applicationStore: GenericLegendApplicationStore,
@@ -378,9 +377,11 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
       executionContext: observable,
       showRuntimeSelector: observable,
       isTemplateQueryDialogOpen: observable,
+      displayedTemplateQueries: observable,
       setExecutionContext: action,
       setShowRuntimeSelector: action,
       setTemplateQueryDialogOpen: action,
+      intialize: flow,
     });
 
     this.dataSpace = dataSpace;
@@ -460,4 +461,43 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
       }
     }
   }
+
+  override buildFunctionAnalysisInfo():
+    | QueryBuilderExtraFunctionAnalysisInfo
+    | undefined {
+    let functionInfoMap: Map<string, FunctionAnalysisInfo> = new Map<
+      string,
+      FunctionAnalysisInfo
+    >();
+    let dependencyFunctionInfoMap: Map<string, FunctionAnalysisInfo> = new Map<
+      string,
+      FunctionAnalysisInfo
+    >();
+    const functionInfos = this.dataSpaceAnalysisResult?.functionInfos;
+    if (functionInfos) {
+      functionInfoMap = functionInfos;
+    }
+    const dependencyFunctionInfos =
+      this.dataSpaceAnalysisResult?.dependencyFunctionInfos;
+    if (dependencyFunctionInfos) {
+      dependencyFunctionInfoMap = dependencyFunctionInfos;
+    }
+    return {
+      functionInfoMap,
+      dependencyFunctionInfoMap,
+    };
+  }
+
+  *intialize(): GeneratorFn<void> {
+    this.displayedTemplateQueries =
+      this.dataSpace.executables && this.dataSpace.executables.length > 0
+        ? ((yield buildDataSpaceExecutableAnalysisResultFromExecutable(
+            this.dataSpace,
+            this.dataSpace.executables,
+            this.graphManagerState,
+          )) as DataSpaceExecutableAnalysisResult[])
+        : this.dataSpaceAnalysisResult?.executables.filter(
+            (ex) => ex.info !== undefined,
+          );
+  }
 }