@finos/legend-application-data-cube 0.1.21 → 0.2.1

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -15,7 +15,7 @@
  */
 
 import {
-  type V1_Lambda,
+  V1_Lambda,
   type V1_ValueSpecification,
   type V1_EngineServerClient,
   V1_PureGraphManager,
@@ -44,6 +44,34 @@ import {
   V1_PackageableType,
   V1_deserializeRawValueSpecificationType,
   V1_Protocol,
+  type V1_ExecutionPlan,
+  V1_deserializeExecutionPlan,
+  V1_SQLExecutionNode,
+  V1_SimpleExecutionPlan,
+  V1_Binary,
+  V1_ClassInstance,
+  V1_ClassInstanceType,
+  V1_Column,
+  V1_Database,
+  V1_Date,
+  V1_Double,
+  V1_DuckDBDatasourceSpecification,
+  V1_EngineRuntime,
+  V1_IdentifiedConnection,
+  V1_Integer,
+  V1_PackageableElementPointer,
+  V1_PackageableRuntime,
+  V1_PureModelContextData,
+  V1_RelationStoreAccessor,
+  type V1_RelationalDataType,
+  V1_RelationalDatabaseConnection,
+  V1_Schema,
+  V1_StoreConnections,
+  V1_Table,
+  V1_TestAuthenticationStrategy,
+  V1_VarChar,
+  PackageableElementPointerType,
+  DatabaseType,
 } from '@finos/legend-graph';
 import {
   _elementPtr,
@@ -52,15 +80,13 @@ import {
   type CompletionItem,
   _function,
   DataCubeFunction,
-  _deserializeLambda,
   AdhocQueryDataCubeSource,
   ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE,
   RawAdhocQueryDataCubeSource,
   _lambda,
-  _serializeValueSpecification,
-  _deserializeValueSpecification,
   _defaultPrimitiveTypeValue,
   type DataCubeExecutionOptions,
+  CachedDataCubeSource,
 } from '@finos/legend-data-cube';
 import {
   isNonNullable,
@@ -72,8 +98,12 @@ import {
   HttpStatus,
   at,
   assertType,
+  guaranteeType,
+  guaranteeNonNullable,
+  filterByType,
 } from '@finos/legend-shared';
 import type { LegendDataCubeApplicationStore } from './LegendDataCubeBaseStore.js';
+import { LegendDataCubeDataCubeCacheManager } from './LegendDataCubeCacheManager.js';
 import { APPLICATION_EVENT } from '@finos/legend-application';
 import {
   LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE,
@@ -91,6 +121,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   private readonly _depotServerClient: DepotServerClient;
   private readonly _engineServerClient: V1_EngineServerClient;
   private readonly _graphManager: V1_PureGraphManager;
+  private readonly _cacheManager: LegendDataCubeDataCubeCacheManager;
 
   constructor(
     application: LegendDataCubeApplicationStore,
@@ -104,6 +135,15 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     this._depotServerClient = depotServerClient;
     this._engineServerClient = engineServerClient;
     this._graphManager = graphManager;
+    this._cacheManager = new LegendDataCubeDataCubeCacheManager();
+  }
+
+  async initializeCacheManager() {
+    await this._cacheManager.initialize();
+  }
+
+  async disposeCacheManager() {
+    await this._cacheManager.dispose();
   }
 
   // ---------------------------------- IMPLEMENTATION ----------------------------------
@@ -125,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;
@@ -155,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;
@@ -181,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),
@@ -206,7 +254,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         try {
           source.columns = (
             await this._getLambdaRelationType(
-              _serializeValueSpecification(source.lambda),
+              this.serializeValueSpecification(source.lambda),
               source.model,
             )
           ).columns;
@@ -230,7 +278,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     returnSourceInformation?: boolean | undefined,
   ) {
     try {
-      return _deserializeValueSpecification(
+      return this.deserializeValueSpecification(
         await this._engineServerClient.grammarToJSON_valueSpecification(
           code,
           '',
@@ -260,7 +308,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     pretty?: boolean | undefined,
   ) {
     return this._graphManager.valueSpecificationToPureCode(
-      _serializeValueSpecification(value),
+      this.serializeValueSpecification(value),
       pretty,
     );
   }
@@ -303,7 +351,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ) {
     try {
       return await this._getQueryRelationType(
-        _serializeValueSpecification(query),
+        this.serializeValueSpecification(query),
         source,
       );
     } catch (error) {
@@ -369,6 +417,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   ) {
     const queryCodePromise = this.getValueSpecificationCode(query);
     let result: ExecutionResult;
+    const startTime = performance.now();
     if (source instanceof AdhocQueryDataCubeSource) {
       result = await this._runQuery(query, source.model, undefined, options);
     } else if (source instanceof LegendQueryDataCubeSource) {
@@ -379,6 +428,29 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         source.parameterValues,
         options,
       );
+    } else if (source instanceof CachedDataCubeSource) {
+      // get the execute plan to extract the generated SQL to run against cached DB
+      const executionPlan = await this.generateExecutionPlan(
+        query,
+        source.model,
+        [],
+        options,
+      );
+      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.runSQLQuery(sql),
+        executionTime: endTime - startTime,
+      };
     } else {
       throw new UnsupportedOperationError(
         `Can't execute query with unsupported source`,
@@ -387,20 +459,21 @@ 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,
       executedSQL: sql,
+      executionTime: endTime - startTime,
     };
   }
 
@@ -418,6 +491,11 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           _elementPtr(source.runtime),
         ].filter(isNonNullable),
       );
+    } else if (source instanceof CachedDataCubeSource) {
+      return _function(
+        DataCubeFunction.FROM,
+        [_elementPtr(source.runtime)].filter(isNonNullable),
+      );
     }
     return undefined;
   }
@@ -432,6 +510,8 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
       return this._getLambdaRelationType(query, source.model);
     } else if (source instanceof LegendQueryDataCubeSource) {
       return this._getLambdaRelationType(query, source.model);
+    } else if (source instanceof CachedDataCubeSource) {
+      return this._getLambdaRelationType(query, serialize(source.model));
     }
     throw new UnsupportedOperationError(
       `Can't get relation type for lambda with unsupported source`,
@@ -472,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,
@@ -486,6 +566,147 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     );
   }
 
