@finos/legend-application-data-cube 0.3.14 → 0.3.15

package/src/components/builder/source/LegendQueryDataCubeSourceBuilder_DataCubeApplicationPlugin.tsx

@@ -0,0 +1,128 @@
+/**
+ * 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 { guaranteeType } from '@finos/legend-shared';
+import packageJson from '../../../../package.json' with { type: 'json' };
+import { LegendDataCubeApplicationPlugin } from '../../../application/LegendDataCubeApplicationPlugin.js';
+import type { LegendDataCubeBuilderState } from '../../../stores/builder/LegendDataCubeBuilderStore.js';
+import { LegendQueryDataCubeSource } from '../../../stores/model/LegendQueryDataCubeSource.js';
+import { V1_AppliedFunction, V1_ValueSpecification } from '@finos/legend-graph';
+import { clsx } from '@finos/legend-art';
+import type {
+  ApplicationStore,
+  LegendApplicationConfig,
+  LegendApplicationPluginManager,
+  LegendApplicationPlugin,
+} from '@finos/legend-application';
+import {
+  buildDatePickerOption,
+  getV1_ValueSpecificationStringValue,
+} from '@finos/legend-query-builder';
+
+const getNameOfV1ValueSpecification = (
+  value: V1_ValueSpecification,
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+): string | undefined => {
+  if (value instanceof V1_AppliedFunction) {
+    const possibleDateLabel = buildDatePickerOption(
+      value,
+      applicationStore,
+    ).label;
+    if (possibleDateLabel) {
+      return possibleDateLabel;
+    }
+  }
+  return getV1_ValueSpecificationStringValue(value, applicationStore);
+};
+
+export class LegendQueryDataCubeSourceBuilder_DataCubeApplicationPlugin extends LegendDataCubeApplicationPlugin {
+  static NAME = packageJson.extensions.legendQueryDataCubeSourceBuilderPlugin;
+
+  constructor() {
+    super(
+      LegendQueryDataCubeSourceBuilder_DataCubeApplicationPlugin.NAME,
+      packageJson.version,
+    );
+  }
+
+  override getSourceViewerHeight(
+    builder: LegendDataCubeBuilderState | undefined,
+  ): number | undefined {
+    if (builder?.source instanceof LegendQueryDataCubeSource) {
+      return (
+        200 +
+        20 * builder.source.parameterValues.length +
+        (builder.dataCube?.isCachingEnabled() ? 70 : 0)
+      );
+    }
+    return undefined;
+  }
+
+  override builderInnerHeaderRenderer(
+    builder: LegendDataCubeBuilderState | undefined,
+  ): React.ReactNode | null {
+    if (
+      builder?.source instanceof LegendQueryDataCubeSource &&
+      builder.source.parameterValues.length
+    ) {
+      const source = guaranteeType(builder.source, LegendQueryDataCubeSource);
+
+      return (
+        <div
+          key={LegendQueryDataCubeSourceBuilder_DataCubeApplicationPlugin.NAME}
+          className="flex h-full flex-auto items-center overflow-auto border-l border-neutral-300 pl-2"
+        >
+          Parameters:
+          {source.parameterValues.map((param) => {
+            const paramValue = getNameOfV1ValueSpecification(
+              guaranteeType(param.valueSpec, V1_ValueSpecification),
+              builder._store.application,
+            );
+            return (
+              <div
+                key={param.variable.name}
+                className="max-w-200 ml-2 flex cursor-pointer hover:brightness-95"
+                onClick={() => {
+                  // Set sourceViewerDisplay height based on length of parameters.
+                  // Height should also be increased if we need to show the parameter
+                  // editing disabled message.
+                  builder._store.sourceViewerDisplay.configuration.window.height =
+                    Math.min(600, this.getSourceViewerHeight(builder) ?? 200);
+                  builder._store.sourceViewerDisplay.open();
+                }}
+              >
+                <span className="truncate bg-neutral-300 px-1">
+                  {param.variable.name}
+                </span>
+                <span
+                  className={clsx('truncate bg-neutral-200 px-1', {
+                    'text-neutral-500': paramValue === '',
+                  })}
+                >
+                  {paramValue === '' ? '(empty)' : paramValue}
+                </span>
+              </div>
+            );
+          })}
+        </div>
+      );
+    }
+    return null;
+  }
+}

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -42,7 +42,6 @@ import {
   V1_buildEngineError,
   V1_EngineError,
   V1_PackageableType,
-  V1_deserializeRawValueSpecificationType,
   V1_Protocol,
   type V1_ExecutionPlan,
   V1_deserializeExecutionPlan,
@@ -85,6 +84,8 @@ import {
   LET_TOKEN,
   V1_AppliedFunction,
   type V1_LambdaReturnTypeResult,
+  V1_Variable,
+  type QueryInfo,
 } from '@finos/legend-graph';
 import {
   _elementPtr,
@@ -92,20 +93,21 @@ import {
   type CompletionItem,
   _function,
   DataCubeFunction,
-  AdhocQueryDataCubeSource,
-  ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE,
-  RawAdhocQueryDataCubeSource,
+  FreeformTDSExpressionDataCubeSource,
+  FREEFORM_TDS_EXPRESSION_DATA_CUBE_SOURCE_TYPE,
+  RawFreeformTDSExpressionDataCubeSource,
   _lambda,
-  _defaultPrimitiveTypeValue,
   CachedDataCubeSource,
   type DataCubeExecutionOptions,
   type DataCubeCacheInitializationOptions,
   DataCubeExecutionError,
   RawUserDefinedFunctionDataCubeSource,
-  ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE,
+  USER_FUNCTION_DATA_CUBE_SOURCE_TYPE,
   type DataCubeSource,
   UserDefinedFunctionDataCubeSource,
   DataCubeQueryFilterOperator,
+  _primitiveValue,
+  _defaultPrimitiveTypeValue,
 } from '@finos/legend-data-cube';
 import {
   isNonNullable,
@@ -211,7 +213,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           path: source.functionPath,
           runtime: source.runtime,
         },
-        sourceType: ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE,
+        sourceType: USER_FUNCTION_DATA_CUBE_SOURCE_TYPE,
       };
     } else if (source instanceof LocalFileDataCubeSource) {
       const deserializedModel = V1_deserializePureModelContext(source.model);
@@ -240,7 +242,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         },
         sourceType: LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE,
       };
-    } else if (source instanceof AdhocQueryDataCubeSource) {
+    } else if (source instanceof FreeformTDSExpressionDataCubeSource) {
       const deserializedModel = V1_deserializePureModelContext(source.model);
 
       const sdlcInfo =
@@ -262,7 +264,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           mapping: source.mapping,
           runtime: source.runtime,
         },
-        sourceType: ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE,
+        sourceType: FREEFORM_TDS_EXPRESSION_DATA_CUBE_SOURCE_TYPE,
       };
     }
     return {};
@@ -283,7 +285,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         },
         sourceType: source._type,
       };
-    } else if (source._type === ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE) {
+    } else if (source._type === USER_FUNCTION_DATA_CUBE_SOURCE_TYPE) {
       const rawSource =
         RawUserDefinedFunctionDataCubeSource.serialization.fromJson(source);
       const deserializedModel = V1_deserializePureModelContext(rawSource.model);
@@ -320,9 +322,9 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         },
         sourceType: source._type,
       };
-    } else if (source._type === ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE) {
+    } else if (source._type === FREEFORM_TDS_EXPRESSION_DATA_CUBE_SOURCE_TYPE) {
       const rawSource =
-        RawAdhocQueryDataCubeSource.serialization.fromJson(source);
+        RawFreeformTDSExpressionDataCubeSource.serialization.fromJson(source);
       const deserializedModel = V1_deserializePureModelContext(rawSource.model);
 
       const sdlcInfo =
@@ -362,10 +364,10 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
 
   override async processSource(value: PlainObject): Promise<DataCubeSource> {
     switch (value._type) {
-      case ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE: {
+      case FREEFORM_TDS_EXPRESSION_DATA_CUBE_SOURCE_TYPE: {
         const rawSource =
-          RawAdhocQueryDataCubeSource.serialization.fromJson(value);
-        const source = new AdhocQueryDataCubeSource();
+          RawFreeformTDSExpressionDataCubeSource.serialization.fromJson(value);
+        const source = new FreeformTDSExpressionDataCubeSource();
         if (rawSource.mapping) {
           source.mapping = rawSource.mapping;
         }
@@ -499,7 +501,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         }
         return source;
       }
-      case ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE: {
+      case USER_FUNCTION_DATA_CUBE_SOURCE_TYPE: {
         const rawSource =
           RawUserDefinedFunctionDataCubeSource.serialization.fromJson(value);
         const deserializedModel = V1_deserializePureModelContext(
@@ -644,58 +646,10 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           );
         }
 
-        // To handle parameter value with function calls we
-        // 1. Separate the parameters with function calls from regular parameters
-        // 2. Add let statements for function parameter values and store them in the source's letParameterValueSpec
-        // 3. Prepend the let statements to the lambda body when we execute the query
-        const letFuncs: V1_ValueSpecification[] = [];
-        const parameterValues = (
-          await Promise.all(
-            source.lambda.parameters.map(async (parameter) => {
-              if (
-                parameter.genericType?.rawType instanceof V1_PackageableType
-              ) {
-                const type = parameter.genericType.rawType.fullPath;
-                const defaultValueString =
-                  queryInfo.defaultParameterValues?.find(
-                    (val) => val.name === parameter.name,
-                  )?.content;
-                const defaultValueSpec =
-                  defaultValueString !== undefined
-                    ? await this.parseValueSpecification(defaultValueString)
-                    : {
-                        _type: V1_deserializeRawValueSpecificationType(type),
-                        value: _defaultPrimitiveTypeValue(type),
-                      };
-                if (defaultValueSpec instanceof V1_AppliedFunction) {
-                  const letFunc = guaranteeType(
-                    this.deserializeValueSpecification(
-                      await this._engineServerClient.grammarToJSON_lambda(
-                        `${LET_TOKEN} ${parameter.name} ${DataCubeQueryFilterOperator.EQUAL} ${defaultValueString}`,
-                        '',
-                        undefined,
-                        undefined,
-                        false,
-                      ),
-                    ),
-                    V1_Lambda,
-                  );
-                  letFuncs.push(...letFunc.body);
-                } else {
-                  const paramValue = new V1_ParameterValue();
-                  paramValue.name = parameter.name;
-                  paramValue.value = defaultValueSpec;
-                  return paramValue;
-                }
-              }
-              return undefined;
-            }),
-          )
-        ).filter(isNonNullable);
-        source.letParameterValueSpec = letFuncs;
-        source.parameterValues = parameterValues;
-        source.lambda.parameters = source.lambda.parameters.filter((param) =>
-          parameterValues.find((p) => p.name === param.name),
+        source.parameterValues = await this._getQueryParameterValues(
+          rawSource,
+          source.lambda,
+          queryInfo,
         );
         return source;
       }
@@ -758,7 +712,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     codeBlock = codeBlock.startsWith(LAMBDA_PIPE)
       ? codeBlock.substring(LAMBDA_PIPE.length)
       : codeBlock;
-    if (context instanceof AdhocQueryDataCubeSource) {
+    if (context instanceof FreeformTDSExpressionDataCubeSource) {
       return (
         await this._engineServerClient.completeCode({
           codeBlock,
@@ -868,17 +822,54 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     const startTime = performance.now();
 
     try {
-      if (source instanceof AdhocQueryDataCubeSource) {
+      if (source instanceof FreeformTDSExpressionDataCubeSource) {
         result = await this._runQuery(query, source.model, undefined, options);
       } else if (source instanceof UserDefinedFunctionDataCubeSource) {
         result = await this._runQuery(query, source.model, undefined, options);
       } else if (source instanceof LegendQueryDataCubeSource) {
-        query.parameters = source.lambda.parameters;
+        // To handle parameter value with function calls we
+        // 1. Separate the parameters with function calls from regular parameters
+        // 2. Add let statements for function parameter values and store them in the source's letParameterValueSpec
+        // 3. Prepend the let statements to the lambda body when we execute the query
+        const letFuncs: V1_ValueSpecification[] = [];
+        const filteredParameterValues = (
+          await Promise.all(
+            source.parameterValues.map(async ({ variable, valueSpec }) => {
+              if (variable.genericType?.rawType instanceof V1_PackageableType) {
+                if (valueSpec instanceof V1_AppliedFunction) {
+                  const letFunc = guaranteeType(
+                    this.deserializeValueSpecification(
+                      await this._engineServerClient.grammarToJSON_lambda(
+                        `${LET_TOKEN} ${variable.name} ${DataCubeQueryFilterOperator.EQUAL} ${await this.getValueSpecificationCode(valueSpec)}`,
+                        '',
+                        undefined,
+                        undefined,
+                        false,
+                      ),
+                    ),
+                    V1_Lambda,
+                  );
+                  letFuncs.push(...letFunc.body);
+                } else {
+                  const paramValue = new V1_ParameterValue();
+                  paramValue.name = variable.name;
+                  paramValue.value = valueSpec;
+                  return paramValue;
+                }
+              }
+              return undefined;
+            }),
+          )
+        ).filter(isNonNullable);
+
+        query.parameters = source.lambda.parameters.filter((param) =>
+          filteredParameterValues.find((p) => p.name === param.name),
+        );
         // If the source lambda has multiple expressions, we should prepend all but the
         // last expression to the transformed query body (which came from the final
         // expression of the source lambda).
         query.body = [
-          ...source.letParameterValueSpec,
+          ...letFuncs,
           ...(source.lambda.body.length > 1
             ? source.lambda.body.slice(0, -1)
             : []),
@@ -887,7 +878,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         result = await this._runQuery(
           query,
           source.model,
-          source.parameterValues,
+          filteredParameterValues,
           options,
         );
       } else if (source instanceof CachedDataCubeSource) {
@@ -979,7 +970,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   }
 
   override buildExecutionContext(source: DataCubeSource) {
-    if (source instanceof AdhocQueryDataCubeSource) {
+    if (source instanceof FreeformTDSExpressionDataCubeSource) {
       return _function(
         DataCubeFunction.FROM,
         [
@@ -1107,7 +1098,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     query: PlainObject<V1_Lambda>,
     source: DataCubeSource,
   ) {
-    if (source instanceof AdhocQueryDataCubeSource) {
+    if (source instanceof FreeformTDSExpressionDataCubeSource) {
       return this._getLambdaRelationType(query, source.model);
     } else if (source instanceof UserDefinedFunctionDataCubeSource) {
       return this._getLambdaRelationType(query, source.model);
@@ -1154,6 +1145,73 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     };
   }
 
+  async _getQueryParameterValues(
+    rawSource: RawLegendQueryDataCubeSource,
+    lambda: V1_Lambda,
+    queryInfo: QueryInfo,
+  ): Promise<{ variable: V1_Variable; valueSpec: V1_ValueSpecification }[]> {
+    const rawSourceParameters: {
+      variable: V1_Variable;
+      valueSpec: V1_ValueSpecification;
+    }[] =
+      rawSource.parameterValues?.map(([variable, _value]) => ({
+        variable: guaranteeType(
+          V1_deserializeValueSpecification(JSON.parse(variable), []),
+          V1_Variable,
+        ),
+        valueSpec: V1_deserializeValueSpecification(JSON.parse(_value), []),
+      })) ?? [];
+
+    const lambdaParameterValues: {
+      variable: V1_Variable;
+      valueSpec: V1_ValueSpecification;
+    }[] = (
+      await Promise.all(
+        lambda.parameters.map(async (parameter) => {
+          if (parameter.genericType?.rawType instanceof V1_PackageableType) {
+            const type = parameter.genericType.rawType.fullPath;
+            const defaultValueString = queryInfo.defaultParameterValues?.find(
+              (val) => val.name === parameter.name,
+            )?.content;
+            const defaultValueSpec =
+              defaultValueString !== undefined
+                ? await this.parseValueSpecification(defaultValueString)
+                : _primitiveValue(type, _defaultPrimitiveTypeValue(type));
+            return { variable: parameter, valueSpec: defaultValueSpec };
+          }
+          return undefined;
+        }),
+      )
+    ).filter(isNonNullable);
+
+    // Here, we need to handle 3 cases:
+    // 1. The query has a parameter with the same name and type as the raw source (which comes from the PersistentDataCube).
+    //    In this case, we use the parameter value from the raw source.
+    // 2. The query has a parameter that does not exist in the raw source (i.e., the parameter was renamed, the type was changed,
+    //    or was newly added after the DataCube was last saved). In this case, we use the default value from the query.
+    // 3. The raw source has a parameter that does not exist in the query. In this case, we discard the parameter as it
+    //    is no longer used in the query.
+    return lambdaParameterValues.map(({ variable, valueSpec }) => {
+      const rawSourceParameter = rawSourceParameters.find(
+        ({ variable: _rawVariable, valueSpec: _rawValueSpec }) =>
+          _rawVariable.name === variable.name,
+      );
+      const rawSourceVariable = rawSourceParameter?.variable;
+      const rawSourceValueSpec = rawSourceParameter?.valueSpec;
+      if (
+        rawSourceVariable &&
+        rawSourceValueSpec &&
+        rawSourceVariable.genericType?.rawType instanceof V1_PackageableType &&
+        variable.genericType?.rawType instanceof V1_PackageableType &&
+        rawSourceVariable.genericType.rawType.fullPath ===
+          variable.genericType.rawType.fullPath
+      ) {
+        return { variable: rawSourceVariable, valueSpec: rawSourceValueSpec };
+      }
+      return { variable, valueSpec };
+    });
+  }
+
   private async _runQuery(
     query: V1_Lambda,
     model: PlainObject<V1_PureModelContext>,

package/src/stores/builder/LegendDataCubeBuilderStore.tsx

@@ -74,6 +74,7 @@ export class LegendDataCubeBuilderState {
   readonly uuid = uuid();
   readonly startTime = Date.now();
 
+  readonly _store!: LegendDataCubeBuilderStore;
   readonly initialSpecification!: DataCubeSpecification;
   persistentDataCube?: PersistentDataCube | undefined;
 
@@ -81,6 +82,7 @@ export class LegendDataCubeBuilderState {
   source?: DataCubeSource | undefined;
 
   constructor(
+    store: LegendDataCubeBuilderStore,
     specification: DataCubeSpecification,
     persistentDataCube?: PersistentDataCube | undefined,
   ) {
@@ -95,6 +97,7 @@ export class LegendDataCubeBuilderState {
       setSource: action,
     });
 
+    this._store = store;
     this.initialSpecification = specification;
     this.persistentDataCube = persistentDataCube;
   }
@@ -423,7 +426,7 @@ export class LegendDataCubeBuilderStore {
     dataCubeId: string,
   ) {
     this.setBuilder(
-      new LegendDataCubeBuilderState(specification, persistentDataCube),
+      new LegendDataCubeBuilderState(this, specification, persistentDataCube),
     );
     this.updateWindowTitle(persistentDataCube);
 

package/src/stores/builder/LegendDataCubeCreatorState.tsx

@@ -35,7 +35,7 @@ import {
 } from '@finos/legend-data-cube';
 import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
 import { LegendDataCubeCreator } from '../../components/builder/LegendDataCubeCreator.js';
-import { AdhocQueryDataCubeSourceBuilderState } from './source/AdhocQueryDataCubeSourceBuilderState.js';
+import { FreeformTDSExpressionDataCubeSourceBuilderState } from './source/FreeformTDSExpressionDataCubeSourceBuilderState.js';
 import {
   LegendDataCubeBuilderState,
   type LegendDataCubeBuilderStore,
@@ -100,11 +100,12 @@ export class LegendDataCubeCreatorState {
           this._application,
           this._engine,
           this._store.engineServerClient,
+          this._store.depotServerClient,
           this._store.graphManager,
           this._alertService,
         );
-      case LegendDataCubeSourceBuilderType.ADHOC_QUERY:
-        return new AdhocQueryDataCubeSourceBuilderState(
+      case LegendDataCubeSourceBuilderType.FREEFORM_TDS_EXPRESSION:
+        return new FreeformTDSExpressionDataCubeSourceBuilderState(
           this._application,
           this._engine,
           this._alertService,
@@ -152,7 +153,9 @@ export class LegendDataCubeCreatorState {
         }
 
         // reset
-        this._store.setBuilder(new LegendDataCubeBuilderState(specification));
+        this._store.setBuilder(
+          new LegendDataCubeBuilderState(this._store, specification),
+        );
         // only update the route instead of reloading in case we are creating
         // a new DataCube when we are editing another DataCube
         this._application.navigationService.navigator.updateCurrentLocation(

package/src/stores/builder/source/{AdHocCodeEditorState.tsx → FreeformExpressionCodeEditorState.tsx}

@@ -28,7 +28,7 @@ import {
 } from '@finos/legend-shared';
 import { action, makeObservable, observable, runInAction } from 'mobx';
 
-export class AdHocCodeEditorState extends DataCubeCodeEditorState {
+export class FreeformExpressionCodeEditorState extends DataCubeCodeEditorState {
   protected override readonly uuid = uuid();
   codeSuffix: string;
 

package/src/stores/builder/source/{AdhocQueryDataCubeSourceBuilderState.ts → FreeformTDSExpressionDataCubeSourceBuilderState.ts}

@@ -41,11 +41,11 @@ import {
 import {
   _lambda,
   type DataCubeAlertService,
-  RawAdhocQueryDataCubeSource,
+  RawFreeformTDSExpressionDataCubeSource,
 } from '@finos/legend-data-cube';
-import { AdHocCodeEditorState } from './AdHocCodeEditorState.js';
+import { FreeformExpressionCodeEditorState } from './FreeformExpressionCodeEditorState.js';
 
-export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
+export class FreeformTDSExpressionDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
   builderStore: LegendDataCubeBuilderStore;
   projects: StoreProjectData[] = [];
   currentProject?: StoreProjectData | undefined;
@@ -57,7 +57,7 @@ export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBu
   currentMapping?: V1_Mapping | undefined;
   modelPointer: PlainObject<V1_PureModelContextPointer> | undefined;
 
-  codeEditorState: AdHocCodeEditorState;
+  codeEditorState: FreeformExpressionCodeEditorState;
   queryCompileState = ActionState.create();
   code = '';
 
@@ -92,7 +92,7 @@ export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBu
     });
 
     this.modelPointer = this.buildPureModelContextPointer();
-    this.codeEditorState = new AdHocCodeEditorState(
+    this.codeEditorState = new FreeformExpressionCodeEditorState(
       application.alertUnhandledError,
       this.modelPointer,
       this.compileQueryCallback,
@@ -157,7 +157,7 @@ export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBu
   }
 
   override get label(): LegendDataCubeSourceBuilderType {
-    return LegendDataCubeSourceBuilderType.ADHOC_QUERY;
+    return LegendDataCubeSourceBuilderType.FREEFORM_TDS_EXPRESSION;
   }
 
   override get isValid(): boolean {
@@ -231,7 +231,7 @@ export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBu
       );
     }
 
-    const source = new RawAdhocQueryDataCubeSource();
+    const source = new RawFreeformTDSExpressionDataCubeSource();
     if (this.currentMapping) {
       source.mapping = this.currentMapping.path;
     }
@@ -247,6 +247,6 @@ export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBu
         );
       }
     }
-    return RawAdhocQueryDataCubeSource.serialization.toJson(source);
+    return RawFreeformTDSExpressionDataCubeSource.serialization.toJson(source);
   }
 }

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

@@ -24,7 +24,7 @@ import type {
 
 export enum LegendDataCubeSourceBuilderType {
   LEGEND_QUERY = 'Legend Query',
-  ADHOC_QUERY = 'Ad hoc Query',
+  FREEFORM_TDS_EXPRESSION = 'Freeform TDS Expression',
   LOCAL_FILE = 'Local File',
   USER_DEFINED_FUNCTION = 'User Defined Function',
 }