@finos/legend-extension-dsl-data-space 10.0.3 → 10.0.5

package/src/components/DataSpaceViewerActivityBar.tsx

@@ -38,6 +38,7 @@ import {
 import {
   type DataSpaceViewerState,
   DATA_SPACE_VIEWER_ACTIVITY_MODE,
+  generateAnchorForActivity,
 } from '../stores/DataSpaceViewerState.js';
 
 const ActivityBarMenu = observer(
@@ -64,7 +65,7 @@ const ActivityBarMenu = observer(
                 <MenuContentItem onClick={toggleExpandedMode}>
                   {layoutState.isExpandedModeEnabled
                     ? 'Disable Expanded Mode'
-                    : 'Enable Expanded Mode'}{' '}
+                    : 'Enable Expanded Mode'}
                 </MenuContentItem>
               </MenuContent>
             }
@@ -89,8 +90,10 @@ export const DataSpaceViewerActivityBar = observer(
     const changeActivity =
       (activity: DATA_SPACE_VIEWER_ACTIVITY_MODE): (() => void) =>
       (): void => {
-        dataSpaceViewerState.setCurrentActivity(activity);
-        dataSpaceViewerState.onZoneChange?.(activity);
+        dataSpaceViewerState.changeZone(
+          generateAnchorForActivity(activity),
+          true,
+        );
       };
 
     const wikiActivities: DataSpaceViewerActivityConfig[] = [

package/src/components/DataSpaceWiki.tsx

@@ -21,11 +21,25 @@ import { DataSpaceModelsDocumentation } from './DataSpaceModelsDocumentation.js'
 import { DataSpaceQuickStart } from './DataSpaceQuickStart.js';
 import { DataSpaceDataAccess } from './DataSpaceDataAccess.js';
 import { DataSpaceDescription } from './DataSpaceDescription.js';
+import { useEffect } from 'react';
 
 export const DataSpaceWiki = observer(
   (props: { dataSpaceViewerState: DataSpaceViewerState }) => {
     const { dataSpaceViewerState } = props;
 
+    useEffect(() => {
+      if (
+        dataSpaceViewerState.layoutState.wikiNavigationCommand &&
+        dataSpaceViewerState.layoutState.isAllWikiPageFullyRendered
+      ) {
+        dataSpaceViewerState.layoutState.navigateWikiAnchor();
+      }
+    }, [
+      dataSpaceViewerState,
+      dataSpaceViewerState.layoutState.wikiNavigationCommand,
+      dataSpaceViewerState.layoutState.isAllWikiPageFullyRendered,
+    ]);
+
     return (
       <div className="data-space__viewer__wiki">
         <DataSpaceDescription dataSpaceViewerState={dataSpaceViewerState} />

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

@@ -19,6 +19,7 @@ import {
   type Mapping,
   type PackageableRuntime,
   type PureModel,
+  type DatasetSpecification,
 } 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';
@@ -31,6 +32,8 @@ export class DataSpaceExecutionContextAnalysisResult {
   mapping!: Mapping;
   defaultRuntime!: PackageableRuntime;
   compatibleRuntimes!: PackageableRuntime[];
+  // TODO: mapping coverage analysis
+  datasets: DatasetSpecification[] = [];
 }
 
 export class DataSpaceTaggedValueInfo {
@@ -158,6 +161,7 @@ export class DataSpaceExecutableAnalysisResult {
   executable!: string;
   info?: DataSpaceExecutableInfo | undefined;
   result!: DataSpaceExecutableResult;
+  datasets: DatasetSpecification[] = [];
 }
 
 export class DataSpaceAnalysisResult {

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

@@ -17,7 +17,7 @@
 import { getExpectedArtifactGenerationExtensionOutputPath } from '@finos/legend-graph';
 import type {
   DepotServerClient,
-  ProjectData,
+  StoreProjectData,
 } from '@finos/legend-server-depot';
 import type { PlainObject } from '@finos/legend-shared';
 import type { DataSpaceAnalysisResult } from './DataSpaceAnalysis.js';
@@ -26,7 +26,7 @@ const DATASPACE_ANALYTICS_FILE_NAME = 'AnalyticsResult.json';
 const V1_DATASPACE_ANALYTICS_ARTIFACT_EXTENSION_KEY = 'dataSpace-analytics';
 
 export const retrieveAnalyticsResultCache = async (
-  project: ProjectData,
+  project: StoreProjectData,
   versionId: string,
   dataSpacePath: string,
   depotServerClient: DepotServerClient,

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

@@ -28,6 +28,8 @@ import {
   V1_EngineRuntime,
   V1_Class,
   GRAPH_MANAGER_EVENT,
+  V1_buildDatasetSpecification,
+  type PureProtocolProcessorPlugin,
 } from '@finos/legend-graph';
 import type { Entity } from '@finos/legend-storage';
 import {
@@ -68,12 +70,13 @@ import {
 } from '../../../action/analytics/DataSpaceAnalysis.js';
 import { DSL_DataSpace_PureGraphManagerExtension } from '../DSL_DataSpace_PureGraphManagerExtension.js';
 import {
-  V1_DataSpaceAnalysisResult,
+  type V1_DataSpaceAnalysisResult,
   V1_DataSpaceAssociationDocumentationEntry,
   V1_DataSpaceClassDocumentationEntry,
   V1_DataSpaceEnumerationDocumentationEntry,
   V1_DataSpaceExecutableTDSResult,
   V1_DataSpaceServiceExecutableInfo,
+  V1_deserializeDataSpaceAnalysisResult,
 } from './engine/analytics/V1_DataSpaceAnalysis.js';
 import { getDiagram } from '@finos/legend-extension-dsl-diagram/graph';
 
@@ -141,13 +144,16 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       );
     }
     return this.buildDataSpaceAnalytics(
-      V1_DataSpaceAnalysisResult.deserialize(analysisResult),
+      analysisResult,
+      this.graphManager.pluginManager.getPureProtocolProcessorPlugins(),
     );
   }
 
   private async buildDataSpaceAnalytics(
-    analysisResult: V1_DataSpaceAnalysisResult,
+    json: PlainObject<V1_DataSpaceAnalysisResult>,
+    plugins: PureProtocolProcessorPlugin[],
   ): Promise<DataSpaceAnalysisResult> {
+    const analysisResult = V1_deserializeDataSpaceAnalysisResult(json, plugins);
     const result = new DataSpaceAnalysisResult();
     result.name = analysisResult.name;
     result.package = analysisResult.package;
@@ -310,6 +316,9 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       contextAnalysisResult.compatibleRuntimes = context.compatibleRuntimes.map(
         (runtime) => graph.getRuntime(runtime),
       );
+      contextAnalysisResult.datasets = context.datasets.map((dataset) =>
+        V1_buildDatasetSpecification(dataset, plugins),
+      );
       result.executionContextsIndex.set(
         contextAnalysisResult.name,
         contextAnalysisResult,
@@ -445,6 +454,9 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
         executable.title = executableProtocol.title;
         executable.description = executableProtocol.description;
         executable.executable = executableProtocol.executable;
+        executable.datasets = executableProtocol.datasets.map((dataset) =>
+          V1_buildDatasetSpecification(dataset, plugins),
+        );
         if (
           executableProtocol.info instanceof V1_DataSpaceServiceExecutableInfo
         ) {

package/src/graph-manager/protocol/pure/v1/engine/analytics/V1_DataSpaceAnalysis.ts

@@ -18,6 +18,9 @@ import {
   type V1_Multiplicity,
   V1_PureModelContextData,
   V1_multiplicityModelSchema,
+  type V1_DatasetSpecification,
+  type PureProtocolProcessorPlugin,
+  V1_deserializeDatasetSpecification,
 } from '@finos/legend-graph';
 import {
   SerializationFactory,
@@ -39,6 +42,7 @@ import {
   optional,
   primitive,
   SKIP,
+  type ModelSchema,
 } from 'serializr';
 import type { V1_DataSpaceSupportInfo } from '../../model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
 import { V1_deserializeSupportInfo } from '../../transformation/pureProtocol/V1_DSL_DataSpace_ProtocolHelper.js';
@@ -76,19 +80,28 @@ class V1_DataSpaceExecutionContextAnalysisResult {
   mapping!: string;
   defaultRuntime!: string;
   compatibleRuntimes!: string[];
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataSpaceExecutionContextAnalysisResult, {
-      compatibleRuntimes: list(primitive()),
-      defaultRuntime: primitive(),
-      description: optional(primitive()),
-      mapping: primitive(),
-      name: primitive(),
-      title: optional(primitive()),
-    }),
-  );
+  datasets: V1_DatasetSpecification[] = [];
 }
 
+const V1_dataSpaceExecutionContextAnalysisResultModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DataSpaceExecutionContextAnalysisResult> =>
+  createModelSchema(V1_DataSpaceExecutionContextAnalysisResult, {
+    compatibleRuntimes: list(primitive()),
+    datasets: list(
+      custom(
+        () => SKIP,
+        (val: PlainObject<V1_DatasetSpecification>) =>
+          V1_deserializeDatasetSpecification(val, plugins),
+      ),
+    ),
+    defaultRuntime: primitive(),
+    description: optional(primitive()),
+    mapping: primitive(),
+    name: primitive(),
+    title: optional(primitive()),
+  });
+
 export class V1_DataSpaceBasicDocumentationEntry {
   name!: string;
   docs: string[] = [];
@@ -321,18 +334,27 @@ export class V1_DataSpaceExecutableAnalysisResult {
   executable!: string;
   info?: V1_DataSpaceExecutableInfo | undefined;
   result!: V1_DataSpaceExecutableResult;
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataSpaceExecutableAnalysisResult, {
-      executable: primitive(),
-      description: optional(primitive()),
-      info: optionalCustom(() => SKIP, V1_deserializeDataSpaceExecutableInfo),
-      result: custom(() => SKIP, V1_deserializeDataSpaceExecutableResult),
-      title: primitive(),
-    }),
-  );
+  datasets: V1_DatasetSpecification[] = [];
 }
 
+const V1_dataSpaceExecutableAnalysisResultModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DataSpaceExecutableAnalysisResult> =>
+  createModelSchema(V1_DataSpaceExecutableAnalysisResult, {
+    datasets: list(
+      custom(
+        () => SKIP,
+        (val: PlainObject<V1_DatasetSpecification>) =>
+          V1_deserializeDatasetSpecification(val, plugins),
+      ),
+    ),
+    executable: primitive(),
+    description: optional(primitive()),
+    info: optionalCustom(() => SKIP, V1_deserializeDataSpaceExecutableInfo),
+    result: custom(() => SKIP, V1_deserializeDataSpaceExecutableResult),
+    title: primitive(),
+  });
+
 export class V1_DataSpaceAnalysisResult {
   name!: string;
   package!: string;
@@ -355,74 +377,75 @@ export class V1_DataSpaceAnalysisResult {
 
   executables: V1_DataSpaceExecutableAnalysisResult[] = [];
   diagrams: V1_DataSpaceDiagramAnalysisResult[] = [];
+}
 
-  private static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataSpaceAnalysisResult, {
-      name: primitive(),
-      package: primitive(),
-      path: primitive(),
-
-      taggedValues: list(object(V1_DataSpaceTaggedValueInfo)),
-      stereotypes: list(object(V1_DataSpaceStereotypeInfo)),
-
-      title: optional(primitive()),
-      description: optional(primitive()),
-
-      supportInfo: optionalCustom(
-        () => SKIP,
-        (val) => V1_deserializeSupportInfo(val),
-      ),
-
-      model: object(V1_PureModelContextData),
-
-      executionContexts: list(
-        object(V1_DataSpaceExecutionContextAnalysisResult),
-      ),
-      defaultExecutionContext: primitive(),
-
-      elements: list(primitive()),
-      elementDocs: list(
-        custom(() => SKIP, V1_deserializeModelDocumentationEntry),
-      ),
-
-      featuredDiagrams: list(primitive()),
-      diagrams: customListWithSchema(
-        V1_DataSpaceDiagramAnalysisResult.serialization.schema,
-      ),
-      executables: customListWithSchema(
-        V1_DataSpaceExecutableAnalysisResult.serialization.schema,
-      ),
-    }),
+const V1_dataSpaceAnalysisResultModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DataSpaceAnalysisResult> =>
+  createModelSchema(V1_DataSpaceAnalysisResult, {
+    name: primitive(),
+    package: primitive(),
+    path: primitive(),
+
+    taggedValues: list(object(V1_DataSpaceTaggedValueInfo)),
+    stereotypes: list(object(V1_DataSpaceStereotypeInfo)),
+
+    title: optional(primitive()),
+    description: optional(primitive()),
+
+    supportInfo: optionalCustom(
+      () => SKIP,
+      (val) => V1_deserializeSupportInfo(val),
+    ),
+
+    model: object(V1_PureModelContextData),
+
+    executionContexts: customListWithSchema(
+      V1_dataSpaceExecutionContextAnalysisResultModelSchema(plugins),
+    ),
+    defaultExecutionContext: primitive(),
+
+    elements: list(primitive()),
+    elementDocs: list(
+      custom(() => SKIP, V1_deserializeModelDocumentationEntry),
+    ),
+
+    featuredDiagrams: list(primitive()),
+    diagrams: customListWithSchema(
+      V1_DataSpaceDiagramAnalysisResult.serialization.schema,
+    ),
+    executables: customListWithSchema(
+      V1_dataSpaceExecutableAnalysisResultModelSchema(plugins),
+    ),
+  });
+
+export const V1_deserializeDataSpaceAnalysisResult = (
+  json: PlainObject<V1_DataSpaceAnalysisResult>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_DataSpaceAnalysisResult => {
+  const result = deserialize(
+    V1_dataSpaceAnalysisResultModelSchema(plugins),
+    json,
   );
-
-  static deserialize(
-    json: PlainObject<V1_DataSpaceAnalysisResult>,
-  ): V1_DataSpaceAnalysisResult {
-    const result = deserialize(
-      V1_DataSpaceAnalysisResult.serialization.schema,
-      json,
-    );
-    /**
-     * Featured diagrams will be transformed to diagrams, so here we nicely
-     * auto-transform it for backward compatibility
-     *
-     * @backwardCompatibility
-     */
-    if (json.featuredDiagrams && Array.isArray(json.featuredDiagrams)) {
-      const diagramResults = json.featuredDiagrams
-        .map((featuredDiagram) => {
-          if (isString(featuredDiagram)) {
-            const diagramAnalysisResult =
-              new V1_DataSpaceDiagramAnalysisResult();
-            diagramAnalysisResult.title = '';
-            diagramAnalysisResult.diagram = featuredDiagram;
-            return diagramAnalysisResult;
-          }
-          return undefined;
-        })
-        .filter(isNonNullable);
-      result.diagrams = result.diagrams.concat(diagramResults);
-    }
-    return result;
+  /**
+   * Featured diagrams will be transformed to diagrams, so here we nicely
+   * auto-transform it for backward compatibility
+   *
+   * @backwardCompatibility
+   */
+  if (json.featuredDiagrams && Array.isArray(json.featuredDiagrams)) {
+    const diagramResults = json.featuredDiagrams
+      .map((featuredDiagram) => {
+        if (isString(featuredDiagram)) {
+          const diagramAnalysisResult = new V1_DataSpaceDiagramAnalysisResult();
+          diagramAnalysisResult.title = '';
+          diagramAnalysisResult.diagram = featuredDiagram;
+          return diagramAnalysisResult;
+        }
+        return undefined;
+      })
+      .filter(isNonNullable);
+    result.diagrams = result.diagrams.concat(diagramResults);
   }
-}
+  return result;
+};

package/src/stores/DSL_DataSpace_LegendApplicationPlugin_Extension.ts

@@ -25,6 +25,11 @@ export type TDSExecutableActionConfiguration = {
   key: string;
   title: string;
   icon?: React.ReactNode | undefined;
+  isSupported: (
+    dataSpaceViewerState: DataSpaceViewerState,
+    executableAnalysisResult: DataSpaceExecutableAnalysisResult,
+    tdsResult: DataSpaceExecutableTDSResult,
+  ) => boolean;
   renderer: (
     dataSpaceViewerState: DataSpaceViewerState,
     executableAnalysisResult: DataSpaceExecutableAnalysisResult,

package/src/stores/DataSpaceModelsDocumentationState.ts

@@ -345,7 +345,7 @@ export class DataSpaceViewerModelsDocumentationState {
   showSearchConfigurationMenu = false;
 
   // filter
-  showFilterPanel = false;
+  showFilterPanel = true;
   typeFilterTreeData: TreeData<ModelsDocumentationFilterTreeNodeData>;
   packageFilterTreeData: TreeData<ModelsDocumentationFilterTreeNodeData>;
   filterTypes: string[] = [];