+  private async generateExecutionPlan(
+    query: V1_Lambda,
+    model: V1_PureModelContext,
+    parameterValues?: V1_ParameterValue[] | undefined,
+    options?: DataCubeExecutionOptions | undefined,
+  ): 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: this.serializeValueSpecification(query),
+        model: serialize(model),
+        context: serialize(
+          V1_rawBaseExecutionContextModelSchema,
+          new V1_RawBaseExecutionContext(),
+        ),
+        parameterValues: (parameterValues ?? []).map((parameterValue) =>
+          serialize(V1_parameterValueModelSchema, parameterValue),
+        ),
+      }),
+    );
+  }
+
+  // ---------------------------------- CACHING --------------------------------------
+
+  override async initializeCache(
+    source: DataCubeSource,
+  ): Promise<CachedDataCubeSource | undefined> {
+    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);
+
+    // model
+    const pacakgePath = 'local';
+
+    const table = new V1_Table();
+    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;
+    });
+
+    const schema = new V1_Schema();
+    schema.name = schemaName;
+    schema.tables = [table];
+    const database = new V1_Database();
+    database.name = 'db';
+    database.package = pacakgePath;
+    database.schemas = [schema];
+
+    const connection = new V1_RelationalDatabaseConnection();
+    connection.databaseType = DatabaseType.DuckDB;
+    connection.type = DatabaseType.DuckDB;
+    const dataSourceSpec = new V1_DuckDBDatasourceSpecification();
+    dataSourceSpec.path = '/tmpFile';
+    connection.store = database.path;
+    connection.datasourceSpecification = dataSourceSpec;
+    connection.authenticationStrategy = new V1_TestAuthenticationStrategy();
+
+    const runtime = new V1_EngineRuntime();
+    const storeConnections = new V1_StoreConnections();
+    storeConnections.store = new V1_PackageableElementPointer(
+      PackageableElementPointerType.STORE,
+      database.path,
+    );
+    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 = 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;
+  }
+
+  override async disposeCache(source: CachedDataCubeSource) {
+    await this._cacheManager.disposeCache(source);
+  }
+
+  // TODO: need a better way to infer datatype from tds builder
+  private _getColumnType(type: string | undefined): V1_RelationalDataType {
+    if (type === undefined) {
+      throw Error('Unsupported data type');
+    }
+    switch (type) {
+      case 'string':
+        return new V1_VarChar();
+      case 'integer':
+        return new V1_Integer();
+      case 'date':
+        return new V1_Date();
+      case 'boolean':
+        return new V1_Binary();
+      case 'number':
+        return new V1_Double();
+      default:
+        return new V1_VarChar();
+    }
+  }
+
   // ---------------------------------- APPLICATION ----------------------------------
 
   override logDebug(message: string, ...data: unknown[]) {

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;
+    }
+  }
 }

package/tsconfig.json

@@ -60,7 +60,9 @@
     "./src/application/LegendDataCubeApplicationConfig.ts",
     "./src/application/LegendDataCubeApplicationPlugin.ts",
     "./src/application/LegendDataCubePluginManager.ts",
+    "./src/stores/DuckDBWASM.d.ts",
     "./src/stores/LegendDataCubeBaseStore.ts",
+    "./src/stores/LegendDataCubeCacheManager.ts",
     "./src/stores/LegendDataCubeDataCubeEngine.ts",
     "./src/stores/model/LegendQueryDataCubeSource.ts",
     "./src/stores/query-builder/source-builder/AdhocQueryDataCubeSourceBuilderState.ts",