@finos/legend-application-query 8.1.2 → 9.0.0

package/src/stores/LegendQueryRouter.ts

@@ -14,7 +14,14 @@
  * limitations under the License.
  */
 
-import { generatePath } from '@finos/legend-application';
+import {
+  generateExtensionUrlPattern,
+  generatePath,
+} from '@finos/legend-application';
+import {
+  addQueryParamsStringToUrl,
+  stringifyQueryParams,
+} from '@finos/legend-shared';
 import { generateGAVCoordinates } from '@finos/legend-storage';
 
 export enum LEGEND_QUERY_PATH_PARAM_TOKEN {
@@ -25,17 +32,77 @@ export enum LEGEND_QUERY_PATH_PARAM_TOKEN {
   SERVICE_PATH = 'servicePath',
 }
 
+export enum LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN {
+  SHOW_ALL_GROUPS = 'showAllGroups',
+  SHOW_ADVANCED_ACTIONS = 'showAdvancedActions',
+  TAG = 'tag',
+}
+
 export enum LEGEND_QUERY_QUERY_PARAM_TOKEN {
   SERVICE_EXECUTION_KEY = 'executionKey',
 }
 
 export const LEGEND_QUERY_ROUTE_PATTERN = Object.freeze({
   SETUP: '/setup',
+  EDIT_EXISTING_QUERY_SETUP: '/setup/existing-query',
+  CREATE_MAPPING_QUERY_SETUP: '/setup/manual',
+  CLONE_SERVICE_QUERY_SETUP: '/setup/clone-service-query',
+  QUERY_PRODUCTIONIZER_SETUP: '/setup/productionize-query',
+  UPDATE_EXISTING_SERVICE_QUERY_SETUP: '/setup/update-existing-service-query',
+  LOAD_PROJECT_SERVICE_QUERY_SETUP: '/setup/load-project-service-query',
   CREATE_FROM_MAPPING_QUERY: `/create/manual/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH}`,
   CREATE_FROM_SERVICE_QUERY: `/create-from-service/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH}`,
   EDIT_EXISTING_QUERY: `/edit/:${LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID}`,
 });
 
+export interface QuerySetupQueryParams {
+  [LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN.SHOW_ALL_GROUPS]?: string;
+  [LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN.SHOW_ADVANCED_ACTIONS]?: string;
+  [LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN.TAG]?: string;
+}
+
+export const generateQuerySetupRoute = (
+  showAllGroups?: boolean | undefined,
+  showAdvancedActions?: boolean | undefined,
+  tag?: string | undefined,
+): string =>
+  addQueryParamsStringToUrl(
+    generatePath(LEGEND_QUERY_ROUTE_PATTERN.SETUP, {}),
+    stringifyQueryParams({
+      [LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN.SHOW_ALL_GROUPS]: showAllGroups,
+      [LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN.SHOW_ADVANCED_ACTIONS]:
+        showAdvancedActions,
+      [LEGEND_QUERY_SETUP_QUERY_PARAM_TOKEN.TAG]: tag,
+    }),
+  );
+
+export const generateEditExistingQuerySetupRoute = (): string =>
+  generatePath(LEGEND_QUERY_ROUTE_PATTERN.EDIT_EXISTING_QUERY_SETUP, {});
+export const generateCreateMappingQuerySetupRoute = (): string =>
+  generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_MAPPING_QUERY_SETUP, {});
+export const generateCloneServiceQuerySetupRoute = (): string =>
+  generateExtensionUrlPattern(
+    generatePath(LEGEND_QUERY_ROUTE_PATTERN.CLONE_SERVICE_QUERY_SETUP, {}),
+  );
+export const generateQueryProductionizerSetupRoute = (): string =>
+  generateExtensionUrlPattern(
+    generatePath(LEGEND_QUERY_ROUTE_PATTERN.QUERY_PRODUCTIONIZER_SETUP, {}),
+  );
+export const generateUpdateExistingServiceQuerySetup = (): string =>
+  generateExtensionUrlPattern(
+    generatePath(
+      LEGEND_QUERY_ROUTE_PATTERN.UPDATE_EXISTING_SERVICE_QUERY_SETUP,
+      {},
+    ),
+  );
+export const generateLoadProjectServiceQuerySetup = (): string =>
+  generateExtensionUrlPattern(
+    generatePath(
+      LEGEND_QUERY_ROUTE_PATTERN.LOAD_PROJECT_SERVICE_QUERY_SETUP,
+      {},
+    ),
+  );
+
 export const generateMappingQueryCreatorRoute = (
   groupId: string,
   artifactId: string,
@@ -64,18 +131,21 @@ export const generateServiceQueryCreatorRoute = (
   artifactId: string,
   versionId: string,
   servicePath: string,
-  key?: string,
+  executionKey?: string | undefined,
 ): string =>
-  `${generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_FROM_SERVICE_QUERY, {
-    [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
-      groupId,
-      artifactId,
-      versionId,
-    ),
-    [LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH]: servicePath,
-  })}${
-    key ? `?${LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY}=${key}` : ''
-  }`;
+  addQueryParamsStringToUrl(
+    generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_FROM_SERVICE_QUERY, {
+      [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
+        groupId,
+        artifactId,
+        versionId,
+      ),
+      [LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH]: servicePath,
+    }),
+    stringifyQueryParams({
+      [LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY]: executionKey,
+    }),
+  );
 
 export interface ServiceQueryCreatorPathParams {
   [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: string;
@@ -111,6 +181,19 @@ export const EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl = (
     versionId,
   )}${entityPath ? `/entity/${entityPath}` : ''}`;
 
+/**
+ * @external_application_navigation This depends on Legend Studio routing and is hardcoded so it's potentially brittle
+ */
+export const EXTERNAL_APPLICATION_NAVIGATION__generateStudioSDLCProjectViewUrl =
+  (
+    studioUrl: string,
+    projectId: string,
+    entityPath: string | undefined,
+  ): string =>
+    `${studioUrl}/view/${projectId}${
+      entityPath ? `/entity/${entityPath}` : ''
+    }`;
+
 /**
  * @external_application_navigation This depends on Legend Studio routing and is hardcoded so it's potentially brittle
  */

package/src/stores/LoadProjectServiceQuerySetupStore.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 {
+  ProjectData,
+  type DepotServerClient,
+} from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  type PlainObject,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { parseProjectIdentifier } from '@finos/legend-storage';
+import { flow, makeObservable, observable } from 'mobx';
+import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { EXTERNAL_APPLICATION_NAVIGATION__generateStudioUpdateProjectServiceQueryUrl } from './LegendQueryRouter.js';
+import { BaseQuerySetupStore } from './QuerySetupStore.js';
+
+export class LoadProjectServiceQuerySetupStore extends BaseQuerySetupStore {
+  readonly loadProjectsState = ActionState.create();
+  projects: ProjectData[] = [];
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+  ) {
+    super(applicationStore, depotServerClient);
+
+    makeObservable(this, {
+      projects: observable,
+      loadProjects: flow,
+    });
+  }
+
+  *loadProjects(): GeneratorFn<void> {
+    this.loadProjectsState.inProgress();
+    try {
+      this.projects = (
+        (yield this.depotServerClient.getProjects()) as PlainObject<ProjectData>[]
+      ).map((v) => ProjectData.serialization.fromJson(v));
+      this.loadProjectsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadProjectsState.fail();
+    }
+  }
+
+  async loadProjectServiceUpdater(project: ProjectData): Promise<void> {
+    // find the matching SDLC instance
+    const projectIDPrefix = parseProjectIdentifier(project.projectId).prefix;
+    const matchingSDLCEntry = this.applicationStore.config.studioInstances.find(
+      (entry) => entry.sdlcProjectIDPrefix === projectIDPrefix,
+    );
+    if (matchingSDLCEntry) {
+      this.applicationStore.setBlockingAlert({
+        message: `Loading service project...`,
+        prompt: 'Please do not close the application',
+        showLoading: true,
+      });
+      this.applicationStore.navigator.goToAddress(
+        EXTERNAL_APPLICATION_NAVIGATION__generateStudioUpdateProjectServiceQueryUrl(
+          matchingSDLCEntry.url,
+          project.projectId,
+        ),
+      );
+    } else {
+      this.applicationStore.notifyWarning(
+        `Can't find the corresponding SDLC instance to load project '${project.projectId}'`,
+      );
+    }
+  }
+}

