@finos/legend-application-query 13.5.56 → 13.6.1

package/src/components/CreateMappingQuerySetup.tsx

@@ -279,7 +279,11 @@ const CreateMappingQuerySetupContent = observer(() => {
                 !projectOptions.length
               }
               isLoading={setupStore.loadProjectsState.isInProgress}
-              onChange={onProjectOptionChange}
+              onChange={(option: ProjectOption | null) => {
+                onProjectOptionChange(option).catch(
+                  applicationStore.alertUnhandledError,
+                );
+              }}
               value={selectedProjectOption}
               placeholder={projectSelectorPlaceholder}
               isClearable={true}
@@ -297,7 +301,11 @@ const CreateMappingQuerySetupContent = observer(() => {
               options={versionOptions}
               disabled={!setupStore.currentProject}
               isLoading={fetchSelectedProjectVersionsStatus.isInProgress}
-              onChange={onVersionOptionChange}
+              onChange={(option: VersionOption | null) => {
+                onVersionOptionChange(option).catch(
+                  applicationStore.alertUnhandledError,
+                );
+              }}
               value={selectedVersionOption}
               placeholder={
                 fetchSelectedProjectVersionsStatus.isInProgress

package/src/components/LegendQueryWebApplication.tsx

@@ -25,9 +25,8 @@ import {
 import {
   BrowserEnvironmentProvider,
   Route,
-  Switch,
+  Routes,
   generateExtensionUrlPattern,
-  type TEMPORARY__ReactRouterComponentType,
 } from '@finos/legend-application/browser';
 import {
   LegendQueryFrameworkProvider,
@@ -41,6 +40,7 @@ import { flowResult } from 'mobx';
 import { LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import { DataSpaceTemplateQueryCreator } from './data-space/DataSpaceTemplateQueryCreator.js';
 import { DataSpaceQueryCreator } from './data-space/DataSpaceQueryCreator.js';
+import { ExistingQueryDataCubeViewer } from './data-cube/ExistingQueryDataCubeViewer.js';
 
 const LegendQueryWebApplicationRouter = observer(() => {
   const applicationStore = useLegendQueryApplicationStore();
@@ -58,117 +58,72 @@ const LegendQueryWebApplicationRouter = observer(() => {
   return (
     <div className="app">
       {baseStore.initState.hasCompleted && (
-        <Switch>
+        <Routes>
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.DEFAULT}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              DataSpaceQueryCreator as TEMPORARY__ReactRouterComponentType
-            }
+            element={<DataSpaceQueryCreator />}
           />
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.EDIT_EXISTING_QUERY_SETUP}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              EditExistingQuerySetup as TEMPORARY__ReactRouterComponentType
-            }
+            element={<EditExistingQuerySetup />}
           />
 
           <Route
-            exact={true}
-            path={[
-              generateExtensionUrlPattern(
-                LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.TEMPLATE_QUERY,
-              ),
-            ]}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              DataSpaceTemplateQueryCreator as TEMPORARY__ReactRouterComponentType
-            }
+            path={generateExtensionUrlPattern(
+              LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.TEMPLATE_QUERY,
+            )}
+            element={<DataSpaceTemplateQueryCreator />}
           />
 
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.SETUP}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              QuerySetupLandingPage as TEMPORARY__ReactRouterComponentType
-            }
+            element={<QuerySetupLandingPage />}
           />
 
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.CREATE_MAPPING_QUERY_SETUP}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              CreateMappingQuerySetup as TEMPORARY__ReactRouterComponentType
-            }
+            element={<CreateMappingQuerySetup />}
           />
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.EDIT_EXISTING_QUERY}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              ExistingQueryEditor as TEMPORARY__ReactRouterComponentType
-            }
+            element={<ExistingQueryEditor />}
+          />
+          <Route
+            path={LEGEND_QUERY_ROUTE_PATTERN.DATA_CUBE_EXISTING_QUERY}
+            element={<ExistingQueryDataCubeViewer />}
           />
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.CREATE_FROM_SERVICE_QUERY}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              ServiceQueryCreator as TEMPORARY__ReactRouterComponentType
-            }
+            element={<ServiceQueryCreator />}
           />
           <Route
-            exact={true}
             path={LEGEND_QUERY_ROUTE_PATTERN.CREATE_FROM_MAPPING_QUERY}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              MappingQueryCreator as TEMPORARY__ReactRouterComponentType
-            }
+            element={<MappingQueryCreator />}
           />
