@finos/legend-extension-dsl-data-space 4.0.3 → 5.0.0

package/src/graphManager/protocol/v1/engine/analytics/V1_DataSpaceAnalysis.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 { V1_PureModelContextData } from '@finos/legend-graph';
+import { SerializationFactory, optionalCustom } from '@finos/legend-shared';
+import {
+  createModelSchema,
+  list,
+  object,
+  optional,
+  primitive,
+  SKIP,
+} from 'serializr';
+import type { V1_DataSpaceSupportInfo } from '../../../../../models/protocols/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.js';
+import { V1_deserializeSupportInfo } from '../../../../../models/protocols/pure/v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper.js';
+
+class V1_DataSpaceTaggedValueInfo {
+  profile!: string;
+  tag!: string;
+  value!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceTaggedValueInfo, {
+      profile: primitive(),
+      tag: primitive(),
+      value: primitive(),
+    }),
+  );
+}
+
+class V1_DataSpaceStereotypeInfo {
+  profile!: string;
+  value!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceStereotypeInfo, {
+      profile: primitive(),
+      value: primitive(),
+    }),
+  );
+}
+
+class V1_DataSpaceExecutionContextAnalysisResult {
+  name!: string;
+  description?: string | undefined;
+  mapping!: string;
+  defaultRuntime!: string;
+  compatibleRuntimes!: string[];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceExecutionContextAnalysisResult, {
+      name: primitive(),
+      description: optional(primitive()),
+      mapping: primitive(),
+      defaultRuntime: primitive(),
+      compatibleRuntimes: list(primitive()),
+    }),
+  );
+}
+
+export class V1_DataSpaceAnalysisResult {
+  name!: string;
+  package!: string;
+  path!: string;
+
+  taggedValues: V1_DataSpaceTaggedValueInfo[] = [];
+  stereotypes: V1_DataSpaceStereotypeInfo[] = [];
+
+  description?: string | undefined;
+  supportInfo?: V1_DataSpaceSupportInfo | undefined;
+
+  model!: V1_PureModelContextData;
+
+  executionContexts: V1_DataSpaceExecutionContextAnalysisResult[] = [];
+  defaultExecutionContext!: string;
+
+  featuredDiagrams: string[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceAnalysisResult, {
+      name: primitive(),
+      package: primitive(),
+      path: primitive(),
+
+      taggedValues: list(object(V1_DataSpaceTaggedValueInfo)),
+      stereotypes: list(object(V1_DataSpaceStereotypeInfo)),
+
+      description: optional(primitive()),
+      supportInfo: optionalCustom(
+        () => SKIP,
+        (val) => V1_deserializeSupportInfo(val),
+      ),
+
+      model: object(V1_PureModelContextData),
+
+      executionContexts: list(
+        object(V1_DataSpaceExecutionContextAnalysisResult),
+      ),
+      defaultExecutionContext: primitive(),
+
+      featuredDiagrams: list(primitive()),
+    }),
+  );
+}

package/src/index.ts

@@ -15,8 +15,8 @@
  */
 
 export * from './DSLDataSpace_Extension.js';
-export { DSLDataSpace_LegendStudioPlugin } from './components/studio/DSLDataSpace_LegendStudioPlugin.js';
-export { DSLDataSpace_LegendQueryPlugin } from './components/query/DSLDataSpace_LegendQueryPlugin.js';
+export { DSLDataSpace_LegendStudioApplicationPlugin } from './components/studio/DSLDataSpace_LegendStudioApplicationPlugin.js';
+export { DSLDataSpace_LegendQueryApplicationPlugin } from './components/query/DSLDataSpace_LegendQueryApplicationPlugin.js';
 
 export { DataSpaceViewer } from './components/DataSpaceViewer.js';
 
