@finos/legend-extension-dsl-data-space 4.0.5 → 6.1.0

package/src/graphManager/protocol/pure/v1/V1_DSLDataSpace_PureGraphManagerExtension.ts

@@ -0,0 +1,265 @@
+/**
+ * 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 { getDiagram } from '@finos/legend-extension-dsl-diagram';
+import {
+  PureModel,
+  V1_PureGraphManager,
+  PureClientVersion,
+  type AbstractPureGraphManager,
+  CoreModel,
+  SystemModel,
+  V1_Mapping,
+  resolvePackagePathAndElementName,
+  V1_PureModelContextType,
+  V1_PackageableRuntime,
+  V1_EngineRuntime,
+  V1_Class,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+import {
+  ActionState,
+  guaranteeNonEmptyString,
+  guaranteeNonNullable,
+  guaranteeType,
+  isNonNullable,
+  uniq,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { DataSpaceSupportEmail } from '../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import { V1_DataSpaceSupportEmail } from '../../../../graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.js';
+import {
+  DataSpaceAnalysisResult,
+  DataSpaceExecutionContextAnalysisResult,
+  DataSpaceStereotypeInfo,
+  DataSpaceTaggedValueInfo,
+} from '../../../action/analytics/DataSpaceAnalysis.js';
+import { DSLDataSpace_PureGraphManagerExtension } from '../DSLDataSpace_PureGraphManagerExtension.js';
+import { V1_DataSpaceAnalysisResult } from './engine/analytics/V1_DataSpaceAnalysis.js';
+
+const ANALYZE_DATA_SPACE_TRACE = 'analyze data space';
+
+export class V1_DSLDataSpace_PureGraphManagerExtension extends DSLDataSpace_PureGraphManagerExtension {
+  declare graphManager: V1_PureGraphManager;
+
+  constructor(graphManager: AbstractPureGraphManager) {
+    super(graphManager);
+    this.graphManager = guaranteeType(graphManager, V1_PureGraphManager);
+  }
+
+  getSupportedProtocolVersion(): string {
+    return PureClientVersion.V1_0_0;
+  }
+
+  async analyzeDataSpace(
+    dataSpacePath: string,
+    entities: Entity[],
+    dependencyEntitiesIndex: Map<string, Entity[]>,
+  ): Promise<DataSpaceAnalysisResult> {
+    // prepare graph data for analysis
+    // NOTE: we don't do serialization roundtrip here to save time
+    const graphDataForAnalysis = {
+      _type: V1_PureModelContextType.DATA,
+      elements: Array.from(dependencyEntitiesIndex.values())
+        .flat()
+        .concat(entities)
+        .map((entity) => entity.content),
+    };
+
+    const engineServerClient = this.graphManager.engine.getEngineServerClient();
+    const analysisResult = V1_DataSpaceAnalysisResult.serialization.fromJson(
+      await engineServerClient.postWithTracing<
+        PlainObject<V1_DataSpaceAnalysisResult>
+      >(
+        engineServerClient.getTraceData(ANALYZE_DATA_SPACE_TRACE),
+        `${engineServerClient._pure()}/analytics/dataSpace/render`,
+        {
+          clientVersion: V1_PureGraphManager.TARGET_PROTOCOL_VERSION,
+          dataSpace: dataSpacePath,
+          model: graphDataForAnalysis,
+        },
+        {},
+        undefined,
+        undefined,
+        { enableCompression: true },
+      ),
+    );
+
+    const result = new DataSpaceAnalysisResult();
+    result.name = analysisResult.name;
+    result.package = analysisResult.package;
+    result.path = analysisResult.path;
+    result.title = analysisResult.title;
+    result.description = analysisResult.description;
+
+    result.taggedValues = analysisResult.taggedValues.map((taggedValue) => {
+      const info = new DataSpaceTaggedValueInfo();
+      info.profile = taggedValue.profile;
+      info.tag = taggedValue.value;
+      info.value = taggedValue.value;
+      return info;
+    });
+    result.stereotypes = analysisResult.stereotypes.map((stereotype) => {
+      const info = new DataSpaceStereotypeInfo();
+      info.profile = stereotype.profile;
+      info.value = stereotype.value;
+      return info;
+    });
+
+    if (analysisResult.supportInfo) {
+      if (analysisResult.supportInfo instanceof V1_DataSpaceSupportEmail) {
+        const supportEmail = new DataSpaceSupportEmail();
+        supportEmail.address = guaranteeNonEmptyString(
+          analysisResult.supportInfo.address,
+          `Data space support email 'address' field is missing or empty`,
+        );
+        result.supportInfo = supportEmail;
+      }
+      // NOTE: we will relax the check and not throw here for unknown support info type
+    }
+
+    // create an empty graph
+    const extensionElementClasses = this.graphManager.pluginManager
+      .getPureGraphPlugins()
+      .flatMap((plugin) => plugin.getExtraPureGraphExtensionClasses?.() ?? []);
+    const systemModel = new SystemModel(extensionElementClasses);
+    const coreModel = new CoreModel(extensionElementClasses);
+    await this.graphManager.buildSystem(
+      coreModel,
+      systemModel,
+      ActionState.create(),
+      {},
+    );
+    systemModel.initializeAutoImports();
+    const graph = new PureModel(
+      coreModel,
+      systemModel,
+      this.graphManager.pluginManager.getPureGraphPlugins(),
+    );
+
+    // Create dummy mappings and runtimes
+    // TODO?: these stubbed mappings and runtimes are not really useful that useful, so either we should
+    // simplify the model here or potentially refactor the backend analytics endpoint to return these as model
+    const mappingModels = uniq(
+      analysisResult.executionContexts.map((context) => context.mapping),
+    ).map((path) => {
+      const mapping = new V1_Mapping();
+      const [packagePath, name] = resolvePackagePathAndElementName(path);
+      mapping.package = packagePath;
+      mapping.name = name;
+      return mapping;
+    });
+    const runtimeModels = uniq(
+      analysisResult.executionContexts
+        .map((context) => context.defaultRuntime)
+        .concat(
+          analysisResult.executionContexts.flatMap(
+            (val) => val.compatibleRuntimes,
+          ),
+        ),
+    ).map((path) => {
+      const runtime = new V1_PackageableRuntime();
+      const [packagePath, name] = resolvePackagePathAndElementName(path);
+      runtime.package = packagePath;
+      runtime.name = name;
+      runtime.runtimeValue = new V1_EngineRuntime();
+      return runtime;
+    });
+
+    // prepare the model context data
+    const graphEntities = analysisResult.model.elements
+      // NOTE: this is a temporary hack to fix a problem with data space analytics
+      // where the classes for properties are not properly surveyed
+      // We need to wait for the actual fix in backend to be merged and released
+      // See https://github.com/finos/legend-engine/pull/836
+      .concat(
+        uniq(
+          analysisResult.model.elements.flatMap((element) => {
+            if (element instanceof V1_Class) {
+              return element.derivedProperties
+                .map((prop) => prop.returnType)
+                .concat(element.properties.map((prop) => prop.type));
+            }
+            return [];
+          }),
+        )
+          // make sure to not include types already returned by the analysis
+          .filter(
+            (path) =>
+              !analysisResult.model.elements
+                .map((el) => el.path)
+                .includes(path),
+          )
+          .map((path) => {
+            const [pkgPath, name] = resolvePackagePathAndElementName(path);
+            if (!pkgPath) {
+              // exclude package-less elements (i.e. primitive types)
+              return undefined;
+            }
+            const _class = new V1_Class();
+            _class.name = name;
+            _class.package = pkgPath;
+            return _class;
+          })
+          .filter(isNonNullable),
+      )
+      .concat(mappingModels)
+      .concat(runtimeModels)
+      // NOTE: if an element could be found in the graph already it means it comes from system
+      // so we could rid of it
+      .filter((el) => !graph.getNullableElement(el.path, false))
+      .map((el) => this.graphManager.elementProtocolToEntity(el));
+
+    await this.graphManager.buildGraph(
+      graph,
+      graphEntities,
+      ActionState.create(),
+    );
+
+    // build execution context info
+    result.executionContextsIndex = new Map<
+      string,
+      DataSpaceExecutionContextAnalysisResult
+    >();
+    analysisResult.executionContexts.forEach((context) => {
+      const contextAnalysisResult =
+        new DataSpaceExecutionContextAnalysisResult();
+      contextAnalysisResult.name = context.name;
+      contextAnalysisResult.description = context.description;
+      contextAnalysisResult.mapping = graph.getMapping(context.mapping);
+      contextAnalysisResult.defaultRuntime = graph.getRuntime(
+        context.defaultRuntime,
+      );
+      contextAnalysisResult.compatibleRuntimes = context.compatibleRuntimes.map(
+        (runtime) => graph.getRuntime(runtime),
+      );
+      result.executionContextsIndex.set(
+        contextAnalysisResult.name,
+        contextAnalysisResult,
+      );
+    });
+    result.defaultExecutionContext = guaranteeNonNullable(
+      result.executionContextsIndex.get(analysisResult.defaultExecutionContext),
+    );
+
+    // find featured diagrams
+    result.featuredDiagrams = analysisResult.featuredDiagrams.map((path) =>
+      getDiagram(path, graph),
+    );
+
+    return result;
+  }
+}

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

@@ -0,0 +1,119 @@
+/**
+ * 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 '../../../../../../graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.js';
+import { V1_deserializeSupportInfo } from '../../../../../../graphManager/protocol/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[] = [];
+
+  title?: string | undefined;
+  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)),
+
+      title: optional(primitive()),
+      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/{models/protocols → graphManager/protocol}/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.ts

@@ -15,7 +15,7 @@
  */
 
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../../DSLDataSpace_ModelUtils.js';
+import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../../../graph/DSLDataSpace_HashUtils.js';
 import {
   V1_PackageableElement,
   type V1_PackageableElementPointer,
@@ -65,6 +65,7 @@ export class V1_DataSpace extends V1_PackageableElement implements Hashable {
   executionContexts!: V1_DataSpaceExecutionContext[];
   defaultExecutionContext!: string;
   featuredDiagrams?: V1_PackageableElementPointer[] | undefined;
+  title?: string | undefined;
   description?: string | undefined;
   supportInfo?: V1_DataSpaceSupportInfo | undefined;
 
@@ -76,6 +77,7 @@ export class V1_DataSpace extends V1_PackageableElement implements Hashable {
       hashArray(this.executionContexts),
       this.defaultExecutionContext,
       hashArray((this.featuredDiagrams ?? []).map((pointer) => pointer.path)),
+      this.title ?? '',
       this.description ?? '',
       this.supportInfo ?? '',
     ]);

package/src/{models/protocols → graphManager/protocol}/pure/v1/transformation/pureGraph/V1_DSLDataSpace_GraphBuilderHelper.ts

@@ -15,7 +15,7 @@
  */
 
 import { getDataSpace } from '../../../../../../graphManager/DSLDataSpace_GraphManagerHelper.js';
-import type { DataSpace } from '../../../../../metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import type { DataSpace } from '../../../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 import type {
   PackageableElementImplicitReference,
   V1_GraphBuilderContext,

package/src/{models/protocols → graphManager/protocol}/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) {
@@ -157,4 +157,5 @@ export const V1_dataSpaceModelSchema = createModelSchema(V1_DataSpace, {
         skipIfEmpty: false,
       }),
   ),
+  title: optional(primitive()),
 });

package/src/index.ts

@@ -15,16 +15,18 @@
  */
 
 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';
 
 export {
   DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
   extractDataSpaceTaxonomyNodes,
-} from './models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin.js';
+} from './graphManager/protocol/pure/DSLDataSpace_PureProtocolProcessorPlugin.js';
 
 export { DataSpaceViewerState } from './stores/DataSpaceViewerState.js';
 
 export * from './graphManager/DSLDataSpace_GraphManagerHelper.js';
+export { getDSLDataSpaceGraphManagerExtension } from './graphManager/protocol/pure/DSLDataSpace_PureGraphManagerExtension.js';
+export { DataSpaceAnalysisResult } from './graphManager/action/analytics/DataSpaceAnalysis.js';

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',
@@ -38,20 +37,19 @@ export enum DATA_SPACE_VIEWER_ACTIVITY_MODE {
   ENTITLEMENT = 'ENTITLEMENT',
   TEST_DATA = 'TEST_DATA',
   TEST_COVERAGE = 'TEST_COVERAGE',
-  TAGS = 'TAGS',
+  INFO = 'INFO',
   SUPPORT = 'SUPPORT',
 }
 
 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-application-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}`
+      : ''
+  }`;