+
           {/* LEGACY DATA SPACE */}
           <Route
-            exact={true}
-            path={[
-              generateExtensionUrlPattern(
-                LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.SETUP,
-              ),
-            ]}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              DataSpaceQueryCreator as TEMPORARY__ReactRouterComponentType
-            }
+            path={generateExtensionUrlPattern(
+              LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.SETUP,
+            )}
+            element={<DataSpaceQueryCreator />}
           />
 
           <Route
-            exact={true}
-            path={[
-              generateExtensionUrlPattern(
-                LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.CREATE,
-              ),
-            ]}
-            component={
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              DataSpaceQueryCreator as TEMPORARY__ReactRouterComponentType
-            }
+            path={generateExtensionUrlPattern(
+              LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.CREATE,
+            )}
+            element={<DataSpaceQueryCreator />}
           />
 
-          {extraApplicationPageEntries.map((entry) => (
-            <Route
-              key={entry.key}
-              exact={true}
-              path={entry.addressPatterns.map(generateExtensionUrlPattern)}
-              component={
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                entry.renderer as TEMPORARY__ReactRouterComponentType
-              }
-            />
-          ))}
-        </Switch>
+          {extraApplicationPageEntries.flatMap((entry) =>
+            entry.addressPatterns
+              .map(generateExtensionUrlPattern)
+              .map((path) => (
+                <Route key={entry.key} path={path} element={entry.renderer()} />
+              )),
+          )}
+        </Routes>
       )}
     </div>
   );

package/src/components/QueryEditor.tsx

