@finos/legend-application-data-cube 0.2.0 → 0.2.2

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -16,7 +16,7 @@
 
 import {
   V1_Lambda,
-  V1_ValueSpecification,
+  type V1_ValueSpecification,
   type V1_EngineServerClient,
   V1_PureGraphManager,
   type V1_PureModelContext,
@@ -70,7 +70,8 @@ import {
   V1_Table,
   V1_TestAuthenticationStrategy,
   V1_VarChar,
-  type TDSBuilder,
+  PackageableElementPointerType,
+  DatabaseType,
 } from '@finos/legend-graph';
 import {
   _elementPtr,
@@ -79,17 +80,13 @@ import {
   type CompletionItem,
   _function,
   DataCubeFunction,
-  _deserializeLambda,
   AdhocQueryDataCubeSource,
   ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE,
   RawAdhocQueryDataCubeSource,
   _lambda,
-  _serializeValueSpecification,
-  _deserializeValueSpecification,
   _defaultPrimitiveTypeValue,
   type DataCubeExecutionOptions,
   CachedDataCubeSource,
-  type DataCubeQuerySnapshot,
 } from '@finos/legend-data-cube';
 import {
   isNonNullable,
@@ -102,10 +99,11 @@ import {
   at,
   assertType,
   guaranteeType,
-  assertNonNullable,
+  guaranteeNonNullable,
+  filterByType,
 } from '@finos/legend-shared';
 import type { LegendDataCubeApplicationStore } from './LegendDataCubeBaseStore.js';
-import { LegendDataCubeDataCubeCacheEngine } from './LegendDataCubeCacheManager.js';
+import { LegendDataCubeDataCubeCacheManager } from './LegendDataCubeCacheManager.js';
 import { APPLICATION_EVENT } from '@finos/legend-application';
 import {
   LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE,
@@ -123,7 +121,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   private readonly _depotServerClient: DepotServerClient;
   private readonly _engineServerClient: V1_EngineServerClient;
   private readonly _graphManager: V1_PureGraphManager;
-  private readonly _cacheManager: LegendDataCubeDataCubeCacheEngine;
+  private readonly _cacheManager: LegendDataCubeDataCubeCacheManager;
 
   constructor(
     application: LegendDataCubeApplicationStore,
@@ -137,7 +135,15 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     this._depotServerClient = depotServerClient;
     this._engineServerClient = engineServerClient;
     this._graphManager = graphManager;
-    this._cacheManager = new LegendDataCubeDataCubeCacheEngine();
+    this._cacheManager = new LegendDataCubeDataCubeCacheManager();
+  }
+
+  async initializeCacheManager() {
+    await this._cacheManager.initialize();
+  }
+
+  async disposeCacheManager() {
+    await this._cacheManager.dispose();
   }
 
   // ---------------------------------- IMPLEMENTATION ----------------------------------
@@ -159,7 +165,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         try {
           source.columns = (
             await this._getLambdaRelationType(
-              _serializeValueSpecification(_lambda([], [source.query])),
+              this.serializeValueSpecification(_lambda([], [source.query])),
               source.model,
             )
           ).columns;
@@ -189,14 +195,18 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           );
         const source = new LegendQueryDataCubeSource();
         source.info = queryInfo;
-        source.lambda = _deserializeLambda(
-          await this._engineServerClient.grammarToJSON_lambda(
-            queryInfo.content,
-            '',
-            undefined,
-            undefined,
-            false,
+
+        source.lambda = guaranteeType(
+          this.deserializeValueSpecification(
+            await this._engineServerClient.grammarToJSON_lambda(
+              queryInfo.content,
+              '',
+              undefined,
+              undefined,
+              false,
+            ),
           ),
+          V1_Lambda,
         );
         source.mapping = executionContext.mapping;
         source.runtime = executionContext.runtime;
@@ -215,18 +225,22 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           ),
         );
         source.query = at(source.lambda.body, 0);
+        // use the default parameter values from the query
+        //
+        // TODO?: we should probably allow configuring the parameters?
+        // this would mean we need to create first-class support for parameters in DataCube component
         const parameterValues = await Promise.all(
           source.lambda.parameters.map(async (parameter) => {
             if (parameter.genericType?.rawType instanceof V1_PackageableType) {
               const paramValue = new V1_ParameterValue();
               paramValue.name = parameter.name;
               const type = parameter.genericType.rawType.fullPath;
-              const defauleValue = queryInfo.defaultParameterValues?.find(
+              const defaultValue = queryInfo.defaultParameterValues?.find(
                 (val) => val.name === parameter.name,
               )?.content;
               paramValue.value =
-                defauleValue !== undefined
-                  ? await this.parseValueSpecification(defauleValue)
+                defaultValue !== undefined
+                  ? await this.parseValueSpecification(defaultValue)
                   : {
                       _type: V1_deserializeRawValueSpecificationType(type),
                       value: _defaultPrimitiveTypeValue(type),
@@ -240,7 +254,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         try {
           source.columns = (
             await this._getLambdaRelationType(
-              _serializeValueSpecification(source.lambda),
+              this.serializeValueSpecification(source.lambda),
               source.model,
             )
           ).columns;
@@ -264,7 +278,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     returnSourceInformation?: boolean | undefined,
   ) {
     try {
-      return _deserializeValueSpecification(
+      return this.deserializeValueSpecification(
         await this._engineServerClient.grammarToJSON_valueSpecification(
           code,
           '',
@@ -294,7 +308,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     pretty?: boolean | undefined,
   ) {
     return this._graphManager.valueSpecificationToPureCode(
-      _serializeValueSpecification(value),
+      this.serializeValueSpecification(value),
       pretty,
     );
   }
@@ -337,7 +351,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ) {
     try {
       return await this._getQueryRelationType(
-        _serializeValueSpecification(query),
+        this.serializeValueSpecification(query),
         source,
       );
     } catch (error) {
@@ -415,32 +429,26 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         options,
       );
     } else if (source instanceof CachedDataCubeSource) {
-      //execute plan
+      // get the execute plan to extract the generated SQL to run against cached DB
       const executionPlan = await this.generateExecutionPlan(
         query,
         source.model,
         [],
         options,
       );
-      let sql;
-      if (executionPlan instanceof V1_SimpleExecutionPlan) {
-        sql = executionPlan.rootExecutionNode.executionNodes
-          .filter((node) => node instanceof V1_SQLExecutionNode)
-          .map((x) =>
-            guaranteeType(
-              x,
-              V1_SQLExecutionNode,
-              `Can't generate sql for the query`,
-            ),
-          )
-          .at(-1)?.sqlQuery;
-      }
-      assertNonNullable(sql, `Can't generate sql for the query`);
+      const sql = guaranteeNonNullable(
+        executionPlan instanceof V1_SimpleExecutionPlan
+          ? executionPlan.rootExecutionNode.executionNodes
+              .filter(filterByType(V1_SQLExecutionNode))
+              .at(-1)?.sqlQuery
+          : undefined,
+        `Can't process execution plan: failed to extract generated SQL`,
+      );
       const endTime = performance.now();
       return {
         executedQuery: await queryCodePromise,
         executedSQL: sql,
-        result: await this._cacheManager.runQuery(sql),
+        result: await this._cacheManager.runSQLQuery(sql),
         executionTime: endTime - startTime,
       };
     } else {
@@ -451,17 +459,16 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     assertType(
       result,
       TDSExecutionResult,
-      `Can't extract execution result: expected tabular data set format`,
+      `Can't process execution result: expected tabular data set format`,
     );
     const endTime = performance.now();
     const queryCode = await queryCodePromise;
-    const sql =
+    const sql = guaranteeNonNullable(
       result.activities?.[0] instanceof RelationalExecutionActivities
         ? result.activities[0].sql
-        : undefined;
-    if (!sql) {
-      throw new Error(`Can't generate SQL for query`);
-    }
+        : undefined,
+      `Can't process execution result: failed to extract generated SQL`,
+    );
     return {
       result: result,
       executedQuery: queryCode,
@@ -493,16 +500,6 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     return undefined;
   }
 
-  override processInitialSnapshot(
-    source: DataCubeSource,
-    snapshot: DataCubeQuerySnapshot,
-  ): DataCubeQuerySnapshot {
-    if (source instanceof LegendQueryDataCubeSource) {
-      snapshot.data.configuration.name = source.info.name;
-    }
-    return snapshot;
-  }
-
   // ---------------------------------- UTILITIES ----------------------------------
 
   private async _getQueryRelationType(
@@ -555,7 +552,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
             (process.env.NODE_ENV === 'development'
               ? PureClientVersion.VX_X_X
               : undefined),
-          function: _serializeValueSpecification(query),
+          function: this.serializeValueSpecification(query),
           model,
           context: serialize(
             V1_rawBaseExecutionContextModelSchema,
@@ -577,13 +574,8 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ): Promise<V1_ExecutionPlan> {
     return V1_deserializeExecutionPlan(
       await this._engineServerClient.generatePlan({
-        clientVersion:
-          options?.clientVersion ??
-          // eslint-disable-next-line no-process-env
-          (process.env.NODE_ENV === 'development'
-            ? PureClientVersion.VX_X_X
-            : undefined),
-        function: _serializeValueSpecification(query),
+        clientVersion: PureClientVersion.VX_X_X,
+        function: this.serializeValueSpecification(query),
         model: serialize(model),
         context: serialize(
           V1_rawBaseExecutionContextModelSchema,
@@ -601,110 +593,92 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   override async initializeCache(
     source: DataCubeSource,
   ): Promise<CachedDataCubeSource | undefined> {
-    if (source instanceof LegendQueryDataCubeSource) {
-      const fromQuery = this.buildExecutionContext(source);
-      fromQuery?.parameters.unshift(source.query);
-      const valSpec = guaranteeType(
-        fromQuery,
-        V1_ValueSpecification,
-        'Query is not a valueSpecification',
-      );
-      const queryLambda = new V1_Lambda();
-      queryLambda.body = [valSpec];
-      const resultQuery = await this.executeQuery(
-        queryLambda,
-        source,
-        undefined,
-      );
-      const result = resultQuery.result;
-      await this._cacheManager.initializeDuckDb(result);
-      return this._synthesizeCachedSource(source, result.builder);
-    }
-    return undefined;
-  }
-
-  override async clearCache() {
-    await this._cacheManager.clearDuckDb();
-  }
-
-  // --------------------------------- CACHING UTILITY -------------------------------
-
-  private _synthesizeCachedSource(
-    source: LegendQueryDataCubeSource,
-    builder: TDSBuilder,
-  ) {
-    const cachedSource = new CachedDataCubeSource();
-    cachedSource.columns = source.columns;
-    cachedSource.query = this._synthesizeQuery([
-      'local::duckdb::cachedStore',
-      'main',
-      'cached_tbl',
-    ]);
-    cachedSource.model = this._synthesizeModel(builder);
-    cachedSource.runtime = 'local::duckdb::runtime';
-    return cachedSource;
-  }
+    const cacheQuery = guaranteeNonNullable(
+      this.buildExecutionContext(source),
+      `Can't initialize cache: failed to build cache query`,
+    );
+    cacheQuery.parameters.unshift(source.query);
+    const result = await this.executeQuery(
+      _lambda([], [cacheQuery]),
+      source,
+      undefined,
+    );
+    const {
+      schema: schemaName,
+      table: tableName,
+      rowCount,
+    } = await this._cacheManager.cache(result.result);
 
-  private _synthesizeQuery(databaseAccessor: string[]) {
-    const classInstance = new V1_ClassInstance();
-    classInstance.type = V1_ClassInstanceType.RELATION_STORE_ACCESSOR;
-    const storeAccessor = new V1_RelationStoreAccessor();
-    storeAccessor.path = databaseAccessor;
-    classInstance.value = storeAccessor;
-    return classInstance;
-  }
+    // model
+    const pacakgePath = 'local';
 
-  private _synthesizeModel(builder: TDSBuilder) {
-    // synthesize table
     const table = new V1_Table();
-    table.name = 'cached_tbl';
-    table.columns = builder.columns.map((col) => {
+    table.name = tableName;
+    table.columns = result.result.builder.columns.map((col) => {
       const column = new V1_Column();
       column.name = col.name;
       column.type = this._getColumnType(col.type);
       return column;
     });
-    // synthesize schema
+
     const schema = new V1_Schema();
-    schema.name = 'main';
+    schema.name = schemaName;
     schema.tables = [table];
-    // synthesize database
     const database = new V1_Database();
-    database.name = 'cachedStore';
-    database.package = 'local::duckdb';
+    database.name = 'db';
+    database.package = pacakgePath;
     database.schemas = [schema];
 
-    // build connection
     const connection = new V1_RelationalDatabaseConnection();
-    connection.databaseType = 'DuckDB';
-    connection.type = 'DuckDB';
+    connection.databaseType = DatabaseType.DuckDB;
+    connection.type = DatabaseType.DuckDB;
     const dataSourceSpec = new V1_DuckDBDatasourceSpecification();
-    dataSourceSpec.path = '/temp/path';
-    connection.store = 'local::duckdb::cachedStore';
+    dataSourceSpec.path = '/tmpFile';
+    connection.store = database.path;
     connection.datasourceSpecification = dataSourceSpec;
     connection.authenticationStrategy = new V1_TestAuthenticationStrategy();
 
-    // build runtime
     const runtime = new V1_EngineRuntime();
     const storeConnections = new V1_StoreConnections();
     storeConnections.store = new V1_PackageableElementPointer(
-      'STORE',
-      `${database.package}::${database.name}`,
+      PackageableElementPointerType.STORE,
+      database.path,
     );
-    const idConnection = new V1_IdentifiedConnection();
-    idConnection.connection = connection;
-    idConnection.id = 'local_duckdb_connection';
-    storeConnections.storeConnections = [idConnection];
+    const identifiedConnection = new V1_IdentifiedConnection();
+    identifiedConnection.connection = connection;
+    identifiedConnection.id = 'c0';
+    storeConnections.storeConnections = [identifiedConnection];
     runtime.connections = [storeConnections];
 
     const packageableRuntime = new V1_PackageableRuntime();
     packageableRuntime.runtimeValue = runtime;
-    packageableRuntime.package = 'local::duckdb';
-    packageableRuntime.name = 'runtime';
+    packageableRuntime.package = pacakgePath;
+    packageableRuntime.name = 'rt';
+
+    const model = new V1_PureModelContextData();
+    model.elements = [database, packageableRuntime];
+
+    // query
+    const query = new V1_ClassInstance();
+    query.type = V1_ClassInstanceType.RELATION_STORE_ACCESSOR;
+    const storeAccessor = new V1_RelationStoreAccessor();
+    storeAccessor.path = [database.path, schema.name, table.name];
+    query.value = storeAccessor;
+
+    const cachedSource = new CachedDataCubeSource();
+    cachedSource.columns = source.columns;
+    cachedSource.query = query;
+    cachedSource.model = model;
+    cachedSource.runtime = packageableRuntime.path;
+    cachedSource.db = database.path;
+    cachedSource.schema = schema.name;
+    cachedSource.table = table.name;
+    cachedSource.count = rowCount;
+    return cachedSource;
+  }
 
-    const pmcd = new V1_PureModelContextData();
-    pmcd.elements = [database, packageableRuntime];
-    return pmcd;
+  override async disposeCache(source: CachedDataCubeSource) {
+    await this._cacheManager.disposeCache(source);
   }
 
   // TODO: need a better way to infer datatype from tds builder

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

@@ -29,9 +29,7 @@ import {
   type LegendDataCubeSourceBuilderState,
 } from './source-builder/LegendDataCubeSourceBuilderState.js';
 import {
-  _selectFunction,
   type DataCubeAlertService,
-  DataCubeQuery,
   DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
   type DisplayState,
 } from '@finos/legend-data-cube';
@@ -44,6 +42,8 @@ import {
 } from './LegendDataCubeQueryBuilderStore.js';
 import { generateQueryBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
 
+const DEFAULT_SOURCE_TYPE = LegendDataCubeSourceBuilderType.LEGEND_QUERY;
+
 export class LegendDataCubeNewQueryState {
   private readonly _application: LegendDataCubeApplicationStore;
   private readonly _store: LegendDataCubeQueryBuilderStore;
@@ -76,9 +76,7 @@ export class LegendDataCubeNewQueryState {
       },
     );
 
-    this.sourceBuilder = this.createSourceBuilder(
-      LegendDataCubeSourceBuilderType.LEGEND_QUERY,
-    );
+    this.sourceBuilder = this.createSourceBuilder(DEFAULT_SOURCE_TYPE);
   }
 
   changeSourceBuilder(
@@ -115,31 +113,27 @@ export class LegendDataCubeNewQueryState {
   }
 
   async finalize(sourceData?: PlainObject) {
-    if (!this.sourceBuilder.isValid && !sourceData) {
+    if (!sourceData && !this.sourceBuilder.isValid) {
       throw new IllegalStateError(`Can't generate query: source is not valid`);
     }
 
     this.finalizeState.inProgress();
     try {
-      const source = sourceData ?? (await this.sourceBuilder.build());
-      const query = new DataCubeQuery();
-      const processedSource = await this._engine.processQuerySource(source);
-      query.source = source;
-      query.query = await this._engine.getValueSpecificationCode(
-        _selectFunction(processedSource.columns),
+      const query = await this._engine.generateBaseQuery(
+        sourceData ?? (await this.sourceBuilder.generateSourceData()),
       );
+      if (query.configuration) {
+        this.sourceBuilder.finalizeConfiguration(query.configuration);
+      }
+
+      // reset
       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(
         generateQueryBuilderRoute(null),
       );
-
-      // reset
-      this.changeSourceBuilder(
-        LegendDataCubeSourceBuilderType.LEGEND_QUERY,
-        true,
-      );
+      this.changeSourceBuilder(DEFAULT_SOURCE_TYPE, true);
       this.display.close();
       this.finalizeState.pass();
     } catch (error) {

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

@@ -43,7 +43,10 @@ import {
 } from '@finos/legend-shared';
 import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
 import { LegendDataCubeQuerySaver } from '../../components/query-builder/LegendDataCubeQuerySaver.js';
-import { generateQueryBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
+import {
+  generateQueryBuilderRoute,
+  LEGEND_DATA_CUBE_ROUTE_PATTERN_TOKEN,
+} from '../../__lib__/LegendDataCubeNavigation.js';
 import { LegendDataCubeQueryLoaderState } from './LegendDataCubeQueryLoaderState.js';
 import {
   LegendDataCubeUserDataKey,
@@ -68,7 +71,6 @@ export class LegendDataCubeQueryBuilderState {
 
       query: observable,
       persistentQuery: observable,
-      setPersistentQuery: action,
     });
 
     this.query = query;
@@ -78,12 +80,6 @@ export class LegendDataCubeQueryBuilderState {
   setDataCube(val: DataCubeAPI | undefined) {
     this.dataCube = val;
   }
-
-  setPersistentQuery(val: PersistentDataCubeQuery) {
-    this.persistentQuery = val;
-    this.query = DataCubeQuery.serialization.fromJson(val.content);
-    this.startTime = Date.now();
-  }
 }
 
 export class LegendDataCubeQueryBuilderStore {
@@ -154,9 +150,31 @@ export class LegendDataCubeQueryBuilderStore {
   }
 
   async loadQuery(queryId: string | undefined) {
+    // internalize the parameters and clean them from the URL
+    const sourceData =
+      this.application.navigationService.navigator.getCurrentLocationParameterValue(
+        LEGEND_DATA_CUBE_ROUTE_PATTERN_TOKEN.SOURCE_DATA,
+      );
+    if (sourceData && !queryId) {
+      this.application.navigationService.navigator.updateCurrentLocation(
+        generateQueryBuilderRoute(null),
+      );
+      // populate the new query state if source data is specified
+      try {
+        await this.newQueryState.finalize(JSON.parse(atob(sourceData)));
+      } catch (error) {
+        assertErrorThrown(error);
+        this.alertService.alertError(error, {
+          message: `Query Creation Failure: Can't materialize query source from source data. Error: ${error.message}`,
+        });
+        this.setBuilder(undefined);
+      }
+    }
+
     if (queryId !== this.builder?.persistentQuery?.id) {
       if (!queryId) {
         this.setBuilder(undefined);
+        this.loader.display.open();
         return;
       }
 
@@ -244,7 +262,6 @@ export class LegendDataCubeQueryBuilderStore {
       this.application.navigationService.navigator.updateCurrentLocation(
         generateQueryBuilderRoute(newQuery.id),
       );
-      this.builder.setPersistentQuery(persistentQuery);
       this.updateWindowTitle(persistentQuery);
 
       this.saverDisplay.close();
@@ -291,7 +308,6 @@ export class LegendDataCubeQueryBuilderStore {
       } else {
         await this.baseStore.graphManager.updateDataCubeQuery(persistentQuery);
       }
-      this.builder.setPersistentQuery(persistentQuery);
       this.updateWindowTitle(persistentQuery);
 
       this.saverDisplay.close();

package/src/stores/query-builder/source-builder/AdhocQueryDataCubeSourceBuilderState.ts

@@ -29,7 +29,7 @@ export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBu
     return false;
   }
 
-  override build(): Promise<PlainObject> {
+  override generateSourceData(): Promise<PlainObject> {
     throw new Error('Method not implemented.');
   }
 }

package/src/stores/query-builder/source-builder/LegendDataCubeSourceBuilderState.ts

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-import { ActionState, type PlainObject } from '@finos/legend-shared';
+import { type PlainObject } from '@finos/legend-shared';
 import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
 import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
+import type { DataCubeConfiguration } from '@finos/legend-data-cube';
 
 export enum LegendDataCubeSourceBuilderType {
   LEGEND_QUERY = 'Legend Query',
@@ -27,8 +28,6 @@ export abstract class LegendDataCubeSourceBuilderState {
   protected readonly _application: LegendDataCubeApplicationStore;
   protected readonly _engine: LegendDataCubeDataCubeEngine;
 
-  readonly buildState = ActionState.create();
-
   constructor(
     application: LegendDataCubeApplicationStore,
     engine: LegendDataCubeDataCubeEngine,
@@ -39,5 +38,10 @@ export abstract class LegendDataCubeSourceBuilderState {
 
   abstract get label(): LegendDataCubeSourceBuilderType;
   abstract get isValid(): boolean;
-  abstract build(): Promise<PlainObject>;
+  abstract generateSourceData(): Promise<PlainObject>;
+
+  /* Modifies the configuration of the finalized DataCube query based on the source builder */
+  finalizeConfiguration(configuration: DataCubeConfiguration) {
+    // do nothing
+  }
 }

package/src/stores/query-builder/source-builder/LegendQueryDataCubeSourceBuilderState.ts

@@ -39,7 +39,10 @@ import { RawLegendQueryDataCubeSource } from '../../model/LegendQueryDataCubeSou
 import { APPLICATION_EVENT } from '@finos/legend-application';
 import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
 import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
-import type { DataCubeAlertService } from '@finos/legend-data-cube';
+import type {
+  DataCubeAlertService,
+  DataCubeConfiguration,
+} from '@finos/legend-data-cube';
 
 export class LegendQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
   private readonly _engineServerClient: V1_EngineServerClient;
@@ -132,7 +135,7 @@ export class LegendQueryDataCubeSourceBuilderState extends LegendDataCubeSourceB
     return Boolean(this.query);
   }
 
-  override async build() {
+  override async generateSourceData() {
     if (!this.query) {
       throw new IllegalStateError('Query is missing');
     }
@@ -140,4 +143,10 @@ export class LegendQueryDataCubeSourceBuilderState extends LegendDataCubeSourceB
     source.queryId = this.query.id;
     return RawLegendQueryDataCubeSource.serialization.toJson(source);
   }
+
+  override finalizeConfiguration(configuration: DataCubeConfiguration) {
+    if (this.query) {
+      configuration.name = this.query.name;
+    }
+  }
 }