@finos/legend-application-studio 13.0.0

package/src/stores/LegendStudioCodeSnippets.ts

@@ -0,0 +1,350 @@
+/**
+ * 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 { TAB_SIZE } from '@finos/legend-application';
+import { indent } from '@finos/legend-shared';
+
+// ------------------------------------- Class -------------------------------------
+
+export const BLANK_CLASS_SNIPPET = `Class \${1:model::NewClass}
+// example of a constraint
+// [
+//   SomeConstraint: true
+// ]
+{
+  \${2:// example of a standard property
+  // prop1: String[1];
+
+  // example of a derived property
+  // derivation1() {''\\}: String[1];}
+}`;
+
+export const CLASS_WITH_PROPERTY_SNIPPET = `Class \${1:model::NewClass}
+{
+  \${2:prop1}: \${3:String[1]};
+}`;
+
+export const CLASS_WITH_INHERITANCE_SNIPPET = `Class \${1:model::NewClass} extends \${2:model::ParentClass}
+{
+  \${3:// class content}
+}`;
+
+export const CLASS_WITH_CONSTRAINT_SNIPPET = `Class \${1:model::NewClass}
+[
+  \${3:SomeConstraint: true}
+]
+{
+  \${2:// class content}
+}`;
+
+// ------------------------------------- Profile -------------------------------------
+
+export const SIMPLE_PROFILE_SNIPPET = `Profile \${1:model::NewProfile}
+{
+  stereotypes: [\${2:}];
+  tags: [\${3:}];
+}`;
+
+// ------------------------------------- Enumeration -------------------------------------
+
+export const SIMPLE_ENUMERATION_SNIPPET = `Enum \${1:model::NewEnumeration}
+{
+  \${2:VALUE_1,\n  VALUE_2}
+}`;
+
+// ------------------------------------- Association -------------------------------------
+
+export const SIMPLE_ASSOCIATION_SNIPPET = `Association \${1:model::NewAssociation}
+{
+  \${2:prop1}: \${3:model::Type1[1]};
+  \${4:prop2}: \${5:model::Type2[1]};
+}`;
+
+// ------------------------------------- Function -------------------------------------
+
+export const BLANK_FUNCTION_SNIPPET = `function \${1:model::NewEnumeration}(\${2:param1: String[1]}): \${3:String[1]}
+{
+  \${4:''; // function content}
+}`;
+
+export const SIMPLE_FUNCTION_SNIPPET = `function \${1:model::NewEnumeration}(): String[1]
+{
+  ''
+}`;
+
+// ------------------------------------- Measure -------------------------------------
+
+export const SIMPLE_MEASURE_SNIPPET = `Measure \${1:model::NewEnumeration}
+{
+  // canonical unit: the unit that other units will be based off for conversion
+  *\${1:Unit_1}: \${2:x -> $x};
+  // example of other units and their conversation functions
+  // Unit_2: x -> $x * 100;
+  // Unit_3: x -> $x * 1000;
+}`;
+
+// ------------------------------------- Runtime -------------------------------------
+
+export const SIMPLE_RUNTIME_SNIPPET = `Runtime \${1:model::NewRuntime}
+{
+  mappings:
+  [
+    \${2:model::SomeMapping}
+  ];
+  connections:
+  [
+    // example of a stored connection which covers the mapping
+    // ModelStore:
+    // [
+    //
+    // example of using connection pointer
+    //   id1: test::connection2,
+    //
+    // example of using embedded connection
+    //   #{
+    //     JsonModelConnection
+    //     {
+    //       class: model::SomeClass;
+    //       url: 'someUrl';
+    //     }
+    //   }#
+    // ]
+  ];
+}`;
+
+// ------------------------------------- Connection -------------------------------------
+
+export const JSON_MODEL_CONNECTION_SNIPPET = `JsonModelConnection \${1:model::NewConnection}
+{
+  class: \${2:model::SomeClass};
+  // data URL
+  url: '\${3:data:application/json,{\\}}';
+}`;
+
+export const XML_MODEL_CONNECTION_SNIPPET = `XmlModelConnection \${1:model::NewConnection}
+{
+  class: \${2:model::SomeClass};
+  // data URL
+  url: '\${3:data:application/json,{\\}}';
+}`;
+
+export const MODEL_CHAIN_CONNECTION_SNIPPET = `ModelChainConnection \${1:model::NewConnection}
+{
+  mappings: [
+    \${2:model::SomeMapping}
+  ];
+}`;
+
+export const RELATIONAL_DATABASE_CONNECTION_SNIPPET = `RelationalDatabaseConnection \${1:model::NewConnection}
+{
+  store: \${2:model::SomeStore};
+  // example of a simple H2 connection
+  type: \${3:H2};
+  specification: \${4:LocalH2 {\\}};
+  auth: \${5:DefaultH2 {\\}};
+}`;
+
+// ------------------------------------- Mapping -------------------------------------
+
+export const BLANK_MAPPING_SNIPPET = `Mapping \${1:model::NewMapping}
+(
+  \${2:// mapping content}
+)`;
+
+export const MAPPING_WITH_M2M_CLASS_MAPPING_SNIPPET = `Mapping \${1:model::NewMapping}
+(
+  \${2:model::TargetClass}: Pure
+  {
+    ~src \${3:model::SourceClass}
+    // example of property mappings
+    // prop1: $src.prop1
+  }
+)`;
+
+export const MAPPING_WITH_RELATIONAL_CLASS_MAPPING_SNIPPET = `Mapping \${1:model::NewMapping}
+(
+  \${2:model::TargetClass}: Relational {
+    ~mainTable \${3:[model::SomeDatabase]SomeTable}
+    // example of property mappings
+    // prop1: [model::SomeDatabase]SomeTable.col1,
+  }
+)`;
+
+export const MAPPING_WITH_ENUMERATION_MAPPING_SNIPPET = `Mapping \${1:model::NewMapping}
+(
+  \${2:model::TargetEnumeration}: EnumerationMapping \${3:EnumerationMappingID}
+  {
+    // example of enum-value mapping
+    // VAL_1: ['val1'],
+    // VAL_2: ['val2', 'val_2']
+  }
+)`;
+
+// ------------------------------------- Service -------------------------------------
+
+export const BLANK_SERVICE_SNIPPET = `Service \${1:new::NewService}
+{
+  pattern: '/\${2:myPattern/}';
+  owners: [\${3:'owner1', 'owner2'}]; // at least 2 owners required
+  documentation: \${4:'documentation'};
+  autoActivateUpdates: \${5:true};
+  execution: \${6:}
+  test: \${7:}
+}`;
+
+export const SERVICE_WITH_SINGLE_EXECUTION_SNIPPET = `Service \${1:new::NewService}
+{
+  pattern: '/\${2:myPattern/}';
+  owners: [\${3:'owner1', 'owner2'}]; // at least 2 owners required
+  documentation: \${4:'documentation'};
+  autoActivateUpdates: \${5:true};
+
+  // example of using a single execution context
+  execution: Single
+  {
+    query: \${6:|''};
+    mapping: \${7:model::SomeMapping};
+
+    // example of using embedded runtime
+    // runtime:
+    // #{
+    //   connections: [];
+    // }#;
+
+    // example of using runtime pointer
+    // runtime: model::SomeRuntime;
+  }
+  test: Single
+  {
+    data: 'data'; // this test data will be shared across tests
+    asserts:
+    [
+    ];
+  }
+}`;
+
+export const SERVICE_WITH_MULTI_EXECUTION_SNIPPET = `Service \${1:new::NewService}
+{
+  pattern: '/\${2:myPattern/}';
+  owners: [\${3:'owner1', 'owner2'}]; // at least 2 owners required
+  documentation: \${4:'documentation'};
+  autoActivateUpdates: \${5:true};
+
+  // example of using multiple execution contexts
+  execution: Multi
+  {
+    query: \${6:|''};
+    key: '\${7:keyName}';
+    executions['key_1']:
+    {
+      mapping: \${8:model::SomeMapping};
+
+      // example of using embedded runtime
+      // runtime:
+      // #{
+      //   connections: [];
+      // }#;
+
+      // example of using runtime pointer
+      // runtime: model::SomeRuntime;
+    }
+    // executions['key_2']:
+    // {
+    //   mapping: model::SomeMapping;
+    //   runtime: model::SomeRuntime;
+    // }
+  }
+  test: Multi
+  {
+    tests['key_1']:
+    {
+      data: 'data';
+      asserts:
+      [
+      ];
+    }
+    // tests['key_2']:
+    // {
+    //   data: 'data';
+    // }
+  }
+}`;
+
+// ------------------------------------- Generation -------------------------------------
+
+export const SIMPLE_GENERATION_SPECIFICATION_SNIPPET = `GenerationSpecification \${1:model::NewGenerationSpecification}
+{
+  // exmple of file generation nodes (which will be generated last)
+  // fileGenerations: [_meta::myAvroMisSpelled];
+
+  // example of model generation nodes (tree form) to order the generations
+  // generationNodes: [
+  //   {
+  //     generationElement: model::MissingElement;
+  //   }
+  // ];
+
+  \${2:// generation specification content}
+}`;
+
+// ------------------------------------- Relational -------------------------------------
+
+export const BLANK_RELATIONAL_DATABASE_SNIPPET = `Database \${1:model::NewDatabase}
+(
+  // example database schema
+  // Schema SOME_SCHEMA
+  // (
+  //   Table TABLE_1
+  //   (
+  //     COL_1 VARCHAR(200)
+  //   )
+  //   Table TABLE_2
+  //   (
+  //     COL_2 VARCHAR(200) PRIMARY_KEY
+  //   )
+  // )
+
+  // example database join
+  // Join SomeJoin(SOME_SCHEMA.TABLE_1.COL_1 = SCHEMA1.TABLE_2.COL_2)
+
+  \${2:// database content}
+)`;
+
+// ------------------------------------- Data -------------------------------------
+
+export const DATA_WITH_EXTERNAL_FORMAT_SNIPPET = `Data \${1:model::NewData}
+{
+  ExternalFormat
+  #{
+    contentType: '\${2:application/x.flatdata}';
+    data: '\${3:data}';
+  }#
+}`;
+
+export const DATA_WITH_MODEL_STORE_SNIPPET = `Data \${1:model::NewData}
+{
+  ModelStore
+  #{
+    \${2:model::SomeClass:}
+      [
+      ]
+  }#
+}`;
+
+export const createDataElementSnippetWithEmbeddedDataSuggestionSnippet = (
+  snippetText: string,
+): string =>
+  `Data \${1:model::NewData}\n${indent(snippetText, ' '.repeat(TAB_SIZE))}\n}`;

package/src/stores/LegendStudioDocumentation.ts

@@ -0,0 +1,84 @@
+/**
+ * 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 { ContextualDocumentationConfig } from '@finos/legend-application';
+import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from './LegendStudioApplicationNavigationContext.js';
+
+export enum LEGEND_STUDIO_DOCUMENTATION_KEY {
+  NOT_FOUND_HELP = 'application.not-found-help',
+
+  SETUP_WORKSPACE = 'setup.setup-workspace',
+  CREATE_PROJECT = 'setup.create-project',
+  IMPORT_PROJECT = 'setup.import-project',
+  CREATE_WORKSPACE = 'setup.create-workspace',
+
+  // grammar parsers
+  GRAMMAR_PARSER_PURE = 'grammar.parser.pure',
+  GRAMMAR_PARSER_MAPPING = 'dsl-mapping.grammar.parser',
+  GRAMMAR_PARSER_CONNECTION = 'dsl-connection.grammar.parser',
+  GRAMMAR_PARSER_RUNTIME = 'dsl-runtime.grammar.parser',
+  GRAMMAR_PARSER_RELATIONAL = 'es-relational.grammar.parser',
+  GRAMMAR_PARSER_SERVICE = 'dsl-service.grammar.parser',
+  GRAMMAR_PARSER_GENERATION_SPECIFICATION = 'dsl-generation-specification.grammar.parser',
+  GRAMMAR_PARSER_FILE_GENERATION = 'dsl-file-generation.grammar.parser',
+  GRAMMAR_PARSER_DATA = 'dsl-data.grammar.parser',
+  // grammar elements
+  GRAMMAR_ELEMENT_CLASS = 'grammar.class',
+  GRAMMAR_ELEMENT_PROFILE = 'grammar.profile',
+  GRAMMAR_ELEMENT_ENUMERATION = 'grammar.enumeration',
+  GRAMMAR_ELEMENT_MEASURE = 'grammar.measure',
+  GRAMMAR_ELEMENT_ASSOCIATION = 'grammar.association',
+  GRAMMAR_ELEMENT_FUNCTION = 'grammar.function',
+  GRAMMAR_ELEMENT_MAPPING = 'dsl-mapping.grammar.element.mapping',
+  GRAMMAR_ELEMENT_DATABASE = 'es-relational.grammar.element.database',
+  GRAMMAR_ELEMENT_SERVICE = 'dsl-service.grammar.element.service',
+  GRAMMAR_ELEMENT_RUNTIME = 'dsl-mapping.grammar.element.runtime',
+  GRAMMAR_ELEMENT_CONNECTION = 'dsl-mapping.grammar.element.connection',
+  GRAMMAR_ELEMENT_GENERATION_SPECIFICATION = 'dsl-generation-specification.grammar.element.generation-specification',
+  GRAMMAR_ELEMENT_FILE_GENERATION_SPECIFICATION = 'dsl-file-generation.grammar.element.file-generation-specification',
+  GRAMMAR_DATA_ELEMENT = 'dsl-data.grammar.element.data',
+  // grammar connection elements
+  GRAMMAR_CONNECTION_JSON_MODEL_CONNECTION = 'dsl-mapping.grammar.connection.json-model-connection',
+  GRAMMAR_CONNECTION_XML_MODEL_CONNECTION = 'dsl-mapping.grammar.connection.xml-model-connection',
+  GRAMMAR_CONNECTION_MODEL_CHAIN_CONNECTION = 'dsl-mapping.grammar.connection.model-chain-connection',
+  GRAMMAR_CONNECTION_RELATIONAL_DATABASE_CONNECTION = 'es-relational.grammar.connection.relational-database-connection',
+
+  // questions
+  QUESTION_WHAT_IS_DSL = 'question.what-is-dsl',
+  QUESTION_WHAT_IS_BASIC_PURE_LANGUAGE = 'question.what-is-basic-pure-language',
+  QUESTION_HOW_TO_WRITE_PURE_LAMBDA = 'question.how-to-write-pure-lambda',
+
+  QUESTION_HOW_TO_DEFINE_A_CLASS = 'question.how-to-define-a-class',
+  QUESTION_HOW_TO_DEFINE_A_PROPERTY = 'question.how-to-define-a-class-property',
+  QUESTION_HOW_TO_DEFINE_A_DERIVATION = 'question.how-to-define-a-class-derivation',
+  QUESTION_HOW_TO_WRITE_A_DERIVATION_LAMBDA = 'question.how-to-write-a-class-derivation-lambda',
+  QUESTION_HOW_TO_DEFINE_A_CONSTRAINT = 'question.how-to-define-a-class-constraint',
+  QUESTION_HOW_TO_WRITE_A_CONSTRAINT_LAMBDA = 'question.how-to-write-a-class-constraint-lambda',
+  QUESTION_HOW_TO_SPECIFY_A_SUPERTYPE = 'question.how-to-specify-a-class-supertype',
+
+  // contexts
+  CONTEXT_CLASS_EDITOR = 'context.class-editor',
+}
+
+export const CORE_CONTEXTUAL_DOCUMENTATION_CONFIG: ContextualDocumentationConfig =
+  {
+    [LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.CLASS_EDITOR]:
+      LEGEND_STUDIO_DOCUMENTATION_KEY.CONTEXT_CLASS_EDITOR,
+    [LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.CLASS_DERIVED_PROPERTY_LAMBDA_EDITOR]:
+      LEGEND_STUDIO_DOCUMENTATION_KEY.QUESTION_HOW_TO_WRITE_A_CONSTRAINT_LAMBDA,
+    [LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.CLASS_CONTRAINT_LAMBDA_EDITOR]:
+      LEGEND_STUDIO_DOCUMENTATION_KEY.QUESTION_HOW_TO_WRITE_A_CONSTRAINT_LAMBDA,
+  };

package/src/stores/LegendStudioEventService.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 {
+  APPLICATION_EVENT,
+  type EventService,
+} from '@finos/legend-application';
+
+export class LegendStudioEventService {
+  private eventService!: EventService;
+
+  private constructor(eventService: EventService) {
+    this.eventService = eventService;
+  }
+
+  static create(eventService: EventService): LegendStudioEventService {
+    return new LegendStudioEventService(eventService);
+  }
+
+  notify_ApplicationLoaded(): void {
+    this.eventService.notify(APPLICATION_EVENT.APPLICATION_LOADED, {});
+  }
+}

package/src/stores/LegendStudioRouter.ts

@@ -0,0 +1,222 @@
+/**
+ * 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 { generateGAVCoordinates } from '@finos/legend-server-depot';
+import { WorkspaceType } from '@finos/legend-server-sdlc';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import { generatePath } from 'react-router';
+
+export enum LEGEND_STUDIO_PATH_PARAM_TOKEN {
+  PROJECT_ID = 'projectId',
+  WORKSPACE_ID = 'workspaceId',
+  GROUP_WORKSPACE_ID = 'groupWorkspaceId',
+  REVISION_ID = 'revisionId',
+  VERSION_ID = 'versionId',
+  REVIEW_ID = 'reviewId',
+  ENTITY_PATH = 'entityPath',
+  GAV = 'gav',
+}
+
+export const LEGEND_STUDIO_ROUTE_PATTERN = Object.freeze({
+  VIEW: `/view/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}`,
+  VIEW_BY_GAV: `/view/archive/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.GAV}`,
+  VIEW_BY_GAV_ENTITY: `/view/archive/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.GAV}/entity/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.ENTITY_PATH}`,
+  VIEW_BY_ENTITY: `/view/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/entity/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.ENTITY_PATH}`,
+  VIEW_BY_REVISION: `/view/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/revision/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.REVISION_ID}`,
+  VIEW_BY_VERSION: `/view/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/version/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.VERSION_ID}`,
+  VIEW_BY_REVISION_ENTITY: `/view/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/revision/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.REVISION_ID}/entity/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.ENTITY_PATH}`,
+  VIEW_BY_VERSION_ENTITY: `/view/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/version/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.VERSION_ID}/entity/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.ENTITY_PATH}`,
+  REVIEW: `/review/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.REVIEW_ID}`,
+  EDIT: `/edit/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.WORKSPACE_ID}/`,
+  EDIT_GROUP: `/edit/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/groupWorkspace/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.GROUP_WORKSPACE_ID}/`,
+  SETUP: `/setup/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}?/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.WORKSPACE_ID}?`,
+  SETUP_GROUP: `/setup/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID}/groupWorkspace/:${LEGEND_STUDIO_PATH_PARAM_TOKEN.GROUP_WORKSPACE_ID}/`,
+});
+
+export interface ReviewPathParams {
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID]: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.REVIEW_ID]: string;
+}
+
+export interface ViewerPathParams {
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.GAV]?: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID]?: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.VERSION_ID]?: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.REVISION_ID]?: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.ENTITY_PATH]?: string;
+}
+
+export interface CoreEditorPathParams {
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID]: string;
+}
+
+export interface EditorPathParams extends CoreEditorPathParams {
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.WORKSPACE_ID]: string;
+}
+
+export interface GroupEditorPathParams extends CoreEditorPathParams {
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.GROUP_WORKSPACE_ID]: string;
+}
+export interface SetupPathParams {
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.PROJECT_ID]?: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.WORKSPACE_ID]?: string;
+  [LEGEND_STUDIO_PATH_PARAM_TOKEN.GROUP_WORKSPACE_ID]?: string;
+}
+
+const generateGroupWorkspaceSetupRoute = (
+  projectId: string | undefined,
+  groupWorkspaceId: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.SETUP_GROUP, {
+    // FIXME: due to some problem with typings, we will need to cast like this
+    // we will fix this when upgrading react-router
+    // See https://github.com/finos/legend-studio/issues/688
+    projectId: projectId as string,
+    groupWorkspaceId,
+  });
+
+const generateWorkspaceSetupRoute = (
+  projectId: string | undefined,
+  workspaceId?: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.SETUP, {
+    // FIXME: due to some problem with typings, we will need to cast like this
+    // we will fix this when upgrading react-router
+    // See https://github.com/finos/legend-studio/issues/688
+    projectId: projectId as string,
+    // FIXME: due to some problem with typings, we will need to cast like this
+    // we will fix this when upgrading react-router
+    // See https://github.com/finos/legend-studio/issues/688
+    workspaceId: workspaceId as string,
+  });
+
+export const generateSetupRoute = (
+  projectId: string | undefined,
+  workspaceId?: string | undefined,
+  workspaceType?: WorkspaceType | undefined,
+): string =>
+  workspaceType === WorkspaceType.GROUP
+    ? generateGroupWorkspaceSetupRoute(
+        projectId,
+        guaranteeNonNullable(workspaceId),
+      )
+    : generateWorkspaceSetupRoute(projectId, workspaceId);
+
+const generateGroupWorkspaceEditorRoute = (
+  projectId: string,
+  groupWorkspaceId: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.EDIT_GROUP, {
+    projectId,
+    groupWorkspaceId,
+  });
+
+const generateWorkspaceEditorRoute = (
+  projectId: string,
+  workspaceId: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.EDIT, {
+    projectId,
+    workspaceId,
+  });
+
+export const generateEditorRoute = (
+  projectId: string,
+  workspaceId: string,
+  workspaceType: WorkspaceType,
+): string =>
+  workspaceType === WorkspaceType.GROUP
+    ? generateGroupWorkspaceEditorRoute(projectId, workspaceId)
+    : generateWorkspaceEditorRoute(projectId, workspaceId);
+
+export const generateReviewRoute = (
+  projectId: string,
+  reviewId: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.REVIEW, {
+    projectId,
+    reviewId,
+  });
+
+export const generateViewProjectRoute = (projectId: string): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW, {
+    projectId,
+  });
+
+export const generateViewEntityRoute = (
+  projectId: string,
+  entityPath: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_ENTITY, {
+    projectId,
+    entityPath,
+  });
+
+export const generateViewProjectByGAVRoute = (
+  groupId: string,
+  artifactId: string,
+  versionId: string,
+  entityPath?: string | undefined,
+): string =>
+  !entityPath
+    ? generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_GAV, {
+        gav: generateGAVCoordinates(groupId, artifactId, versionId),
+      })
+    : generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_GAV_ENTITY, {
+        gav: generateGAVCoordinates(groupId, artifactId, versionId),
+        entityPath,
+      });
+
+export const generateViewProjectEntityByGAVRoute = (
+  groupId: string,
+  artifactId: string,
+  versionId: string,
+): string =>
+  generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_GAV, {
+    gav: generateGAVCoordinates(groupId, artifactId, versionId),
+  });
+
+export const generateViewVersionRoute = (
+  projectId: string,
+  versionId: string,
+  entityPath?: string | undefined,
+): string =>
+  !entityPath
+    ? generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_VERSION, {
+        projectId,
+        versionId,
+      })
+    : generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_VERSION_ENTITY, {
+        projectId,
+        versionId,
+        entityPath,
+      });
+
+export const generateViewRevisionRoute = (
+  projectId: string,
+  revisionId: string,
+  entityPath?: string | undefined,
+): string =>
+  !entityPath
+    ? generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_REVISION, {
+        projectId,
+        revisionId,
+      })
+    : generatePath(LEGEND_STUDIO_ROUTE_PATTERN.VIEW_BY_REVISION_ENTITY, {
+        projectId,
+        revisionId,
+        entityPath,
+      });