@@ -89,7 +89,11 @@ import {
 import { LATEST_VERSION_ALIAS } from '@finos/legend-server-depot';
 import { buildVersionOption, type VersionOption } from './QuerySetup.js';
 import { QueryEditorExistingQueryVersionRevertModal } from './QueryEdtiorExistingQueryVersionRevertModal.js';
-import { debounce, compareSemVerVersions } from '@finos/legend-shared';
+import {
+  debounce,
+  compareSemVerVersions,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
 import { LegendQueryInfo } from './LegendQueryAppInfo.js';
 import { QueryEditorDataspaceInfoModal } from './data-space/DataSpaceInfo.js';
 import { DataSpaceQueryBuilderState } from '@finos/legend-extension-dsl-data-space/application';
@@ -422,9 +426,7 @@ const QueryEditorExistingQueryInfoModal = observer(
     const selectedVersionOption = updateState.queryVersionId
       ? buildVersionOption(updateState.queryVersionId)
       : buildVersionOption(query.versionId);
-    const onVersionOptionChange = async (
-      option: VersionOption | null,
-    ): Promise<void> => {
+    const onVersionOptionChange = (option: VersionOption | null) => {
       if (option?.value && option.value !== updateState.queryVersionId) {
         updateState.setQueryVersionId(option.value);
       }
@@ -816,7 +818,9 @@ const processQueryParams = (
 export const ExistingQueryEditor = observer(() => {
   const applicationStore = useApplicationStore();
   const params = useParams<ExistingQueryEditorPathParams>();
-  const queryId = params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.QUERY_ID];
+  const queryId = guaranteeNonNullable(
+    params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.QUERY_ID],
+  );
   const queryParams =
     applicationStore.navigationService.navigator.getCurrentLocationParameters();
   const processed = processQueryParams(queryParams);
@@ -839,8 +843,12 @@ export const ExistingQueryEditor = observer(() => {
 export const ServiceQueryCreator = observer(() => {
   const applicationStore = useApplicationStore();
   const parameters = useParams<ServiceQueryCreatorPathParams>();
-  const gav = parameters[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.GAV];
-  const servicePath = parameters[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.SERVICE_PATH];
+  const gav = guaranteeNonNullable(
+    parameters[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.GAV],
+  );
+  const servicePath = guaranteeNonNullable(
+    parameters[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.SERVICE_PATH],
+  );
   const executionKey =
     applicationStore.navigationService.navigator.getCurrentLocationParameterValue(
       LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY,
@@ -859,9 +867,15 @@ export const ServiceQueryCreator = observer(() => {
 
 export const MappingQueryCreator = observer(() => {
   const params = useParams<MappingQueryCreatorPathParams>();
-  const gav = params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.GAV];
-  const mappingPath = params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.MAPPING_PATH];
-  const runtimePath = params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.RUNTIME_PATH];
+  const gav = guaranteeNonNullable(
+    params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.GAV],
+  );
+  const mappingPath = guaranteeNonNullable(
+    params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.MAPPING_PATH],
+  );
+  const runtimePath = guaranteeNonNullable(
+    params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.RUNTIME_PATH],
+  );
 
   return (
     <MappingQueryCreatorStoreProvider

package/src/components/QueryEdtiorExistingQueryVersionRevertModal.tsx

@@ -49,9 +49,7 @@ export const QueryEditorExistingQueryVersionRevertModal = observer(
     const selectedVersionOption = queryVersion
       ? buildVersionOption(queryVersion)
       : null;
-    const onVersionOptionChange = async (
-      option: VersionOption | null,
-    ): Promise<void> => {
+    const onVersionOptionChange = (option: VersionOption | null) => {
       if (option?.value && option.value !== queryVersion) {
         setQueryVersion(option.value);
       }

package/src/components/UpdateExistingServiceQuerySetup.tsx

@@ -131,7 +131,7 @@ const UpdateExistingServiceQuerySetupContent = observer(() => {
             <SearchIcon />
           </div>
           <CustomSelectorInput
-            ref={serviceSearchRef}
+            inputRef={serviceSearchRef}
             className="query-setup__wizard__selector"
             options={serviceOptions}
             isLoading={setupStore.loadServicesState.isInProgress}

package/src/components/__test-utils__/QueryEditorComponentTestUtils.tsx

@@ -44,6 +44,11 @@ import {
 import { LegendQueryFrameworkProvider } from '../LegendQueryFrameworkProvider.js';
 import { TEST__BrowserEnvironmentProvider } from '@finos/legend-application/test';
 import { Core_LegendQueryApplicationPlugin } from '../Core_LegendQueryApplicationPlugin.js';
+import { Route, Routes } from '@finos/legend-application/browser';
+import {
+  generateExistingQueryEditorRoute,
+  LEGEND_QUERY_ROUTE_PATTERN,
+} from '../../__lib__/LegendQueryNavigation.js';
 
 const TEST_QUERY_ID = 'test-query-id';
 export const TEST_QUERY_NAME = 'MyTestQuery';
@@ -170,9 +175,16 @@ export const TEST__setUpQueryEditor = async (
 
   const renderResult = render(
     <ApplicationStoreProvider store={MOCK__editorStore.applicationStore}>
-      <TEST__BrowserEnvironmentProvider>
+      <TEST__BrowserEnvironmentProvider
+        initialEntries={[generateExistingQueryEditorRoute(lightQuery.id)]}
+      >
         <LegendQueryFrameworkProvider>
-          <ExistingQueryEditor />
+          <Routes>
+            <Route
+              path={LEGEND_QUERY_ROUTE_PATTERN.EDIT_EXISTING_QUERY}
+              element={<ExistingQueryEditor />}
+            />
+          </Routes>
         </LegendQueryFrameworkProvider>
       </TEST__BrowserEnvironmentProvider>
     </ApplicationStoreProvider>,

package/src/components/data-cube/ExistingQueryDataCubeViewer.tsx

@@ -0,0 +1,67 @@
+/**
+ * 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 { useApplicationStore } from '@finos/legend-application';
+import { observer } from 'mobx-react-lite';
+import {
+  LEGEND_QUERY_ROUTE_PATTERN_TOKEN,
+  type ExistingQueryEditorPathParams,
+} from '../../__lib__/LegendQueryNavigation.js';
+import { useParams } from '@finos/legend-application/browser';
+import {
+  ExistingQueryDataCubeEditorStoreProvider,
+  useExistingQueryDataCubeEditorStore,
+} from './ExistingQueryEditorStoreProviderProvider.js';
+import { useEffect } from 'react';
+import { flowResult } from 'mobx';
+import { DataCube, DataCubeProvider } from '@finos/legend-data-cube';
+import { QueryBuilderDataCubeApplicationEngine } from '@finos/legend-query-builder';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export const DataCubeWrapper = observer(() => {
+  const applicationStore = useApplicationStore();
+  const store = useExistingQueryDataCubeEditorStore();
+
+  useEffect(() => {
+    flowResult(store.initialize()).catch(applicationStore.alertUnhandledError);
+  }, [applicationStore, store]);
+
+  if (!store.engine) {
+    return null;
+  }
+  const _appEngine = new QueryBuilderDataCubeApplicationEngine(
+    applicationStore,
+  );
+
+  return (
+    <DataCubeProvider application={_appEngine} engine={store.engine}>
+      <DataCube />
+    </DataCubeProvider>
+  );
+});
+
+export const ExistingQueryDataCubeViewer = observer(() => {
+  const params = useParams<ExistingQueryEditorPathParams>();
+  const queryId = guaranteeNonNullable(
+    params[LEGEND_QUERY_ROUTE_PATTERN_TOKEN.QUERY_ID],
+  );
+
+  return (
+    <ExistingQueryDataCubeEditorStoreProvider queryId={queryId}>
+      <DataCubeWrapper />
+    </ExistingQueryDataCubeEditorStoreProvider>
+  );
+});

package/src/components/data-cube/ExistingQueryEditorStoreProviderProvider.tsx

@@ -0,0 +1,56 @@
+/**
+ * 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 { createContext, useContext } from 'react';
+import { useLocalObservable } from 'mobx-react-lite';
+import { ExistingQueryDataCubeEditorStore } from '../../stores/data-cube/ExistingQueryDataCubeViewer.js';
+import {
+  useLegendQueryApplicationStore,
+  useLegendQueryBaseStore,
+} from '../LegendQueryFrameworkProvider.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export const ExistingQueryDataCubeEditorStoreContext = createContext<
+  ExistingQueryDataCubeEditorStore | undefined
+>(undefined);
+
+export const ExistingQueryDataCubeEditorStoreProvider: React.FC<{
+  children: React.ReactNode;
+  queryId: string;
+}> = ({ children, queryId }) => {
+  const applicationStore = useLegendQueryApplicationStore();
+  const baseStore = useLegendQueryBaseStore();
+  const store = useLocalObservable(
+    () =>
+      new ExistingQueryDataCubeEditorStore(
+        applicationStore,
+        baseStore.depotServerClient,
+        queryId,
+      ),
+  );
+  return (
+    <ExistingQueryDataCubeEditorStoreContext.Provider value={store}>
+      {children}
+    </ExistingQueryDataCubeEditorStoreContext.Provider>
+  );
+};
+
+export const useExistingQueryDataCubeEditorStore =
+  (): ExistingQueryDataCubeEditorStore =>
+    guaranteeNonNullable(
+      useContext(ExistingQueryDataCubeEditorStoreContext),
+      `Can't find query editor store in context`,
+    );

package/src/components/data-space/DataSpaceQueryCreator.tsx

@@ -88,14 +88,12 @@ const DataSpaceQueryCreatorStoreProvider: React.FC<{
 
 export const DataSpaceQueryCreator = observer(() => {
   const applicationStore = useApplicationStore();
-  const parameters = useParams<DataSpaceQueryCreatorPathParams | undefined>();
-  const gav = parameters?.[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV];
+  const parameters = useParams<DataSpaceQueryCreatorPathParams>();
+  const gav = parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV];
   const dataSpacePath =
-    parameters?.[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.DATA_SPACE_PATH];
+    parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.DATA_SPACE_PATH];
   const executionContext =
-    parameters?.[
-      DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.EXECUTION_CONTEXT
-    ];
+    parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.EXECUTION_CONTEXT];
   const runtimePath =
     applicationStore.navigationService.navigator.getCurrentLocationParameterValue(
       DATA_SPACE_QUERY_CREATOR_QUERY_PARAM_TOKEN.RUNTIME_PATH,

package/src/components/data-space/DataSpaceQuerySetup.tsx

@@ -82,7 +82,7 @@ const DataSpaceQuerySetupSetupPanelContent = observer(
             </label>
             <CustomSelectorInput
               inputId="query-builder__setup__data-space-selector"
-              ref={dataSpaceSearchRef}
+              inputRef={dataSpaceSearchRef}
               className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
               options={dataSpaceOptions}
               isLoading={queryBuilderState.loadDataSpacesState.isInProgress}

package/src/components/data-space/DataSpaceTemplateQueryCreator.tsx

@@ -28,6 +28,7 @@ import {
   type DataSpaceTemplateQueryCreatorPathParams,
 } from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import { QueryEditor } from '../QueryEditor.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
 
 const DataSpaceTemplateQueryCreatorStoreProvider: React.FC<{
   children: React.ReactNode;
@@ -59,16 +60,19 @@ const DataSpaceTemplateQueryCreatorStoreProvider: React.FC<{
 
 export const DataSpaceTemplateQueryCreator = observer(() => {
   const parameters = useParams<DataSpaceTemplateQueryCreatorPathParams>();
-  const gav =
-    parameters[DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV];
-  const dataSpacePath =
+  const gav = guaranteeNonNullable(
+    parameters[DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV],
+  );
+  const dataSpacePath = guaranteeNonNullable(
     parameters[
       DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.DATA_SPACE_PATH
-    ];
-  const templateQueryId =
+    ],
+  );
+  const templateQueryId = guaranteeNonNullable(
     parameters[
       DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.TEMPLATE_QUERY_ID
-    ];
+    ],
+  );
 
   return (
     <DataSpaceTemplateQueryCreatorStoreProvider

package/src/stores/data-cube/ExistingQueryDataCubeViewer.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 { DepotServerClient } from '@finos/legend-server-depot';
+import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
+import {
+  GraphManagerState,
+  type RawLambda,
+  type QueryInfo,
+} from '@finos/legend-graph';
+import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
+import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
+import { QueryBuilderDataCubeEngine } from '@finos/legend-query-builder';
+
+export class ExistingQueryDataCubeEditorStore {
+  readonly applicationStore: LegendQueryApplicationStore;
+  readonly depotServerClient: DepotServerClient;
+  readonly graphManagerState: GraphManagerState;
+  readonly queryId: string;
+  engine: QueryBuilderDataCubeEngine | undefined;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+    queryId: string,
+  ) {
+    this.applicationStore = applicationStore;
+    this.depotServerClient = depotServerClient;
+    this.graphManagerState = new GraphManagerState(
+      applicationStore.pluginManager,
+      applicationStore.logService,
+    );
+    this.queryId = queryId;
+  }
+
+  *initialize(): GeneratorFn<void> {
+    try {
+      // initialize the graph manager
+      yield this.graphManagerState.graphManager.initialize(
+        {
+          env: this.applicationStore.config.env,
+          tabSize: DEFAULT_TAB_SIZE,
+          clientConfig: {
+            baseUrl: this.applicationStore.config.engineServerUrl,
+            queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
+            enableCompression: true,
+          },
+        },
+        {
+          tracerService: this.applicationStore.tracerService,
+        },
+      );
+      const queryInfo = (yield this.graphManagerState.graphManager.getQueryInfo(
+        this.queryId,
+      )) as unknown as QueryInfo;
+      const content = queryInfo.content;
+      const execConext =
+        (yield this.graphManagerState.graphManager.resolveQueryInfoExecutionContext(
+          queryInfo,
+          () =>
+            this.depotServerClient.getVersionEntities(
+              queryInfo.groupId,
+              queryInfo.artifactId,
+              queryInfo.versionId,
+            ),
+        )) as { mapping: string | undefined; runtime: string };
+      const lambda =
+        (yield this.graphManagerState.graphManager.pureCodeToLambda(
+          content,
+        )) as unknown as RawLambda;
+      const engine = new QueryBuilderDataCubeEngine(
+        lambda,
+        execConext.mapping,
+        execConext.runtime,
+        this.graphManagerState,
+      );
+      this.engine = engine;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(
+        `Unable to initialize cube with query ${this.queryId}: ${error.message}`,
+      );
+    }
+  }
+}

package/tsconfig.json

@@ -73,6 +73,7 @@
     "./src/stores/QuerySetupStore.ts",
     "./src/stores/UpdateExistingServiceQuerySetupStore.ts",
     "./src/stores/__test-utils__/LegendQueryApplicationTestUtils.ts",
+    "./src/stores/data-cube/ExistingQueryDataCubeViewer.ts",
     "./src/stores/data-space/DataSpaceQueryBuilderHelper.ts",
     "./src/stores/data-space/DataSpaceQueryCreatorStore.ts",
     "./src/stores/data-space/DataSpaceQuerySetupState.ts",
@@ -93,6 +94,8 @@
     "./src/components/QuerySetup.tsx",
     "./src/components/UpdateExistingServiceQuerySetup.tsx",
     "./src/components/__test-utils__/QueryEditorComponentTestUtils.tsx",
+    "./src/components/data-cube/ExistingQueryDataCubeViewer.tsx",
+    "./src/components/data-cube/ExistingQueryEditorStoreProviderProvider.tsx",
     "./src/components/data-space/DataSpaceInfo.tsx",
     "./src/components/data-space/DataSpaceQueryCreator.tsx",
     "./src/components/data-space/DataSpaceQuerySetup.tsx",