package/src/stores/QueryEditorStore.ts

@@ -50,21 +50,27 @@ import {
   QuerySearchSpecification,
   Mapping,
   type Runtime,
+  type Service,
 } from '@finos/legend-graph';
 import {
+  EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl,
+  EXTERNAL_APPLICATION_NAVIGATION__generateStudioSDLCProjectViewUrl,
   generateExistingQueryEditorRoute,
   generateMappingQueryCreatorRoute,
   generateServiceQueryCreatorRoute,
 } from './LegendQueryRouter.js';
 import { LEGEND_QUERY_APP_EVENT } from '../LegendQueryAppEvent.js';
-import type { Entity, ProjectGAVCoordinates } from '@finos/legend-storage';
+import {
+  type Entity,
+  type ProjectGAVCoordinates,
+  parseProjectIdentifier,
+} from '@finos/legend-storage';
 import {
   type DepotServerClient,
   ProjectData,
 } from '@finos/legend-server-depot';
 import {
   TAB_SIZE,
-  APPLICATION_EVENT,
   DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
   DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
 } from '@finos/legend-application';
@@ -79,6 +85,58 @@ import {
   ServiceQueryBuilderState,
 } from '@finos/legend-query-builder';
 
+export const createViewProjectHandler =
+  (applicationStore: LegendQueryApplicationStore) =>
+  (
+    groupId: string,
+    artifactId: string,
+    versionId: string,
+    entityPath: string | undefined,
+  ): void =>
+    applicationStore.navigator.visitAddress(
+      EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl(
+        applicationStore.config.studioUrl,
+        groupId,
+        artifactId,
+        versionId,
+        entityPath,
+      ),
+    );
+
+export const createViewSDLCProjectHandler =
+  (
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+  ) =>
+  async (
+    groupId: string,
+    artifactId: string,
+    entityPath: string | undefined,
+  ): Promise<void> => {
+    // fetch project data
+    const project = ProjectData.serialization.fromJson(
+      await depotServerClient.getProject(groupId, artifactId),
+    );
+    // find the matching SDLC instance
+    const projectIDPrefix = parseProjectIdentifier(project.projectId).prefix;
+    const matchingSDLCEntry = applicationStore.config.studioInstances.find(
+      (entry) => entry.sdlcProjectIDPrefix === projectIDPrefix,
+    );
+    if (matchingSDLCEntry) {
+      applicationStore.navigator.visitAddress(
+        EXTERNAL_APPLICATION_NAVIGATION__generateStudioSDLCProjectViewUrl(
+          matchingSDLCEntry.url,
+          project.projectId,
+          entityPath,
+        ),
+      );
+    } else {
+      applicationStore.notifyWarning(
+        `Can't find the corresponding SDLC instance to view the SDLC project`,
+      );
+    }
+  };
+
 export interface QueryExportConfiguration {
   defaultName?: string | undefined;
   allowUpdate?: boolean | undefined;
@@ -131,6 +189,7 @@ export class QueryExportState {
 
   async persistQuery(createNew: boolean): Promise<void> {
     if (
+      this.editorStore.isSaveActionDisabled ||
       !this.queryBuilderState.mapping ||
       !(this.queryBuilderState.runtimeValue instanceof RuntimePointer)
     ) {
@@ -174,7 +233,7 @@ export class QueryExportState {
         LegendQueryEventService.create(
           this.editorStore.applicationStore.eventService,
         ).notify_QueryCreated({ queryId: newQuery.id });
-        this.editorStore.applicationStore.navigator.reloadToLocation(
+        this.editorStore.applicationStore.navigator.goToLocation(
           generateExistingQueryEditorRoute(newQuery.id),
         );
       } else {
@@ -296,6 +355,14 @@ export abstract class QueryEditorStore {
     this.queryLoaderState = new QueryLoaderState(this);
   }
 
+  get isViewProjectActionDisabled(): boolean {
+    return false;
+  }
+
+  get isSaveActionDisabled(): boolean {
+    return false;
+  }
+
   setExportState(val: QueryExportState | undefined): void {
     this.exportState = val;
   }
@@ -304,9 +371,11 @@ export abstract class QueryEditorStore {
   /**
    * Set up the editor state before building the graph
    */
+
   protected async setUpEditorState(): Promise<void> {
     // do nothing
   }
+
   /**
    * Set up the query builder state after building the graph
    */
@@ -317,17 +386,6 @@ export abstract class QueryEditorStore {
 
   *initialize(): GeneratorFn<void> {
     if (!this.initState.isInInitialState) {
-      // eslint-disable-next-line no-process-env
-      if (process.env.NODE_ENV === 'development') {
-        this.applicationStore.log.info(
-          LogEvent.create(APPLICATION_EVENT.DEVELOPMENT_ISSUE),
-          `Fast-refreshing the app - preventing initialize() recall...`,
-        );
-        return;
-      }
-      this.applicationStore.notifyIllegalState(
-        `Query editor store is already initialized`,
-      );
       return;
     }
 
@@ -351,8 +409,7 @@ export abstract class QueryEditorStore {
       );
 
       yield this.setUpEditorState();
-      const { groupId, artifactId, versionId } = this.getProjectInfo();
-      yield flowResult(this.buildGraph(groupId, artifactId, versionId));
+      yield flowResult(this.buildGraph());
       this.queryBuilderState =
         (yield this.initializeQueryBuilderState()) as QueryBuilderState;
 
@@ -368,13 +425,11 @@ export abstract class QueryEditorStore {
     }
   }
 
-  *buildGraph(
-    groupId: string,
-    artifactId: string,
-    versionId: string,
-  ): GeneratorFn<void> {
+  *buildGraph(): GeneratorFn<void> {
     const stopWatch = new StopWatch();
 
+    const { groupId, artifactId, versionId } = this.getProjectInfo();
+
     // fetch project data
     const project = ProjectData.serialization.fromJson(
       (yield this.depotServerClient.getProject(
@@ -496,7 +551,7 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
       this.applicationStore,
       this.graphManagerState,
       (val: Mapping) => {
-        this.applicationStore.navigator.goToLocation(
+        this.applicationStore.navigator.updateCurrentLocation(
           generateMappingQueryCreatorRoute(
             this.groupId,
             this.artifactId,
@@ -508,7 +563,7 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
         );
       },
       (val: Runtime) => {
-        this.applicationStore.navigator.goToLocation(
+        this.applicationStore.navigator.updateCurrentLocation(
           generateMappingQueryCreatorRoute(
             this.groupId,
             this.artifactId,
@@ -590,9 +645,20 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
       this.applicationStore,
       this.graphManagerState,
       service,
+      this.graphManagerState.usableServices,
       this.executionKey,
-      (val: ServiceExecutionContext): void => {
+      (val: Service): void => {
         this.applicationStore.navigator.goToLocation(
+          generateServiceQueryCreatorRoute(
+            this.groupId,
+            this.artifactId,
+            this.versionId,
+            val.path,
+          ),
+        );
+      },
+      (val: ServiceExecutionContext): void => {
+        this.applicationStore.navigator.updateCurrentLocation(
           generateServiceQueryCreatorRoute(
             this.groupId,
             this.artifactId,

package/src/stores/QueryEditorStoreTestUtils.ts

@@ -30,6 +30,9 @@ const TEST_DATA__appConfig = {
     url: 'http://testStudioUrl',
     instances: [],
   },
+  taxonomy: {
+    url: 'http://testTaxonomyUrl',
+  },
 };
 
 export const TEST__getTestLegendQueryApplicationConfig = (

package/src/stores/QueryProductionizerSetupStore.ts

@@ -0,0 +1,143 @@
+/**
+ * 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 {
+  DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
+  DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
+} from '@finos/legend-application';
+import {
+  type LightQuery,
+  type QueryInfo,
+  QuerySearchSpecification,
+} from '@finos/legend-graph';
+import {
+  type DepotServerClient,
+  ProjectData,
+} from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { parseProjectIdentifier } from '@finos/legend-storage';
+import { flow, makeObservable, observable } from 'mobx';
+import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { EXTERNAL_APPLICATION_NAVIGATION__generateStudioProductionizeQueryUrl } from './LegendQueryRouter.js';
+import { BaseQuerySetupStore } from './QuerySetupStore.js';
+
+export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
+  readonly loadQueriesState = ActionState.create();
+  readonly loadQueryState = ActionState.create();
+  queries: LightQuery[] = [];
+  currentQuery?: LightQuery | undefined;
+  currentQueryInfo?: QueryInfo | undefined;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+  ) {
+    super(applicationStore, depotServerClient);
+
+    makeObservable(this, {
+      queries: observable,
+      currentQuery: observable,
+      currentQueryInfo: observable,
+      setCurrentQuery: flow,
+      loadQueries: flow,
+    });
+  }
+
+  async loadQueryProductionizer(): Promise<void> {
+    if (!this.currentQuery) {
+      return;
+    }
+
+    // fetch project data
+    const project = ProjectData.serialization.fromJson(
+      await this.depotServerClient.getProject(
+        this.currentQuery.groupId,
+        this.currentQuery.artifactId,
+      ),
+    );
+
+    // find the matching SDLC instance
+    const projectIDPrefix = parseProjectIdentifier(project.projectId).prefix;
+    const matchingSDLCEntry = this.applicationStore.config.studioInstances.find(
+      (entry) => entry.sdlcProjectIDPrefix === projectIDPrefix,
+    );
+    if (matchingSDLCEntry) {
+      this.applicationStore.setBlockingAlert({
+        message: `Loading query...`,
+        prompt: 'Please do not close the application',
+        showLoading: true,
+      });
+      this.applicationStore.navigator.goToAddress(
+        EXTERNAL_APPLICATION_NAVIGATION__generateStudioProductionizeQueryUrl(
+          matchingSDLCEntry.url,
+          this.currentQuery.id,
+        ),
+      );
+    } else {
+      this.applicationStore.notifyWarning(
+        `Can't find the corresponding SDLC instance to productionize the query`,
+      );
+    }
+  }
+
+  *setCurrentQuery(queryId: string | undefined): GeneratorFn<void> {
+    if (queryId) {
+      try {
+        this.loadQueryState.inProgress();
+        this.currentQuery =
+          (yield this.graphManagerState.graphManager.getLightQuery(
+            queryId,
+          )) as LightQuery;
+        this.currentQueryInfo =
+          (yield this.graphManagerState.graphManager.getQueryInfo(
+            queryId,
+          )) as QueryInfo;
+      } catch (error) {
+        assertErrorThrown(error);
+        this.applicationStore.notifyError(error);
+      } finally {
+        this.loadQueryState.reset();
+      }
+    } else {
+      this.currentQuery = undefined;
+    }
+  }
+
+  *loadQueries(searchText: string): GeneratorFn<void> {
+    const isValidSearchString =
+      searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
+    this.loadQueriesState.inProgress();
+    try {
+      const searchSpecification = new QuerySearchSpecification();
+      searchSpecification.searchTerm = isValidSearchString
+        ? searchText
+        : undefined;
+      searchSpecification.limit = DEFAULT_TYPEAHEAD_SEARCH_LIMIT;
+      this.queries = (yield this.graphManagerState.graphManager.searchQueries(
+        searchSpecification,
+      )) as LightQuery[];
+      this.loadQueriesState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadQueriesState.fail();
+    }
+  }
+}