@finos/legend-application-query 9.0.37 → 10.0.0

package/src/stores/LegendQueryBaseStore.ts

@@ -15,9 +15,21 @@
  */
 
 import type { DepotServerClient } from '@finos/legend-server-depot';
-import type { ApplicationStore } from '@finos/legend-application';
+import {
+  type ApplicationStore,
+  ApplicationTelemetry,
+  APPLICATION_EVENT,
+} from '@finos/legend-application';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import type { LegendQueryApplicationConfig } from '../application/LegendQueryApplicationConfig.js';
+import {
+  ActionState,
+  assertErrorThrown,
+  LogEvent,
+  NetworkClient,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { flow, makeObservable } from 'mobx';
 
 export type LegendQueryApplicationStore = ApplicationStore<
   LegendQueryApplicationConfig,
@@ -25,14 +37,20 @@ export type LegendQueryApplicationStore = ApplicationStore<
 >;
 
 export class LegendQueryBaseStore {
-  applicationStore: LegendQueryApplicationStore;
-  depotServerClient: DepotServerClient;
-  pluginManager: LegendQueryPluginManager;
+  readonly applicationStore: LegendQueryApplicationStore;
+  readonly depotServerClient: DepotServerClient;
+  readonly pluginManager: LegendQueryPluginManager;
+
+  readonly initState = ActionState.create();
 
   constructor(
     applicationStore: LegendQueryApplicationStore,
     depotServerClient: DepotServerClient,
   ) {
+    makeObservable(this, {
+      initialize: flow,
+    });
+
     this.applicationStore = applicationStore;
     this.depotServerClient = depotServerClient;
     this.pluginManager = applicationStore.pluginManager;
@@ -42,4 +60,54 @@ export class LegendQueryBaseStore {
       this.applicationStore.tracerService,
     );
   }
+
+  *initialize(): GeneratorFn<void> {
+    if (!this.initState.isInInitialState) {
+      this.applicationStore.notifyIllegalState('Base store is re-initialized');
+      return;
+    }
+    this.initState.inProgress();
+
+    try {
+      this.applicationStore.setCurrentUser(
+        (yield new NetworkClient().get(
+          `${this.applicationStore.config.engineServerUrl}/server/v1/currentUser`,
+        )) as string,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(
+          APPLICATION_EVENT.APPLICATION_IDENTITY_AUTO_FETCH__FAILURE,
+        ),
+        error,
+      );
+      this.applicationStore.notifyWarning(error.message);
+    }
+
+    // setup telemetry service
+    this.applicationStore.telemetryService.setUserId(
+      this.applicationStore.currentUser,
+    );
+
+    ApplicationTelemetry.logEvent_ApplicationInitializationSucceeded(
+      this.applicationStore.telemetryService,
+      {
+        application: {
+          name: this.applicationStore.config.appName,
+          version: this.applicationStore.config.appVersion,
+          env: this.applicationStore.config.env,
+        },
+        browser: {
+          userAgent: navigator.userAgent,
+        },
+        screen: {
+          height: window.screen.height,
+          width: window.screen.width,
+        },
+      },
+    );
+
+    this.initState.complete();
+  }
 }

package/src/stores/LegendQueryEventService.ts

@@ -33,6 +33,9 @@ export class LegendQueryEventService {
   }
 
   notify_QueryCreated(data: QueryCreated_EventData): void {
-    this.eventService.notify(LEGEND_QUERY_APP_EVENT.QUERY_CREATED, data);
+    this.eventService.notify(
+      LEGEND_QUERY_APP_EVENT.CREATE_QUERY__SUCCESS,
+      data,
+    );
   }
 }

package/src/stores/LegendQueryTelemetry.ts

@@ -17,7 +17,7 @@
 import type { TelemetryService } from '@finos/legend-shared';
 import { LEGEND_QUERY_APP_EVENT } from './LegendQueryAppEvent.js';
 
