@finos/legend-application-query 12.0.9 → 13.0.1

package/src/stores/QueryEditorStore.ts

@@ -33,6 +33,7 @@ import {
   ActionState,
   StopWatch,
   guaranteeType,
+  quantifyList,
 } from '@finos/legend-shared';
 import {
   type LightQuery,
@@ -45,12 +46,12 @@ import {
   RuntimePointer,
   GRAPH_MANAGER_EVENT,
   extractElementNameFromPath,
-  QuerySearchSpecification,
   Mapping,
   type Runtime,
   type Service,
   createGraphBuilderReport,
   LegendSDLC,
+  QuerySearchSpecification,
 } from '@finos/legend-graph';
 import {
   EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl,
@@ -74,7 +75,6 @@ import {
 import {
   DEFAULT_TAB_SIZE,
   DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
-  DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
 } from '@finos/legend-application';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import { LegendQueryEventHelper } from '../__lib__/LegendQueryEventHelper.js';
@@ -85,7 +85,9 @@ import {
   ClassQueryBuilderState,
   MappingQueryBuilderState,
   ServiceQueryBuilderState,
+  QueryLoaderState,
 } from '@finos/legend-query-builder';
+import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
 
 export const createViewProjectHandler =
@@ -148,14 +150,15 @@ export interface QueryPersistConfiguration {
 }
 
 export class QuerySaveAsState {
-  editorStore: QueryEditorStore;
+  readonly editorStore: QueryEditorStore;
+  readonly queryBuilderState: QueryBuilderState;
+  readonly createQueryState = ActionState.create();
+
   lambda: RawLambda;
   queryName: string;
   allowUpdate = false;
   onQueryUpdate?: ((query: Query) => void) | undefined;
   decorator?: ((query: Query) => void) | undefined;
-  queryBuilderState: QueryBuilderState;
-  createQueryState = ActionState.create();
 
   constructor(
     editorStore: QueryEditorStore,
@@ -256,7 +259,6 @@ export class QuerySaveAsState {
         this.queryBuilderState.changeDetectionState.initialize(this.lambda);
         // turn off change detection at this point
         // TODO: to make performance better, refrain from refreshing like this
-        this.editorStore.setTitle(query.name);
         this.editorStore.applicationStore.navigationService.navigator.goToLocation(
           generateExistingQueryEditorRoute(newQuery.id),
         );
@@ -266,7 +268,6 @@ export class QuerySaveAsState {
             query,
             this.editorStore.graphManagerState.graph,
           )) as Query;
-        this.editorStore.setTitle(updatedQuery.name);
         this.editorStore.applicationStore.notificationService.notifySuccess(
           `Successfully updated query!`,
         );
@@ -301,14 +302,15 @@ export class QuerySaveAsState {
 }
 
 export class QuerySaveState {
-  editorStore: QueryEditorStore;
+  readonly editorStore: QueryEditorStore;
+  readonly saveQueryState = ActionState.create();
+
+  queryBuilderState: QueryBuilderState;
   lambda: RawLambda;
   queryName: string;
   allowUpdate = false;
   onQueryUpdate?: ((query: Query) => void) | undefined;
   decorator?: ((query: Query) => void) | undefined;
-  queryBuilderState: QueryBuilderState;
-  saveQueryState = ActionState.create();
 
   constructor(
     editorStore: QueryEditorStore,
@@ -409,14 +411,16 @@ export class QuerySaveState {
 }
 
 export class QueryRenameState {
-  editorStore: QueryEditorStore;
+  readonly editorStore: QueryEditorStore;
+  readonly queryBuilderState: QueryBuilderState;
+
+  readonly renameQueryState = ActionState.create();
+
   lambda: RawLambda;
   queryName: string;
   allowUpdate = false;
   onQueryUpdate?: ((query: Query) => void) | undefined;
   decorator?: ((query: Query) => void) | undefined;
-  queryBuilderState: QueryBuilderState;
-  saveQueryState = ActionState.create();
 
   constructor(
     editorStore: QueryEditorStore,
@@ -451,7 +455,7 @@ export class QueryRenameState {
     ) {
       return;
     }
-    this.saveQueryState.inProgress();
+    this.renameQueryState.inProgress();
     const query = new Query();
     query.name = this.queryName;
     query.mapping = PackageableElementExplicitReference.create(
@@ -471,7 +475,7 @@ export class QueryRenameState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.saveQueryState.reset();
+      this.renameQueryState.reset();
       return;
     }
 
@@ -481,7 +485,6 @@ export class QueryRenameState {
           query,
           this.editorStore.graphManagerState.graph,
         )) as Query;
-      this.editorStore.setTitle(updatedQuery.name);
       this.editorStore.applicationStore.notificationService.notifySuccess(
         `Successfully renamed query!`,
       );
@@ -506,90 +509,25 @@ export class QueryRenameState {
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
-      this.saveQueryState.reset();
+      this.renameQueryState.reset();
       this.editorStore.setRenameState(undefined);
     }
   }
 }
 
-export class QueryLoaderState {
-  readonly editorStore: QueryEditorStore;
-
-  readonly loadQueriesState = ActionState.create();
-  queries: LightQuery[] = [];
-  isQueryLoaderOpen = false;
-  showCurrentUserQueriesOnly = false;
-
-  constructor(editorStore: QueryEditorStore) {
-    makeObservable(this, {
-      isQueryLoaderOpen: observable,
-      queries: observable,
-      showCurrentUserQueriesOnly: observable,
-      setIsQueryLoaderOpen: action,
-      setQueries: action,
-      setShowCurrentUserQueriesOnly: action,
-      loadQueries: flow,
-    });
-    this.editorStore = editorStore;
-  }
-
-  setIsQueryLoaderOpen(val: boolean): void {
-    this.isQueryLoaderOpen = val;
-  }
-
-  setQueries(val: LightQuery[]): void {
-    this.queries = val;
-  }
-
-  setShowCurrentUserQueriesOnly(val: boolean): void {
-    this.showCurrentUserQueriesOnly = val;
-  }
-
-  *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;
-      searchSpecification.showCurrentUserQueriesOnly =
-        this.showCurrentUserQueriesOnly;
-      this.queries =
-        (yield this.editorStore.graphManagerState.graphManager.searchQueries(
-          searchSpecification,
-        )) as LightQuery[];
-      this.loadQueriesState.pass();
-    } catch (error) {
-      this.loadQueriesState.fail();
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-    }
-  }
-
-  reset(): void {
-    this.setShowCurrentUserQueriesOnly(false);
-  }
-}
-
 export abstract class QueryEditorStore {
   readonly applicationStore: LegendQueryApplicationStore;
   readonly depotServerClient: DepotServerClient;
   readonly pluginManager: LegendQueryPluginManager;
   readonly graphManagerState: GraphManagerState;
+  readonly queryLoaderState: QueryLoaderState;
 
   readonly initState = ActionState.create();
+
   queryBuilderState?: QueryBuilderState | undefined;
   saveAsState?: QuerySaveAsState | undefined;
   saveState?: QuerySaveState | undefined;
   renameState?: QueryRenameState | undefined;
-
-  // if the implementation of QueryEditorStore does not support save
-  // saveState = undefined
-
-  queryLoaderState: QueryLoaderState;
   title: string | undefined;
   existingQueryName: string | undefined;
 
@@ -608,7 +546,6 @@ export abstract class QueryEditorStore {
       setExistingQueryName: action,
       setSaveAsState: action,
       setSaveState: action,
-      setTitle: action,
       initialize: flow,
       buildGraph: flow,
       searchExistingQueryName: flow,
@@ -621,7 +558,56 @@ export abstract class QueryEditorStore {
       applicationStore.pluginManager,
       applicationStore.logService,
     );
-    this.queryLoaderState = new QueryLoaderState(this);
+    this.queryLoaderState = new QueryLoaderState(
+      applicationStore,
+      this.graphManagerState,
+      {
+        loadQuery: (query: LightQuery): void => {
+          this.queryBuilderState?.changeDetectionState.alertUnsavedChanges(
+            () => {
+              this.queryLoaderState.setQueryLoaderDialogOpen(false);
+              applicationStore.navigationService.navigator.goToLocation(
+                generateExistingQueryEditorRoute(query.id),
+                { ignoreBlocking: true },
+              );
+            },
+          );
+        },
+        fetchDefaultQueries: () =>
+          this.graphManagerState.graphManager.getQueries(
+            LegendQueryUserDataHelper.getRecentlyViewedQueries(
+              this.applicationStore.userDataService,
+            ),
+          ),
+        generateDefaultQueriesSummaryText: (queries) =>
+          queries.length
+            ? `Showing ${quantifyList(
+                queries,
+                'recently viewed query',
+                'recently viewed queries',
+              )}`
+            : `No recently viewed queries`,
+        onQueryDeleted: (query): void =>
+          LegendQueryUserDataHelper.removeRecentlyViewedQuery(
+            this.applicationStore.userDataService,
+            query.id,
+          ),
+        onQueryRenamed: (query): void => {
+          LegendQueryTelemetryHelper.logEvent_RenameQuerySucceeded(
+            applicationStore.telemetryService,
+            {
+              query: {
+                id: query.id,
+                name: query.name,
+                groupId: query.groupId,
+                artifactId: query.artifactId,
+                versionId: query.versionId,
+              },
+            },
+          );
+        },
+      },
+    );
   }
 
   get isViewProjectActionDisabled(): boolean {
@@ -632,11 +618,6 @@ export abstract class QueryEditorStore {
     return false;
   }
 
-  setTitle(val: string | undefined): void {
-    document.title = `${val} - Legend Query`;
-    this.title = val;
-  }
-
   setSaveAsState(val: QuerySaveAsState | undefined): void {
     this.saveAsState = val;
   }
@@ -667,7 +648,7 @@ export abstract class QueryEditorStore {
    */
   protected abstract initializeQueryBuilderState(): Promise<QueryBuilderState>;
 
-  abstract getExportConfiguration(
+  abstract getPersistConfiguration(
     lambda: RawLambda,
     options?: { update?: boolean | undefined },
   ): Promise<QueryPersistConfiguration>;
@@ -703,7 +684,7 @@ export abstract class QueryEditorStore {
       yield flowResult(this.buildGraph());
       this.queryBuilderState =
         (yield this.initializeQueryBuilderState()) as QueryBuilderState;
-
+      this.queryLoaderState.initialize(this.queryBuilderState);
       this.initState.pass();
     } catch (error) {
       assertErrorThrown(error);
@@ -835,11 +816,11 @@ export abstract class QueryEditorStore {
 }
 
 export class MappingQueryCreatorStore extends QueryEditorStore {
-  groupId: string;
-  artifactId: string;
-  versionId: string;
-  mappingPath: string;
-  runtimePath: string;
+  readonly groupId: string;
+  readonly artifactId: string;
+  readonly versionId: string;
+  readonly mappingPath: string;
+  readonly runtimePath: string;
 
   constructor(
     applicationStore: LegendQueryApplicationStore,
@@ -909,7 +890,7 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
     return queryBuilderState;
   }
 
-  async getExportConfiguration(): Promise<QueryPersistConfiguration> {
+  async getPersistConfiguration(): Promise<QueryPersistConfiguration> {
     return {
       decorator: (query: Query): void => {
         query.id = uuid();
@@ -922,11 +903,11 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
 }
 
 export class ServiceQueryCreatorStore extends QueryEditorStore {
-  groupId: string;
-  artifactId: string;
-  versionId: string;
-  servicePath: string;
-  executionKey: string | undefined;
+  readonly groupId: string;
+  readonly artifactId: string;
+  readonly versionId: string;
+  readonly servicePath: string;
+  readonly executionKey: string | undefined;
 
   constructor(
     applicationStore: LegendQueryApplicationStore,
@@ -997,7 +978,7 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
     return queryBuilderState;
   }
 
-  async getExportConfiguration(
+  async getPersistConfiguration(
     lambda: RawLambda,
     options?: { update?: boolean | undefined },
   ): Promise<QueryPersistConfiguration> {
@@ -1064,6 +1045,10 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       this.queryId,
       this.graphManagerState.graph,
     );
+    LegendQueryUserDataHelper.addRecentlyViewedQuery(
+      this.applicationStore.userDataService,
+      query.id,
+    );
     let queryBuilderState: QueryBuilderState | undefined;
     const existingQueryEditorStateBuilders = this.applicationStore.pluginManager
       .getApplicationPlugins()
@@ -1107,11 +1092,10 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         },
       },
     );
-    this.setTitle(this.query.name);
     return queryBuilderState;
   }
 
-  async getExportConfiguration(
+  async getPersistConfiguration(
     lambda: RawLambda,
     options?: { update?: boolean | undefined },
   ): Promise<QueryPersistConfiguration> {

package/src/stores/QueryProductionizerSetupStore.ts

@@ -14,36 +14,22 @@
  * 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 { LightQuery } from '@finos/legend-graph';
+import { QueryLoaderState } from '@finos/legend-query-builder';
 import {
   type DepotServerClient,
   StoreProjectData,
 } 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 '../__lib__/LegendQueryNavigation.js';
 import { BaseQuerySetupStore } from './QuerySetupStore.js';
+import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
+import { quantifyList } from '@finos/legend-shared';
+import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
 
 export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
-  readonly loadQueriesState = ActionState.create();
-  readonly loadQueryState = ActionState.create();
-  queries: LightQuery[] = [];
-  currentQuery?: LightQuery | undefined;
-  currentQueryInfo?: QueryInfo | undefined;
+  readonly queryLoaderState: QueryLoaderState;
 
   constructor(
     applicationStore: LegendQueryApplicationStore,
@@ -51,25 +37,59 @@ export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
   ) {
     super(applicationStore, depotServerClient);
 
-    makeObservable(this, {
-      queries: observable,
-      currentQuery: observable,
-      currentQueryInfo: observable,
-      setCurrentQuery: flow,
-      loadQueries: flow,
-    });
+    this.queryLoaderState = new QueryLoaderState(
+      applicationStore,
+      this.graphManagerState,
+      {
+        loadQuery: (query: LightQuery): void => {
+          this.queryLoaderState.setQueryLoaderDialogOpen(false);
+          this.loadQueryProductionizer(query).catch(
+            applicationStore.alertUnhandledError,
+          );
+        },
+        fetchDefaultQueries: () =>
+          this.graphManagerState.graphManager.getQueries(
+            LegendQueryUserDataHelper.getRecentlyViewedQueries(
+              this.applicationStore.userDataService,
+            ),
+          ),
+        generateDefaultQueriesSummaryText: (queries) =>
+          queries.length
+            ? `Showing ${quantifyList(
+                queries,
+                'recently viewed query',
+                'recently viewed queries',
+              )}`
+            : `No recently viewed queries`,
+        onQueryDeleted: (query): void =>
+          LegendQueryUserDataHelper.removeRecentlyViewedQuery(
+            this.applicationStore.userDataService,
+            query.id,
+          ),
+        onQueryRenamed: (query): void => {
+          LegendQueryTelemetryHelper.logEvent_RenameQuerySucceeded(
+            applicationStore.telemetryService,
+            {
+              query: {
+                id: query.id,
+                name: query.name,
+                groupId: query.groupId,
+                artifactId: query.artifactId,
+                versionId: query.versionId,
+              },
+            },
+          );
+        },
+      },
+    );
   }
 
-  async loadQueryProductionizer(): Promise<void> {
-    if (!this.currentQuery) {
-      return;
-    }
-
+  async loadQueryProductionizer(selectedQuery: LightQuery): Promise<void> {
     // fetch project data
     const project = StoreProjectData.serialization.fromJson(
       await this.depotServerClient.getProject(
-        this.currentQuery.groupId,
-        this.currentQuery.artifactId,
+        selectedQuery.groupId,
+        selectedQuery.artifactId,
       ),
     );
 
@@ -87,7 +107,7 @@ export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
       this.applicationStore.navigationService.navigator.goToAddress(
         EXTERNAL_APPLICATION_NAVIGATION__generateStudioProductionizeQueryUrl(
           matchingSDLCEntry.url,
-          this.currentQuery.id,
+          selectedQuery.id,
         ),
       );
     } else {
@@ -96,53 +116,4 @@ export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
       );
     }
   }
-
-  *setCurrentQuery(queryId: string | undefined): GeneratorFn<void> {
-    if (queryId) {
-      try {
-        this.loadQueryState.inProgress();
-        this.currentQuery =
-          (yield this.graphManagerState.graphManager.getLightQuery(
-            queryId,
-          )) as LightQuery;
-        const queryInfo =
-          (yield this.graphManagerState.graphManager.getQueryInfo(
-            queryId,
-          )) as QueryInfo;
-        queryInfo.content =
-          (yield this.graphManagerState.graphManager.prettyLambdaContent(
-            queryInfo.content,
-          )) as string;
-        this.currentQueryInfo = queryInfo;
-      } catch (error) {
-        assertErrorThrown(error);
-        this.applicationStore.notificationService.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.notificationService.notifyError(error);
-      this.loadQueriesState.fail();
-    }
-  }
 }

package/src/stores/QuerySetupStore.ts

@@ -26,7 +26,10 @@ import {
 import { BasicGraphManagerState } from '@finos/legend-graph';
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import { LEGEND_QUERY_APP_EVENT } from '../__lib__/LegendQueryEvent.js';
-import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
+import {
+  DEFAULT_TAB_SIZE,
+  LEGEND_APPLICATION_COLOR_THEME,
+} from '@finos/legend-application';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
 import { generateQuerySetupRoute } from '../__lib__/LegendQueryNavigation.js';
@@ -62,6 +65,12 @@ export abstract class BaseQuerySetupStore {
       return;
     }
 
+    // TODO?: remove this when we properly support theme everywhere
+    // See https://github.com/finos/legend-studio/issues/264
+    this.applicationStore.layoutService.setColorTheme(
+      LEGEND_APPLICATION_COLOR_THEME.DEFAULT_DARK,
+    );
+
     try {
       this.initState.inProgress();
       yield this.graphManagerState.graphManager.initialize(

package/tsconfig.json

@@ -38,6 +38,7 @@
     "./src/__lib__/LegendQueryEventHelper.ts",
     "./src/__lib__/LegendQueryNavigation.ts",
     "./src/__lib__/LegendQueryTelemetryHelper.ts",
+    "./src/__lib__/LegendQueryUserDataHelper.ts",
     "./src/application/LegendQueryApplicationConfig.ts",
     "./src/application/LegendQueryDocumentation.ts",
     "./src/application/LegendQueryPluginManager.ts",