@finos/legend-application-data-cube 0.1.7 → 0.1.9

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -62,21 +62,14 @@ import {
   LogEvent,
   UnsupportedOperationError,
   type PlainObject,
-  type DocumentationEntry,
   assertErrorThrown,
   NetworkClientError,
   HttpStatus,
   getNonNullableEntry,
   assertType,
 } from '@finos/legend-shared';
-import type {
-  LegendDataCubeApplicationStore,
-  LegendDataCubeBaseStore,
-} from './LegendDataCubeBaseStore.js';
-import {
-  APPLICATION_EVENT,
-  shouldDisplayVirtualAssistantDocumentationEntry,
-} from '@finos/legend-application';
+import type { LegendDataCubeApplicationStore } from './LegendDataCubeBaseStore.js';
+import { APPLICATION_EVENT } from '@finos/legend-application';
 import {
   LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE,
   LegendQueryDataCubeSource,
@@ -89,18 +82,23 @@ import {
 } from '@finos/legend-server-depot';
 
 export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
-  readonly application: LegendDataCubeApplicationStore;
-  readonly graphManager: V1_PureGraphManager;
-  readonly depotServerClient: DepotServerClient;
-  readonly engineServerClient: V1_EngineServerClient;
+  private readonly _application: LegendDataCubeApplicationStore;
+  private readonly _depotServerClient: DepotServerClient;
+  private readonly _engineServerClient: V1_EngineServerClient;
+  private readonly _graphManager: V1_PureGraphManager;
 
-  constructor(baseStore: LegendDataCubeBaseStore) {
+  constructor(
+    application: LegendDataCubeApplicationStore,
+    depotServerClient: DepotServerClient,
+    engineServerClient: V1_EngineServerClient,
+    graphManager: V1_PureGraphManager,
+  ) {
     super();
 
-    this.application = baseStore.application;
-    this.graphManager = baseStore.graphManager;
-    this.depotServerClient = baseStore.depotServerClient;
-    this.engineServerClient = baseStore.engineServerClient;
+    this._application = application;
+    this._depotServerClient = depotServerClient;
+    this._engineServerClient = engineServerClient;
+    this._graphManager = graphManager;
   }
 
   // ---------------------------------- IMPLEMENTATION ----------------------------------
@@ -119,31 +117,41 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           rawSource.query,
           false,
         );
-        source.columns = (
-          await this.getQueryRelationType(_lambda([], [source.query]), source)
-        ).columns;
+        try {
+          source.columns = (
+            await this._getLambdaRelationType(
+              _serializeValueSpecification(_lambda([], [source.query])),
+              source.model,
+            )
+          ).columns;
+        } catch (error) {
+          assertErrorThrown(error);
+          throw new Error(
+            `Can't get query result columns. Make sure the source query return a relation (i.e. typed TDS). Error: ${error.message}`,
+          );
+        }
         return source;
       }
       case LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE: {
         const rawSource =
           RawLegendQueryDataCubeSource.serialization.fromJson(value);
-        const queryInfo = await this.graphManager.getQueryInfo(
+        const queryInfo = await this._graphManager.getQueryInfo(
           rawSource.queryId,
         );
         const executionContext =
-          await this.graphManager.resolveQueryInfoExecutionContext(
+          await this._graphManager.resolveQueryInfoExecutionContext(
             queryInfo,
             () =>
-              this.depotServerClient.getVersionEntities(
+              this._depotServerClient.getVersionEntities(
                 queryInfo.groupId,
                 queryInfo.artifactId,
                 queryInfo.versionId,
               ),
           );
-        const query = new LegendQueryDataCubeSource();
-        query.info = queryInfo;
-        query.lambda = _deserializeLambda(
-          await this.engineServerClient.grammarToJSON_lambda(
+        const source = new LegendQueryDataCubeSource();
+        source.info = queryInfo;
+        source.lambda = _deserializeLambda(
+          await this._engineServerClient.grammarToJSON_lambda(
             queryInfo.content,
             '',
             undefined,
@@ -151,9 +159,9 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
             false,
           ),
         );
-        query.mapping = executionContext.mapping;
-        query.runtime = executionContext.runtime;
-        query.model = V1_serializePureModelContext(
+        source.mapping = executionContext.mapping;
+        source.runtime = executionContext.runtime;
+        source.model = V1_serializePureModelContext(
           new V1_PureModelContextPointer(
             undefined,
             new V1_LegendSDLC(
@@ -163,15 +171,22 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
             ),
           ),
         );
-        query.columns = (
-          await this._getLambdaRelationType(
-            _serializeValueSpecification(query.lambda),
-            query.model,
-          )
-        ).columns;
-        query.query = getNonNullableEntry(query.lambda.body, 0);
+        source.query = getNonNullableEntry(source.lambda.body, 0);
         // TODO: handle parameter values
-        return query;
+        try {
+          source.columns = (
+            await this._getLambdaRelationType(
+              _serializeValueSpecification(source.lambda),
+              source.model,
+            )
+          ).columns;
+        } catch (error) {
+          assertErrorThrown(error);
+          throw new Error(
+            `Can't get query result columns. Make sure the saved query return a relation (i.e. typed TDS). Error: ${error.message}`,
+          );
+        }
+        return source;
       }
       default:
         throw new UnsupportedOperationError(
@@ -194,14 +209,14 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
       : codeBlock;
     if (source instanceof AdhocQueryDataCubeSource) {
       return (
-        await this.engineServerClient.completeCode({
+        await this._engineServerClient.completeCode({
           codeBlock,
           model: source.model,
         })
       ).completions as CompletionItem[];
     } else if (source instanceof LegendQueryDataCubeSource) {
       return (
-        await this.engineServerClient.completeCode({
+        await this._engineServerClient.completeCode({
           codeBlock,
           model: source.model,
         })
@@ -218,7 +233,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ) {
     try {
       return _deserializeValueSpecification(
-        await this.engineServerClient.grammarToJSON_valueSpecification(
+        await this._engineServerClient.grammarToJSON_valueSpecification(
           code,
           '',
           undefined,
@@ -246,24 +261,12 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     value: V1_ValueSpecification,
     pretty?: boolean | undefined,
   ) {
-    return this.graphManager.valueSpecificationToPureCode(
+    return this._graphManager.valueSpecificationToPureCode(
       _serializeValueSpecification(value),
       pretty,
     );
   }
 
-  // TODO: we could optimize this by synthesizing the base query from the source columns
-  // instead of having to send the entire graph model
-  override async getQueryRelationType(
-    query: V1_Lambda,
-    source: DataCubeSource,
-  ) {
-    return this._getQueryRelationType(
-      _serializeValueSpecification(query),
-      source,
-    );
-  }
-
   // TODO: we could optimize this by synthesizing the base query from the source columns
   // instead of having to send the entire graph model
   override async getQueryCodeRelationReturnType(
@@ -274,7 +277,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     const baseQueryCode = await this.getValueSpecificationCode(baseQuery);
     const columnOffset = baseQueryCode.length;
     try {
-      const lambda = await this.engineServerClient.grammarToJSON_lambda(
+      const lambda = await this._engineServerClient.grammarToJSON_lambda(
         baseQueryCode + code,
         '',
         undefined,
@@ -379,7 +382,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ) {
     const relationType = deserialize(
       V1_relationTypeModelSchema,
-      await this.engineServerClient.lambdaRelationType({
+      await this._engineServerClient.lambdaRelationType({
         lambda,
         model,
       }),
@@ -399,7 +402,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ): Promise<ExecutionResult> {
     return V1_buildExecutionResult(
       V1_deserializeExecutionResult(
-        (await this.engineServerClient.runQuery({
+        (await this._engineServerClient.runQuery({
           clientVersion:
             // eslint-disable-next-line no-process-env
             process.env.NODE_ENV === 'development'
@@ -421,28 +424,8 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
 
   // ---------------------------------- APPLICATION ----------------------------------
 
-  override getDocumentationURL(): string | undefined {
-    return this.application.documentationService.url;
-  }
-
-  override getDocumentationEntry(key: string) {
-    return this.application.documentationService.getDocEntry(key);
-  }
-
-  override shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
-    return shouldDisplayVirtualAssistantDocumentationEntry(entry);
-  }
-
-  override openLink(url: string) {
-    this.application.navigationService.navigator.visitAddress(url);
-  }
-
-  override sendTelemetry(event: string, data: PlainObject) {
-    this.application.telemetryService.logEvent(event, data);
-  }
-
   override logDebug(message: string, ...data: unknown[]) {
-    this.application.logService.debug(
+    this._application.logService.debug(
       LogEvent.create(APPLICATION_EVENT.DEBUG),
       message,
       ...data,
@@ -452,14 +435,14 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   override debugProcess(processName: string, ...data: [string, unknown][]) {
     // eslint-disable-next-line no-process-env
     if (process.env.NODE_ENV === 'development') {
-      this.application.logService.info(
+      this._application.logService.info(
         LogEvent.create(APPLICATION_EVENT.DEBUG),
         `\n------ START DEBUG PROCESS: ${processName} ------`,
         ...data.flatMap(([key, value]) => [`\n[${key.toUpperCase()}]:`, value]),
         `\n------- END DEBUG PROCESS: ${processName} -------\n\n`,
       );
     } else {
-      this.application.logService.debug(
+      this._application.logService.debug(
         LogEvent.create(APPLICATION_EVENT.DEBUG),
         `\n------ START DEBUG PROCESS: ${processName} ------`,
         ...data.flatMap(([key, value]) => [`\n[${key.toUpperCase()}]:`, value]),
@@ -469,19 +452,19 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   }
 
   override logInfo(event: LogEvent, ...data: unknown[]) {
-    this.application.logService.info(event, ...data);
+    this._application.logService.info(event, ...data);
   }
 
   override logWarning(event: LogEvent, ...data: unknown[]) {
-    this.application.logService.warn(event, ...data);
+    this._application.logService.warn(event, ...data);
   }
 
   override logError(event: LogEvent, ...data: unknown[]) {
-    this.application.logService.error(event, ...data);
+    this._application.logService.error(event, ...data);
   }
 
   override logUnhandledError(error: Error) {
-    this.application.logUnhandledError(error);
+    this._application.logUnhandledError(error);
   }
 
   override logIllegalStateError(message: string, error?: Error) {
@@ -491,4 +474,16 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
       error,
     );
   }
+
+  override getDocumentationEntry(key: string) {
+    return this._application.documentationService.getDocEntry(key);
+  }
+
+  override openLink(url: string) {
+    this._application.navigationService.navigator.visitAddress(url);
+  }
+
+  override sendTelemetry(event: string, data: PlainObject) {
+    this._application.telemetryService.logEvent(event, data);
+  }
 }

package/src/stores/query-builder/LegendDataCubeNewQueryState.tsx

@@ -29,6 +29,7 @@ import {
 } from './source-builder/LegendDataCubeSourceBuilderState.js';
 import {
   _selectFunction,
+  type DataCubeAlertService,
   DataCubeQuery,
   DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
   type DisplayState,
@@ -43,12 +44,14 @@ import {
 import { generateQueryBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
 
 export class LegendDataCubeNewQueryState {
-  readonly application: LegendDataCubeApplicationStore;
-  readonly store: LegendDataCubeQueryBuilderStore;
-  readonly engine: LegendDataCubeDataCubeEngine;
-  readonly display: DisplayState;
+  private readonly _application: LegendDataCubeApplicationStore;
+  private readonly _store: LegendDataCubeQueryBuilderStore;
+  private readonly _engine: LegendDataCubeDataCubeEngine;
+  private readonly _alertService: DataCubeAlertService;
 
   readonly finalizeState = ActionState.create();
+  readonly display: DisplayState;
+
   sourceBuilder: LegendDataCubeSourceBuilderState;
 
   constructor(store: LegendDataCubeQueryBuilderStore) {
@@ -57,12 +60,14 @@ export class LegendDataCubeNewQueryState {
       changeSourceBuilder: action,
     });
 
-    this.application = store.application;
-    this.store = store;
-    this.engine = store.engine;
-    this.display = this.engine.layout.newDisplay(
+    this._application = store.application;
+    this._store = store;
+    this._engine = store.engine;
+    this._alertService = store.alertService;
+
+    this.display = store.layoutService.newDisplay(
       'New Query',
-      () => <LegendDataCubeNewQueryBuilder state={this} />,
+      () => <LegendDataCubeNewQueryBuilder />,
       {
         ...DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
         width: 500,
@@ -89,9 +94,18 @@ export class LegendDataCubeNewQueryState {
   ): LegendDataCubeSourceBuilderState {
     switch (type) {
       case LegendDataCubeSourceBuilderType.LEGEND_QUERY:
-        return new LegendQueryDataCubeSourceBuilderState(this);
+        return new LegendQueryDataCubeSourceBuilderState(
+          this._application,
+          this._engine,
+          this._store.engineServerClient,
+          this._store.graphManager,
+          this._alertService,
+        );
       case LegendDataCubeSourceBuilderType.ADHOC_QUERY:
-        return new AdhocQueryDataCubeSourceBuilderState(this);
+        return new AdhocQueryDataCubeSourceBuilderState(
+          this._application,
+          this._engine,
+        );
       default:
         throw new UnsupportedOperationError(
           `Can't create source builder for unsupported type '${type}'`,
@@ -108,16 +122,16 @@ export class LegendDataCubeNewQueryState {
     try {
       const source = await this.sourceBuilder.build();
       const query = new DataCubeQuery();
-      const processedSource = await this.engine.processQuerySource(source);
+      const processedSource = await this._engine.processQuerySource(source);
       query.source = source;
-      query.query = await this.engine.getValueSpecificationCode(
+      query.query = await this._engine.getValueSpecificationCode(
         _selectFunction(processedSource.columns),
       );
 
-      this.store.setBuilder(new LegendDataCubeQueryBuilderState(query));
+      this._store.setBuilder(new LegendDataCubeQueryBuilderState(query));
       // only update the route instead of reloading in case we are creating
       // a new query when we are editing another query
-      this.application.navigationService.navigator.updateCurrentLocation(
+      this._application.navigationService.navigator.updateCurrentLocation(
         generateQueryBuilderRoute(null),
       );
 
@@ -130,7 +144,7 @@ export class LegendDataCubeNewQueryState {
       this.finalizeState.pass();
     } catch (error) {
       assertErrorThrown(error);
-      this.engine.alertError(error, {
+      this._alertService.alertError(error, {
         message: `Query Creation Failure: ${error.message}`,
       });
       this.finalizeState.fail();

package/src/stores/query-builder/LegendDataCubeQueryBuilderStore.tsx

@@ -20,14 +20,20 @@ import type {
   LegendDataCubeBaseStore,
 } from '../LegendDataCubeBaseStore.js';
 import {
-  DataCubeConfiguration,
+  type DataCubeAlertService,
+  type DataCubeAPI,
+  type DataCubeLayoutService,
+  type DataCubeTaskService,
   DataCubeQuery,
-  DEFAULT_SMALL_ALERT_WINDOW_CONFIG,
-  type DataCubeState,
+  DEFAULT_ALERT_WINDOW_CONFIG,
   type DisplayState,
 } from '@finos/legend-data-cube';
 import { LegendDataCubeNewQueryState } from './LegendDataCubeNewQueryState.js';
-import { PersistentDataCubeQuery } from '@finos/legend-graph';
+import {
+  PersistentDataCubeQuery,
+  type V1_EngineServerClient,
+  type V1_PureGraphManager,
+} from '@finos/legend-graph';
 import {
   ActionState,
   assertErrorThrown,
@@ -43,13 +49,14 @@ import {
   LegendDataCubeUserDataKey,
   RECENTLY_VIEWED_QUERIES_LIMIT,
 } from '../../__lib__/LegendDataCubeUserData.js';
+import type { DepotServerClient } from '@finos/legend-server-depot';
 
 export class LegendDataCubeQueryBuilderState {
   uuid = uuid();
   startTime = Date.now();
   query!: DataCubeQuery;
   persistentQuery?: PersistentDataCubeQuery | undefined;
-  dataCube?: DataCubeState | undefined;
+  dataCube?: DataCubeAPI | undefined;
 
   constructor(
     query: DataCubeQuery,
@@ -68,7 +75,7 @@ export class LegendDataCubeQueryBuilderState {
     this.persistentQuery = persistentQuery;
   }
 
-  setDataCube(val: DataCubeState | undefined) {
+  setDataCube(val: DataCubeAPI | undefined) {
     this.dataCube = val;
   }
 
@@ -83,6 +90,12 @@ export class LegendDataCubeQueryBuilderStore {
   readonly application: LegendDataCubeApplicationStore;
   readonly baseStore: LegendDataCubeBaseStore;
   readonly engine: LegendDataCubeDataCubeEngine;
+  readonly depotServerClient: DepotServerClient;
+  readonly engineServerClient: V1_EngineServerClient;
+  readonly graphManager: V1_PureGraphManager;
+  readonly taskService: DataCubeTaskService;
+  readonly layoutService: DataCubeLayoutService;
+  readonly alertService: DataCubeAlertService;
 
   readonly newQueryState: LegendDataCubeNewQueryState;
 
@@ -102,14 +115,20 @@ export class LegendDataCubeQueryBuilderStore {
     this.application = baseStore.application;
     this.baseStore = baseStore;
     this.engine = baseStore.engine;
+    this.depotServerClient = baseStore.depotServerClient;
+    this.engineServerClient = baseStore.engineServerClient;
+    this.graphManager = baseStore.graphManager;
+    this.taskService = baseStore.taskService;
+    this.alertService = baseStore.alertService;
+    this.layoutService = baseStore.layoutService;
 
     this.newQueryState = new LegendDataCubeNewQueryState(this);
     this.loader = new LegendDataCubeQueryLoaderState(this);
-    this.saverDisplay = this.engine.layout.newDisplay(
+    this.saverDisplay = this.layoutService.newDisplay(
       'Save Query',
       () => <LegendDataCubeQuerySaver />,
       {
-        ...DEFAULT_SMALL_ALERT_WINDOW_CONFIG,
+        ...DEFAULT_ALERT_WINDOW_CONFIG,
         height: 140,
       },
     );
@@ -174,7 +193,7 @@ export class LegendDataCubeQueryBuilderStore {
         this.loadQueryState.pass();
       } catch (error) {
         assertErrorThrown(error);
-        this.engine.alertError(error, {
+        this.alertService.alertError(error, {
           message: `Query Load Failure: ${error.message}`,
         });
         this.loadQueryState.fail();
@@ -183,19 +202,11 @@ export class LegendDataCubeQueryBuilderStore {
   }
 
   private async generatePersistentQuery(
-    dataCube: DataCubeState,
+    api: DataCubeAPI,
     name: string,
     existingPersistentQuery?: PersistentDataCubeQuery | undefined,
   ) {
-    const currentSnapshot = dataCube.view.snapshotManager.currentSnapshot;
-
-    const query = new DataCubeQuery();
-    query.source = dataCube.query.source;
-    query.configuration = DataCubeConfiguration.serialization.fromJson(
-      currentSnapshot.data.configuration,
-    );
-    query.query = await this.engine.getPartialQueryCode(currentSnapshot);
-
+    const query = await api.generateDataCubeQuery();
     let persistentQuery: PersistentDataCubeQuery;
     if (existingPersistentQuery) {
       persistentQuery = existingPersistentQuery.clone();
@@ -240,7 +251,7 @@ export class LegendDataCubeQueryBuilderStore {
       this.saveQueryState.pass();
     } catch (error) {
       assertErrorThrown(error);
-      this.engine.alertError(error, {
+      this.alertService.alertError(error, {
         message: `Query Creation Failure: ${error.message}`,
       });
       this.saveQueryState.fail();
@@ -287,7 +298,7 @@ export class LegendDataCubeQueryBuilderStore {
       this.saveQueryState.pass();
     } catch (error) {
       assertErrorThrown(error);
-      this.engine.alertError(error, {
+      this.alertService.alertError(error, {
         message: `Query Update Failure: ${error.message}`,
       });
       this.saveQueryState.fail();

package/src/stores/query-builder/LegendDataCubeQueryLoaderState.tsx

@@ -23,13 +23,14 @@ import {
   type LightPersistentDataCubeQuery,
   QuerySearchSpecification,
   QuerySearchSortBy,
+  type V1_PureGraphManager,
 } from '@finos/legend-graph';
 import { ActionState, assertErrorThrown, LogEvent } from '@finos/legend-shared';
 import { makeObservable, observable, action } from 'mobx';
-import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
 import type { LegendDataCubeQueryBuilderStore } from './LegendDataCubeQueryBuilderStore.js';
 import { LegendDataCubeUserDataKey } from '../../__lib__/LegendDataCubeUserData.js';
 import {
+  type DataCubeAlertService,
   DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
   type DisplayState,
 } from '@finos/legend-data-cube';
@@ -46,13 +47,15 @@ export enum DataCubeQuerySortByType {
 }
 
 export class LegendDataCubeQueryLoaderState {
-  readonly application: GenericLegendApplicationStore;
-  readonly store: LegendDataCubeQueryBuilderStore;
-  readonly engine: LegendDataCubeDataCubeEngine;
-  readonly display: DisplayState;
+  private readonly _application: GenericLegendApplicationStore;
+  private readonly _store: LegendDataCubeQueryBuilderStore;
+  private readonly _graphManager: V1_PureGraphManager;
+  private readonly _alertService: DataCubeAlertService;
 
+  readonly display: DisplayState;
   readonly searchState = ActionState.create();
   readonly finalizeState = ActionState.create();
+
   queries: LightPersistentDataCubeQuery[] = [];
   selectedQuery?: LightPersistentDataCubeQuery | undefined;
 
@@ -82,10 +85,12 @@ export class LegendDataCubeQueryLoaderState {
       setSelectedQuery: action,
     });
 
-    this.application = store.application;
-    this.store = store;
-    this.engine = store.engine;
-    this.display = this.engine.layout.newDisplay(
+    this._application = store.application;
+    this._store = store;
+    this._graphManager = store.graphManager;
+    this._alertService = store.alertService;
+
+    this.display = store.layoutService.newDisplay(
       'Load Query',
       () => <LegendDataCubeQueryLoader />,
       {
@@ -152,18 +157,17 @@ export class LegendDataCubeQueryLoaderState {
           // first, try to fetch recently viewed queries
           try {
             const recentlyViewedQueryIDs =
-              this.store.getRecentlyViewedQueries();
+              this._store.getRecentlyViewedQueries();
             if (recentlyViewedQueryIDs.length) {
-              defaultQueries =
-                await this.engine.graphManager.getDataCubeQueries(
-                  recentlyViewedQueryIDs,
-                );
+              defaultQueries = await this._graphManager.getDataCubeQueries(
+                recentlyViewedQueryIDs,
+              );
             }
           } catch (error) {
             assertErrorThrown(error);
             // if there's an error fetching recently viewed queries, most likely because
             // some queries have been removed, just remove them all from the cached user data
-            this.application.userDataService.persistValue(
+            this._application.userDataService.persistValue(
               LegendDataCubeUserDataKey.RECENTLY_VIEWED_QUERIES,
               undefined,
             );
@@ -175,7 +179,7 @@ export class LegendDataCubeQueryLoaderState {
               DATA_CUBE_QUERY_LOADER_DEFAULT_QUERY_SEARCH_LIMIT;
             searchSpecification.showCurrentUserQueriesOnly = true;
             defaultQueries =
-              await this.engine.graphManager.searchDataCubeQueries(
+              await this._graphManager.searchDataCubeQueries(
                 searchSpecification,
               );
           }
@@ -183,7 +187,7 @@ export class LegendDataCubeQueryLoaderState {
           this.searchState.pass();
         } catch (error) {
           assertErrorThrown(error);
-          this.engine.logError(
+          this._application.logService.error(
             LogEvent.create(APPLICATION_EVENT.GENERIC_FAILURE),
             error,
           );
@@ -208,9 +212,7 @@ export class LegendDataCubeQueryLoaderState {
         searchSpecification.sortByOption = querySearchSortBy;
       }
       this.setQueries(
-        await this.engine.graphManager.searchDataCubeQueries(
-          searchSpecification,
-        ),
+        await this._graphManager.searchDataCubeQueries(searchSpecification),
       );
 
       // if sorting is not configured, sort by name
@@ -223,7 +225,7 @@ export class LegendDataCubeQueryLoaderState {
       this.searchState.pass();
     } catch (error) {
       assertErrorThrown(error);
-      this.engine.alertError(error, {
+      this._alertService.alertError(error, {
         message: `Query Search Failure: ${error.message}`,
       });
       this.searchState.fail();
@@ -239,7 +241,7 @@ export class LegendDataCubeQueryLoaderState {
     try {
       // just simply change the route here and the new query ID will get picked up
       // and handled by the query builder to load the new query.
-      this.application.navigationService.navigator.updateCurrentLocation(
+      this._application.navigationService.navigator.updateCurrentLocation(
         generateQueryBuilderRoute(this.selectedQuery.id),
       );
 
@@ -249,7 +251,7 @@ export class LegendDataCubeQueryLoaderState {
       this.finalizeState.pass();
     } catch (error) {
       assertErrorThrown(error);
-      this.engine.alertError(error, {
+      this._alertService.alertError(error, {
         message: `Query Load Failure: ${error.message}`,
       });
       this.finalizeState.fail();