@@ -28,3 +28,5 @@ export {
 export { DataSpaceViewerState } from './stores/DataSpaceViewerState.js';
 
 export * from './graphManager/DSLDataSpace_GraphManagerHelper.js';
+export { getDSLDataSpaceGraphManagerExtension } from './graphManager/protocol/DSLDataSpace_PureGraphManagerExtension.js';
+export { DataSpaceAnalysisResult } from './graphManager/action/analytics/DataSpaceAnalysis.js';

package/src/models/protocols/pure/v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper.ts

@@ -78,7 +78,7 @@ const V1_serializeSupportInfo = (
   throw new UnsupportedOperationError(`Can't serialize support info`, protocol);
 };
 
-const V1_deserializeSupportInfo = (
+export const V1_deserializeSupportInfo = (
   json: PlainObject<V1_DataSpaceSupportInfo> | undefined,
 ): V1_DataSpaceSupportInfo | undefined => {
   if (!json) {

package/src/stores/DataSpaceViewerState.ts

@@ -17,20 +17,19 @@
 import {
   type ClassView,
   type DiagramRenderer,
-  Diagram,
+  type 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 type { PackageableRuntime } from '@finos/legend-graph';
+import {
+  getNullableFirstElement,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
 import { action, computed, makeObservable, observable } from 'mobx';
 import type {
-  DataSpace,
-  DataSpaceExecutionContext,
-} from '../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+  DataSpaceAnalysisResult,
+  DataSpaceExecutionContextAnalysisResult,
+} from '../graphManager/action/analytics/DataSpaceAnalysis.js';
 
 export enum DATA_SPACE_VIEWER_ACTIVITY_MODE {
   MODELS_OVERVIEW = 'MODELS_OVERVIEW',
@@ -43,15 +42,14 @@ export enum DATA_SPACE_VIEWER_ACTIVITY_MODE {
 }
 
 export class DataSpaceViewerState {
-  graphManagerState: GraphManagerState;
   groupId: string;
   artifactId: string;
   versionId: string;
-  dataSpace: DataSpace;
+  dataSpaceAnalysisResult: DataSpaceAnalysisResult;
   _renderer?: DiagramRenderer | undefined;
   currentDiagram?: Diagram | undefined;
   currentActivity = DATA_SPACE_VIEWER_ACTIVITY_MODE.MODELS_OVERVIEW;
-  currentExecutionContext: DataSpaceExecutionContext;
+  currentExecutionContext: DataSpaceExecutionContextAnalysisResult;
   currentRuntime: PackageableRuntime;
   viewProject?:
     | ((
@@ -64,11 +62,10 @@ export class DataSpaceViewerState {
   onDiagramClassDoubleClick?: ((classView: ClassView) => void) | undefined;
 
   constructor(
-    graphManagerState: GraphManagerState,
     groupId: string,
     artifactId: string,
     versionId: string,
-    dataSpace: DataSpace,
+    dataSpaceAnalysisResult: DataSpaceAnalysisResult,
     options?: {
       viewProject?: (
         groupId: string,
@@ -93,22 +90,16 @@ export class DataSpaceViewerState {
       setCurrentRuntime: action,
     });
 
-    this.graphManagerState = graphManagerState;
-    this.dataSpace = dataSpace;
+    this.dataSpaceAnalysisResult = dataSpaceAnalysisResult;
     this.groupId = groupId;
     this.artifactId = artifactId;
     this.versionId = versionId;
-    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.currentExecutionContext =
+      dataSpaceAnalysisResult.defaultExecutionContext;
+    this.currentRuntime = this.currentExecutionContext.defaultRuntime;
+    this.currentDiagram = getNullableFirstElement(
+      this.dataSpaceAnalysisResult.featuredDiagrams,
+    );
     this.viewProject = options?.viewProject;
     this.onDiagramClassDoubleClick = options?.onDiagramClassDoubleClick;
   }
@@ -124,30 +115,6 @@ export class DataSpaceViewerState {
     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/
@@ -183,9 +150,11 @@ export class DataSpaceViewerState {
     this.currentActivity = val;
   }
 
-  setCurrentExecutionContext(val: DataSpaceExecutionContext): void {
+  setCurrentExecutionContext(
+    val: DataSpaceExecutionContextAnalysisResult,
+  ): void {
     this.currentExecutionContext = val;
-    this.currentRuntime = val.defaultRuntime.value;
+    this.currentRuntime = val.defaultRuntime;
   }
 
   setCurrentRuntime(val: PackageableRuntime): void {

package/src/stores/query/DSLDataSpace_LegendQueryRouter.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 { generateExtensionUrlPattern } from '@finos/legend-application';
+import {
+  LEGEND_QUERY_PATH_PARAM_TOKEN,
+  LEGEND_QUERY_QUERY_PARAM_TOKEN,
+} from '@finos/legend-query';
+import { generateGAVCoordinates } from '@finos/legend-server-depot';
+import { generatePath } from 'react-router';
+
+export enum DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN {
+  DATA_SPACE_PATH = 'dataSpacePath',
+  EXECUTION_CONTEXT = 'executionContext',
+}
+
+export interface DataSpaceQueryEditorPathParams {
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: string;
+  [DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.DATA_SPACE_PATH]: string;
+  [DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.EXECUTION_CONTEXT]: string;
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH]?: string;
+}
+
+export interface DataSpaceQueryEditorQueryParams {
+  [LEGEND_QUERY_QUERY_PARAM_TOKEN.CLASS_PATH]?: string;
+}
+
+export const DATA_SPACE_QUERY_EDITOR_ROUTE_PATTERN = `/dataspace/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.DATA_SPACE_PATH}/:${DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.EXECUTION_CONTEXT}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH}?`;
+
+export const generateDataSpaceQueryEditorRoute = (
+  groupId: string,
+  artifactId: string,
+  versionId: string,
+  dataSpacePath: string,
+  executionContextKey: string,
+  runtimePath?: string | undefined,
+  classPath?: string | undefined,
+): string =>
+  `${generatePath(
+    generateExtensionUrlPattern(DATA_SPACE_QUERY_EDITOR_ROUTE_PATTERN),
+    {
+      [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
+        groupId,
+        artifactId,
+        versionId,
+      ),
+      [DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.DATA_SPACE_PATH]: dataSpacePath,
+      [DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.EXECUTION_CONTEXT]:
+        executionContextKey,
+      [LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH]: runtimePath,
+    },
+  )}${
+    classPath
+      ? `?${LEGEND_QUERY_QUERY_PARAM_TOKEN.CLASS_PATH}=${classPath}`
+      : ''
+  }`;

package/src/stores/query/DataSpaceQueryEditorStore.ts

@@ -0,0 +1,141 @@
+/**
+ * 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 Query,
+  extractElementNameFromPath,
+  QueryTaggedValue,
+} from '@finos/legend-graph';
+import {
+  QueryEditorStore,
+  type QueryExportConfiguration,
+  type LegendQueryPluginManager,
+  type LegendQueryApplicationStore,
+} from '@finos/legend-query';
+import type {
+  DepotServerClient,
+  ProjectGAVCoordinates,
+} from '@finos/legend-server-depot';
+import { guaranteeNonNullable, uuid } from '@finos/legend-shared';
+import {
+  QUERY_PROFILE_PATH,
+  QUERY_PROFILE_TAG_DATA_SPACE,
+} from '../../DSLDataSpace_Const.js';
+import { getDataSpace } from '../../graphManager/DSLDataSpace_GraphManagerHelper.js';
+
+const createQueryDataSpaceTaggedValue = (
+  dataSpacePath: string,
+): QueryTaggedValue => {
+  const taggedValue = new QueryTaggedValue();
+  taggedValue.profile = QUERY_PROFILE_PATH;
+  taggedValue.tag = QUERY_PROFILE_TAG_DATA_SPACE;
+  taggedValue.value = dataSpacePath;
+  return taggedValue;
+};
+
+export class DataSpaceQueryEditorStore extends QueryEditorStore {
+  groupId: string;
+  artifactId: string;
+  versionId: string;
+  dataSpacePath: string;
+  executionContext: string;
+  runtimePath: string | undefined;
+  classPath: string | undefined;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+    pluginManager: LegendQueryPluginManager,
+    groupId: string,
+    artifactId: string,
+    versionId: string,
+    dataSpacePath: string,
+    executionContext: string,
+    runtimePath: string | undefined,
+    executionKey: string | undefined,
+  ) {
+    super(applicationStore, depotServerClient, pluginManager);
+
+    this.groupId = groupId;
+    this.artifactId = artifactId;
+    this.versionId = versionId;
+    this.dataSpacePath = dataSpacePath;
+    this.executionContext = executionContext;
+    this.runtimePath = runtimePath;
+    this.classPath = executionKey;
+  }
+
+  getProjectInfo(): ProjectGAVCoordinates {
+    return {
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+    };
+  }
+
+  async setUpBuilderState(): Promise<void> {
+    this.queryBuilderState.querySetupState.setMappingIsReadOnly(true);
+    this.queryBuilderState.querySetupState.setRuntimeIsReadOnly(true);
+
+    const dataSpace = getDataSpace(
+      this.dataSpacePath,
+      this.graphManagerState.graph,
+    );
+    const executionContext = guaranteeNonNullable(
+      dataSpace.executionContexts.find(
+        (context) => context.name === this.executionContext,
+      ),
+      `Can't find execution context '${this.executionContext}'`,
+    );
+    this.queryBuilderState.querySetupState.setMapping(
+      executionContext.mapping.value,
+    );
+    this.queryBuilderState.querySetupState.setRuntimeValue(
+      (this.runtimePath
+        ? this.graphManagerState.graph.getRuntime(this.runtimePath)
+        : executionContext.defaultRuntime.value
+      ).runtimeValue,
+    );
+
+    if (this.classPath) {
+      this.queryBuilderState.querySetupState._class =
+        this.queryBuilderState.graphManagerState.graph.getClass(this.classPath);
+      this.queryBuilderState.querySetupState.setClassIsReadOnly(true);
+    }
+    // TODO?: should we set the class here automatically?
+
+    // initialize query builder state after setting up
+    this.queryBuilderState.resetQueryBuilder();
+    this.queryBuilderState.resetQuerySetup();
+  }
+
+  async getExportConfiguration(): Promise<QueryExportConfiguration> {
+    return {
+      defaultName: `New Query for ${extractElementNameFromPath(
+        this.dataSpacePath,
+      )}[${this.executionContext}]`,
+      decorator: (query: Query): void => {
+        query.id = uuid();
+        query.groupId = this.groupId;
+        query.artifactId = this.artifactId;
+        query.versionId = this.versionId;
+        query.taggedValues = [
+          createQueryDataSpaceTaggedValue(this.dataSpacePath),
+        ];
+      },
+    };
+  }
+}