-type QueryViewed_TelemetryData = {
+type Query_TelemetryData = {
   query: {
     name: string;
     id: string;
@@ -28,10 +28,30 @@ type QueryViewed_TelemetryData = {
 };
 
 export class LegendQueryTelemetry {
-  static logEvent_ViewQuery(
+  static logEvent_ViewQuerySucceeded(
     telemetryService: TelemetryService,
-    data: QueryViewed_TelemetryData,
+    data: Query_TelemetryData,
   ): void {
-    telemetryService.logEvent(LEGEND_QUERY_APP_EVENT.QUERY_VIEWED, data);
+    telemetryService.logEvent(LEGEND_QUERY_APP_EVENT.VIEW_QUERY__SUCCESS, data);
+  }
+
+  static logEvent_CreateQuerySucceeded(
+    telemetryService: TelemetryService,
+    data: Query_TelemetryData,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_QUERY_APP_EVENT.CREATE_QUERY__SUCCESS,
+      data,
+    );
+  }
+
+  static logEvent_UpdateQuerySucceeded(
+    telemetryService: TelemetryService,
+    data: Query_TelemetryData,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_QUERY_APP_EVENT.UPDATE_QUERY__SUCCESS,
+      data,
+    );
   }
 }

package/src/stores/QueryEditorStore.ts

@@ -44,13 +44,13 @@ import {
   PackageableElementExplicitReference,
   RuntimePointer,
   GRAPH_MANAGER_EVENT,
-  type GraphBuilderReport,
   GraphManagerTelemetry,
   extractElementNameFromPath,
   QuerySearchSpecification,
   Mapping,
   type Runtime,
   type Service,
+  createGraphBuilderReport,
 } from '@finos/legend-graph';
 import {
   EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl,
@@ -64,10 +64,12 @@ import {
   type Entity,
   type ProjectGAVCoordinates,
   parseProjectIdentifier,
+  LegendSDLC,
 } from '@finos/legend-storage';
 import {
   type DepotServerClient,
   ProjectData,
+  resolveVersion,
 } from '@finos/legend-server-depot';
 import {
   TAB_SIZE,
@@ -85,6 +87,7 @@ import {
   ServiceQueryBuilderState,
 } from '@finos/legend-query-builder';
 import { LegendQueryTelemetry } from './LegendQueryTelemetry.js';
+import { LEGEND_QUERY_APPLICATION_NAVIGATION_CONTEXT_KEY } from './LegendQueryApplicationNavigationContext.js';
 
 export const createViewProjectHandler =
   (applicationStore: LegendQueryApplicationStore) =>
@@ -231,9 +234,24 @@ export class QueryExportState {
         this.editorStore.applicationStore.notifySuccess(
           `Successfully created query!`,
         );
+
         LegendQueryEventService.create(
           this.editorStore.applicationStore.eventService,
         ).notify_QueryCreated({ queryId: newQuery.id });
+
+        LegendQueryTelemetry.logEvent_CreateQuerySucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          {
+            query: {
+              id: query.id,
+              name: query.name,
+              groupId: query.groupId,
+              artifactId: query.artifactId,
+              versionId: query.versionId,
+            },
+          },
+        );
+
         this.editorStore.applicationStore.navigator.goToLocation(
           generateExistingQueryEditorRoute(newQuery.id),
         );
@@ -246,6 +264,20 @@ export class QueryExportState {
         this.editorStore.applicationStore.notifySuccess(
           `Successfully updated query!`,
         );
+
+        LegendQueryTelemetry.logEvent_UpdateQuerySucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          {
+            query: {
+              id: query.id,
+              name: query.name,
+              groupId: query.groupId,
+              artifactId: query.artifactId,
+              versionId: query.versionId,
+            },
+          },
+        );
+
         this.onQueryUpdate?.(updatedQuery);
       }
     } catch (error) {
@@ -442,7 +474,7 @@ export abstract class QueryEditorStore {
     // initialize system
     stopWatch.record();
     yield this.graphManagerState.initializeSystem();
-    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_SYSTEM_INITIALIZED);
+    stopWatch.record(GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH_SYSTEM__SUCCESS);
 
     // fetch entities
     stopWatch.record();
@@ -452,7 +484,7 @@ export abstract class QueryEditorStore {
       versionId,
     )) as Entity[];
     this.initState.setMessage(undefined);
-    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_ENTITIES_FETCHED);
+    stopWatch.record(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS);
 
     // fetch and build dependencies
     stopWatch.record();
@@ -465,49 +497,61 @@ export abstract class QueryEditorStore {
     const dependencyEntitiesIndex = (yield flowResult(
       this.depotServerClient.getIndexedDependencyEntities(project, versionId),
     )) as Map<string, Entity[]>;
-    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_DEPENDENCIES_FETCHED);
-
-    const dependency_buildReport =
-      (yield this.graphManagerState.graphManager.buildDependencies(
-        this.graphManagerState.coreModel,
-        this.graphManagerState.systemModel,
-        dependencyManager,
-        dependencyEntitiesIndex,
-        this.graphManagerState.dependenciesBuildState,
-      )) as GraphBuilderReport;
+    stopWatch.record(GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS);
+
+    const dependency_buildReport = createGraphBuilderReport();
+    yield this.graphManagerState.graphManager.buildDependencies(
+      this.graphManagerState.coreModel,
+      this.graphManagerState.systemModel,
+      dependencyManager,
+      dependencyEntitiesIndex,
+      this.graphManagerState.dependenciesBuildState,
+      {},
+      dependency_buildReport,
+    );
     dependency_buildReport.timings[
-      GRAPH_MANAGER_EVENT.GRAPH_DEPENDENCIES_FETCHED
-    ] = stopWatch.getRecord(GRAPH_MANAGER_EVENT.GRAPH_DEPENDENCIES_FETCHED);
+      GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS
+    ] = stopWatch.getRecord(
+      GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS,
+    );
 
     // build graph
