@finos/legend-extension-dsl-data-space 0.1.1 → 1.0.3

package/src/components/studio/{DSLDataSpace_StudioPlugin.tsx → DSLDataSpace_LegendStudioPlugin.tsx}

@@ -16,12 +16,11 @@
 
 import packageJson from '../../../package.json';
 import type {
-  StudioPluginManager,
   NewElementFromStateCreator,
   ElementTypeGetter,
   ElementProjectExplorerDnDTypeGetter,
   ElementIconGetter,
-  DSL_StudioPlugin_Extension,
+  DSL_LegendStudioPlugin_Extension,
   NewElementState,
   ElementEditorStateCreator,
   EditorStore,
@@ -29,7 +28,7 @@ import type {
 } from '@finos/legend-studio';
 import {
   UnsupportedElementEditorState,
-  StudioPlugin,
+  LegendStudioPlugin,
 } from '@finos/legend-studio';
 import { SquareIcon } from '@finos/legend-art';
 import type { PackageableElement } from '@finos/legend-graph';
@@ -37,23 +36,20 @@ import {
   DataSpace,
   DataSpaceExecutionContext,
 } from '../../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
+import { LATEST_VERSION_ALIAS } from '@finos/legend-server-depot';
 
 const DATA_SPACE_ELEMENT_TYPE = 'DATA SPACE';
 const DATA_SPACE_ELEMENT_PROJECT_EXPLORER_DND_TYPE =
   'PROJECT_EXPLORER_DATA_SPACE';
 
-export class DSLDataSpace_StudioPlugin
-  extends StudioPlugin
-  implements DSL_StudioPlugin_Extension
+export class DSLDataSpace_LegendStudioPlugin
+  extends LegendStudioPlugin
+  implements DSL_LegendStudioPlugin_Extension
 {
   constructor() {
     super(packageJson.extensions.studioPlugin, packageJson.version);
   }
 
-  install(pluginManager: StudioPluginManager): void {
-    pluginManager.registerStudioPlugin(this);
-  }
-
   getExtraSupportedElementTypes(): string[] {
     return [DATA_SPACE_ELEMENT_TYPE];
   }
@@ -74,7 +70,7 @@ export class DSLDataSpace_StudioPlugin
       (type: string): React.ReactNode | undefined => {
         if (type === DATA_SPACE_ELEMENT_TYPE) {
           return (
-            <div className="icon icon--text-element">
+            <div className="icon icon--data-space">
               <SquareIcon />
             </div>
           );
@@ -97,7 +93,7 @@ export class DSLDataSpace_StudioPlugin
             state.editorStore.projectConfigurationEditorState.currentProjectConfiguration.groupId;
           dataSpace.artifactId =
             state.editorStore.projectConfigurationEditorState.currentProjectConfiguration.artifactId;
-          dataSpace.versionId = 'latest';
+          dataSpace.versionId = LATEST_VERSION_ALIAS;
           const dataSpaceExecutionContext = new DataSpaceExecutionContext();
           dataSpaceExecutionContext.name = 'dummyContext';
           dataSpaceExecutionContext.mapping = 'dummyMapping';

package/src/graph/DSLDataSpace_PureGraphPlugin.ts

@@ -17,10 +17,7 @@
 import packageJson from '../../package.json';
 import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
 import type { Clazz } from '@finos/legend-shared';
-import type {
-  GraphPluginManager,
-  PackageableElement,
-} from '@finos/legend-graph';
+import type { PackageableElement } from '@finos/legend-graph';
 import { PureGraphPlugin } from '@finos/legend-graph';
 
 export class DSLDataSpace_PureGraphPlugin extends PureGraphPlugin {
@@ -28,10 +25,6 @@ export class DSLDataSpace_PureGraphPlugin extends PureGraphPlugin {
     super(packageJson.extensions.pureGraphPlugin, packageJson.version);
   }
 
-  install(pluginManager: GraphPluginManager): void {
-    pluginManager.registerPureGraphPlugin(this);
-  }
-
   override getExtraPureGraphExtensionClasses(): Clazz<PackageableElement>[] {
     return [DataSpace];
   }

package/src/graphManager/DSLDataSpace_PureGraphManagerPlugin.ts

@@ -17,7 +17,6 @@
 import packageJson from '../../package.json';
 import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
 import type {
-  GraphPluginManager,
   PackageableElement,
   PureGrammarElementLabeler,
 } from '@finos/legend-graph';
@@ -31,10 +30,6 @@ export class DSLDataSpace_PureGraphManagerPlugin extends PureGraphManagerPlugin
     super(packageJson.extensions.pureGraphManagerPlugin, packageJson.version);
   }
 
-  install(pluginManager: GraphPluginManager): void {
-    pluginManager.registerPureGraphManagerPlugin(this);
-  }
-
   override getExtraPureGrammarParserNames(): string[] {
     return [PURE_GRAMMAR_DATA_SPACE_PARSER_NAME];
   }

package/src/index.ts

@@ -15,3 +15,15 @@
  */
 
 export * from './DSLDataSpace_Extension';
+export { DSLDataSpace_LegendStudioPlugin } from './components/studio/DSLDataSpace_LegendStudioPlugin';
+export { DSLDataSpace_LegendQueryPlugin } from './components/query/DSLDataSpace_LegendQueryPlugin';
+
+export { DataSpaceViewer } from './components/DataSpaceViewer';
+
+export {
+  DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
+  extractDataSpaceTaxonomyNodes,
+  getResolvedDataSpace,
+} from './models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin';
+
+export { DataSpaceViewerState } from './stores/DataSpaceViewerState';

package/src/models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin.ts

@@ -23,6 +23,7 @@ import {
 } from './v1/model/packageableElements/dataSpace/V1_DataSpace';
 import type { PlainObject } from '@finos/legend-shared';
 import {
+  uuid,
   guaranteeNonEmptyString,
   guaranteeNonNullable,
   UnsupportedOperationError,
@@ -42,7 +43,6 @@ import {
   DataSpaceSupportEmail,
 } from '../../metamodels/pure/model/packageableElements/dataSpace/DataSpace';
 import type {
-  GraphPluginManager,
   Mapping,
   PackageableElement,
   PackageableElementReference,
@@ -56,8 +56,10 @@ import type {
   V1_GraphTransformerContext,
   V1_PackageableElement,
   V1_PureModelContextData,
+  V1_TaggedValue,
 } from '@finos/legend-graph';
 import {
+  V1_taggedValueSchema,
   PackageableElementExplicitReference,
   V1_PackageableElementPointer,
   V1_PackageableElementPointerType,
@@ -67,6 +69,7 @@ import {
   PureProtocolProcessorPlugin,
   V1_ElementBuilder,
   V1_initPackageableElement,
+  V1_StereotypePtr,
 } from '@finos/legend-graph';
 import {
   Diagram,
@@ -84,10 +87,6 @@ export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProces
     );
   }
 
-  install(pluginManager: GraphPluginManager): void {
-    pluginManager.registerPureProtocolProcessorPlugin(this);
-  }
-
   override V1_getExtraElementBuilders(): V1_ElementBuilder<V1_PackageableElement>[] {
     return [
       new V1_ElementBuilder<V1_DataSpace>({
@@ -317,6 +316,13 @@ export class ResolvedDataSpaceExecutionContext {
  * element pointers to actual reference, hence this model.
  */
 export class ResolvedDataSpace {
+  taggedValues: {
+    uuid: string;
+    profile: string;
+    tag: string;
+    value: string;
+  }[] = [];
+  stereotypes: { uuid: string; profile: string; stereotype: string }[] = [];
   path!: string;
   groupId!: string;
   artifactId!: string;
@@ -336,6 +342,33 @@ export const getResolvedDataSpace = (
   if (json._type === V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE) {
     const protocol = deserialize(V1_dataSpaceModelSchema, json);
     dataSpace.path = protocol.path;
+    if (Array.isArray(json.taggedValues)) {
+      dataSpace.taggedValues = (
+        json.taggedValues as PlainObject<V1_TaggedValue>[]
+      )
+        .map((taggedValueJson) =>
+          deserialize(V1_taggedValueSchema, taggedValueJson),
+        )
+        .map((taggedValue) => ({
+          uuid: uuid(),
+          profile: taggedValue.tag.profile,
+          tag: taggedValue.tag.value,
+          value: taggedValue.value,
+        }));
+    }
+    if (Array.isArray(json.stereotypes)) {
+      dataSpace.stereotypes = (
+        json.stereotypes as PlainObject<V1_StereotypePtr>[]
+      )
+        .map((stereotypePtrJson) =>
+          deserialize(V1_StereotypePtr, stereotypePtrJson),
+        )
+        .map((stereotypePtr) => ({
+          uuid: uuid(),
+          profile: stereotypePtr.profile,
+          stereotype: stereotypePtr.value,
+        }));
+    }
     dataSpace.groupId = guaranteeNonEmptyString(
       protocol.groupId,
       `Data space 'groupId' field is missing or empty`,
@@ -403,3 +436,36 @@ export const getResolvedDataSpace = (
   }
   throw new UnsupportedOperationError(`Can't resolve data space`, json);
 };
+
+export const extractDataSpaceTaxonomyNodes = (
+  json: PlainObject<V1_DataSpace>,
+): string[] => {
+  const ENTERPRISE_PROFILE_PATH = `meta::pure::profiles::enterprise`;
+  const TAXONOMY_NODES_TAG = `taxonomyNodes`;
+  const TAXONOMY_NODES_TAG_VALUE_DELIMITER = `,`;
+
+  const taxonomyNodes = new Set<string>();
+  if (json._type === V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE) {
+    if (Array.isArray(json.taggedValues)) {
+      const taggedValues = (
+        json.taggedValues as PlainObject<V1_TaggedValue>[]
+      ).map((taggedValueJson) =>
+        deserialize(V1_taggedValueSchema, taggedValueJson),
+      );
+      taggedValues
+        .filter(
+          (taggedValue) =>
+            taggedValue.tag.profile === ENTERPRISE_PROFILE_PATH &&
+            taggedValue.tag.value === TAXONOMY_NODES_TAG,
+        )
+        .forEach((taggedValue) => {
+          taggedValue.value
+            .split(TAXONOMY_NODES_TAG_VALUE_DELIMITER)
+            .map((value) => value.trim())
+            .filter((value) => Boolean(value))
+            .forEach((value) => taxonomyNodes.add(value));
+        });
+    }
+  }
+  return Array.from(taxonomyNodes.values());
+};

package/src/stores/DataSpaceViewerState.ts

@@ -0,0 +1,202 @@
+/**
+ * Copyright (c) 2020-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 type {
+  ClassView,
+  DiagramRenderer,
+} from '@finos/legend-extension-dsl-diagram';
+import {
+  Diagram,
+  DIAGRAM_INTERACTION_MODE,
+} from '@finos/legend-extension-dsl-diagram';
+import type {
+  GraphManagerState,
+  PackageableElementReference,
+  PackageableRuntime,
+} from '@finos/legend-graph';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import { action, computed, makeObservable, observable } from 'mobx';
+import type {
+  ResolvedDataSpace,
+  ResolvedDataSpaceExecutionContext,
+} from '../models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin';
+
+export enum DATA_SPACE_VIEWER_ACTIVITY_MODE {
+  MODELS_OVERVIEW = 'MODELS_OVERVIEW',
+  EXECUTION = 'EXECUTION',
+  ENTITLEMENT = 'ENTITLEMENT',
+  TEST_DATA = 'TEST_DATA',
+  TEST_COVERAGE = 'TEST_COVERAGE',
+  TAGS = 'TAGS',
+  SUPPORT = 'SUPPORT',
+}
+
+export class DataSpaceViewerState {
+  graphManagerState: GraphManagerState;
+  dataSpaceGroupId: string;
+  dataSpaceArtifactId: string;
+  dataSpaceVersionId: string;
+  dataSpace: ResolvedDataSpace;
+  _renderer?: DiagramRenderer | undefined;
+  currentDiagram?: Diagram | undefined;
+  currentActivity = DATA_SPACE_VIEWER_ACTIVITY_MODE.MODELS_OVERVIEW;
+  currentExecutionContext: ResolvedDataSpaceExecutionContext;
+  currentRuntime: PackageableRuntime;
+  viewProject?:
+    | ((
+        groupId: string,
+        artifactId: string,
+        versionId: string,
+        entityPath: string | undefined,
+      ) => void)
+    | undefined;
+  onDiagramClassDoubleClick?: ((classView: ClassView) => void) | undefined;
+
+  constructor(
+    graphManagerState: GraphManagerState,
+    dataSpaceGroupId: string,
+    dataSpaceArtifactId: string,
+    dataSpaceVersionId: string,
+    dataSpace: ResolvedDataSpace,
+    options?: {
+      viewProject?: (
+        groupId: string,
+        artifactId: string,
+        versionId: string,
+        entityPath: string | undefined,
+      ) => void;
+      onDiagramClassDoubleClick?: (classView: ClassView) => void;
+    },
+  ) {
+    makeObservable(this, {
+      _renderer: observable,
+      currentDiagram: observable,
+      currentActivity: observable,
+      currentExecutionContext: observable,
+      currentRuntime: observable,
+      renderer: computed,
+      setRenderer: action,
+      setCurrentDiagram: action,
+      setCurrentActivity: action,
+      setCurrentExecutionContext: action,
+      setCurrentRuntime: action,
+    });
+
+    this.graphManagerState = graphManagerState;
+    this.dataSpace = dataSpace;
+    this.dataSpaceGroupId = dataSpaceGroupId;
+    this.dataSpaceArtifactId = dataSpaceArtifactId;
+    this.dataSpaceVersionId = dataSpaceVersionId;
+    this.currentExecutionContext = this.dataSpace.defaultExecutionContext;
+    this.currentRuntime =
+      this.dataSpace.defaultExecutionContext.defaultRuntime.value;
+    this.currentDiagram = this.dataSpace.featuredDiagrams.length
+      ? (
+          this.dataSpace
+            .featuredDiagrams[0] as PackageableElementReference<Diagram>
+        ).value
+      : this.diagrams.length
+      ? this.diagrams[0]
+      : undefined;
+    this.viewProject = options?.viewProject;
+    this.onDiagramClassDoubleClick = options?.onDiagramClassDoubleClick;
+  }
+
+  get renderer(): DiagramRenderer {
+    return guaranteeNonNullable(
+      this._renderer,
+      `Diagram renderer must be initialized (this is likely caused by calling this method at the wrong place)`,
+    );
+  }
+
+  get isDiagramRendererInitialized(): boolean {
+    return Boolean(this._renderer);
+  }
+
+  get featuredDiagrams(): Diagram[] {
+    return this.dataSpace.featuredDiagrams.map((ref) => ref.value);
+  }
+
+  get diagrams(): Diagram[] {
+    return this.graphManagerState.graph
+      .getExtensionElements(Diagram)
+      .concat(
+        this.graphManagerState.graph.dependencyManager.getExtensionElements(
+          Diagram,
+        ),
+      );
+  }
+
+  get runtimes(): PackageableRuntime[] {
+    return this.graphManagerState.graph.ownRuntimes
+      .concat(this.graphManagerState.graph.dependencyManager.runtimes)
+      .filter((runtime) =>
+        runtime.runtimeValue.mappings
+          .map((mapping) => mapping.value)
+          .includes(this.currentExecutionContext.mapping.value),
+      );
+  }
+
+  // NOTE: we have tried to use React to control the cursor and
+  // could not overcome the jank/lag problem, so we settle with CSS-based approach
+  // See https://css-tricks.com/using-css-cursors/
+  // See https://developer.mozilla.org/en-US/docs/Web/CSS/cursor
+  get diagramCursorClass(): string {
+    if (!this.isDiagramRendererInitialized) {
+      return '';
+    }
+    if (this.renderer.middleClick || this.renderer.rightClick) {
+      return 'diagram-editor__cursor--grabbing';
+    }
+    switch (this.renderer.interactionMode) {
+      case DIAGRAM_INTERACTION_MODE.LAYOUT: {
+        if (this.renderer.mouseOverClassView) {
+          return 'diagram-editor__cursor--pointer';
+        }
+        return '';
+      }
+      default:
+        return '';
+    }
+  }
+
+  setRenderer(val: DiagramRenderer): void {
+    this._renderer = val;
+  }
+
+  setCurrentDiagram(val: Diagram): void {
+    this.currentDiagram = val;
+  }
+
+  setCurrentActivity(val: DATA_SPACE_VIEWER_ACTIVITY_MODE): void {
+    this.currentActivity = val;
+  }
+
+  setCurrentExecutionContext(val: ResolvedDataSpaceExecutionContext): void {
+    this.currentExecutionContext = val;
+    this.currentRuntime = val.defaultRuntime.value;
+  }
+
+  setCurrentRuntime(val: PackageableRuntime): void {
+    this.currentRuntime = val;
+  }
+
+  setupRenderer(): void {
+    this.renderer.setIsReadOnly(true);
+    this.renderer.onClassViewDoubleClick = (classView: ClassView): void =>
+      this.onDiagramClassDoubleClick?.(classView);
+  }
+}