-    const graph_buildReport =
-      (yield this.graphManagerState.graphManager.buildGraph(
-        this.graphManagerState.graph,
-        entities,
-        this.graphManagerState.graphBuildState,
-      )) as GraphBuilderReport;
-    graph_buildReport.timings[GRAPH_MANAGER_EVENT.GRAPH_ENTITIES_FETCHED] =
-      stopWatch.getRecord(GRAPH_MANAGER_EVENT.GRAPH_ENTITIES_FETCHED);
+    const graph_buildReport = createGraphBuilderReport();
+    yield this.graphManagerState.graphManager.buildGraph(
+      this.graphManagerState.graph,
+      entities,
+      this.graphManagerState.graphBuildState,
+      {
+        sdlc: new LegendSDLC(groupId, artifactId, resolveVersion(versionId)),
+      },
+      graph_buildReport,
+    );
+    graph_buildReport.timings[
+      GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS
+    ] = stopWatch.getRecord(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS);
 
     // report
-    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED);
+    stopWatch.record(GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS);
     const graphBuilderReportData = {
       timings: {
-        [GRAPH_MANAGER_EVENT.GRAPH_SYSTEM_INITIALIZED]: stopWatch.getRecord(
-          GRAPH_MANAGER_EVENT.GRAPH_SYSTEM_INITIALIZED,
-        ),
-        [GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED]: stopWatch.getRecord(
-          GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED,
+        [GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH_SYSTEM__SUCCESS]:
+          stopWatch.getRecord(
+            GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH_SYSTEM__SUCCESS,
+          ),
+        [GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS]: stopWatch.getRecord(
+          GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS,
         ),
       },
       dependencies: dependency_buildReport,
+      dependenciesCount:
+        this.graphManagerState.graph.dependencyManager.numberOfDependencies,
       graph: graph_buildReport,
     };
     this.applicationStore.log.info(
-      LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED),
+      LogEvent.create(GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS),
       graphBuilderReportData,
     );
-    GraphManagerTelemetry.logEvent_GraphInitialized(
+    GraphManagerTelemetry.logEvent_GraphInitializationSucceeded(
       this.applicationStore.telemetryService,
       graphBuilderReportData,
     );
@@ -757,6 +801,9 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       queryBuilderState ??
       new ClassQueryBuilderState(this.applicationStore, this.graphManagerState);
 
+    queryBuilderState.applicationContext =
+      LEGEND_QUERY_APPLICATION_NAVIGATION_CONTEXT_KEY.EDITOR;
+
     queryBuilderState.setMapping(query.mapping.value);
     queryBuilderState.setRuntimeValue(
       new RuntimePointer(
@@ -770,7 +817,7 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
     );
 
     // send analytics
-    LegendQueryTelemetry.logEvent_ViewQuery(
+    LegendQueryTelemetry.logEvent_ViewQuerySucceeded(
       this.applicationStore.telemetryService,
       {
         query: {
@@ -783,6 +830,7 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       },
     );
 
+    queryBuilderState.setTitleOfQuery(this.query.name);
     return queryBuilderState;
   }
 

package/tsconfig.json

@@ -40,6 +40,7 @@
     "./src/stores/CreateMappingQuerySetupStore.ts",
     "./src/stores/EditExistingQuerySetupStore.ts",
     "./src/stores/LegendQueryAppEvent.ts",
+    "./src/stores/LegendQueryApplicationNavigationContext.ts",
     "./src/stores/LegendQueryApplicationPlugin.ts",
     "./src/stores/LegendQueryBaseStore.ts",
     "./src/stores/LegendQueryEventService.ts",