@finos/legend-application-studio 28.18.148 → 28.19.0

package/src/components/editor/editor-group/function-activator/FunctionEditor.tsx

@@ -68,6 +68,7 @@ import {
   LongArrowRightIcon,
   CheckSquareIcon,
   SquareIcon,
+  SinglestoreIcon,
 } from '@finos/legend-art';
 import { LEGEND_STUDIO_TEST_ID } from '../../../../__lib__/LegendStudioTesting.js';
 import {
@@ -163,7 +164,6 @@ import type { FunctionActivatorState } from '../../../../stores/editor/editor-st
 import { FunctionTestableEditor } from './testable/FunctionTestableEditor.js';
 import { DocumentationLink } from '@finos/legend-lego/application';
 import { LEGEND_STUDIO_DOCUMENTATION_KEY } from '../../../../__lib__/LegendStudioDocumentation.js';
-import { openDataCube } from '../../../../stores/editor/data-cube/LegendStudioDataCubeHelper.js';
 import {
   DataGrid,
   type DataGridColumnDefinition,
@@ -178,6 +178,7 @@ enum FUNCTION_PARAMETER_TYPE {
 export enum FUNCTION_ACTIVATE_TYPE {
   SNOWFLAKE_NATIVE_APP = 'Snowflake UDTF',
   HOSTED_SERVICE = 'REST Service',
+  MEM_SQL_FUNCTION = 'Mem SQL Function',
   SERVICE_JAR = 'Service JAR',
   REFINER = 'Refiner',
   BIG_QUERY_NATIVE_APP = 'BigQuery Native App',
@@ -756,6 +757,22 @@ const FunctionPromoteEditor = observer(
           }
           return false;
         }
+        case FUNCTION_ACTIVATE_TYPE.MEM_SQL_FUNCTION: {
+          const availableConnections =
+            activatorPromoteState.functionEditorState.editorStore.graphManagerState.usableConnections.filter(
+              (connection) =>
+                connection.connectionValue instanceof
+                  RelationalDatabaseConnection &&
+                connection.connectionValue.type === DatabaseType.MemSQL,
+            );
+          if (availableConnections.length > 0) {
+            return true;
+          } else {
+            validationMessage =
+              'There is no available connection of type MemSQL';
+          }
+          return false;
+        }
         default:
           return true;
       }
@@ -798,6 +815,24 @@ const FunctionPromoteEditor = observer(
               }}
             />
           );
+        case FUNCTION_ACTIVATE_TYPE.MEM_SQL_FUNCTION:
+          return (
+            <BaseCard
+              key={FUNCTION_ACTIVATE_TYPE.MEM_SQL_FUNCTION}
+              cardMedia={
+                <SinglestoreIcon className="function-promote-editor__type-icon" />
+              }
+              cardName={type}
+              cardContent="Deploy the function as a UDF (user-defined function) in Mem SQL"
+              isActive={
+                activatorPromoteState.activateType ===
+                FUNCTION_ACTIVATE_TYPE.MEM_SQL_FUNCTION
+              }
+              onClick={() => {
+                activatorPromoteState.setAcitvateType(type);
+              }}
+            />
+          );
         case FUNCTION_ACTIVATE_TYPE.SERVICE_JAR:
           return (
             <BaseCard
@@ -1418,7 +1453,10 @@ export const FunctionEditor = observer(() => {
 
   const openFunctionCubeViewer =
     editorStore.applicationStore.guardUnhandledError(async () => {
-      await openDataCube(functionEditorState.element, editorStore);
+      await functionEditorState.handleOpeningDataCube(
+        functionEditorState.element,
+        editorStore,
+      );
     });
 
   const visitActivator = (activator: FunctionActivator): void =>

package/src/components/editor/editor-group/function-activator/MemSQLFunctionActivatorEditor.tsx

@@ -0,0 +1,269 @@
+/**
+ * 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 SelectComponent,
+  Panel,
+  PanelHeader,
+  PanelContent,
+  PanelForm,
+  PanelFormTextField,
+  PURE_FunctionIcon,
+  LongArrowRightIcon,
+  PanelLoadingIndicator,
+  PURE_ConnectionIcon,
+  CustomSelectorInput,
+  createFilter,
+} from '@finos/legend-art';
+import {
+  type PackageableConnection,
+  generateFunctionPrettyName,
+  RelationalDatabaseConnection,
+  DatabaseType,
+} from '@finos/legend-graph';
+import { observer } from 'mobx-react-lite';
+import { useApplicationStore } from '@finos/legend-application';
+import { useEditorStore } from '../../EditorStoreProvider.js';
+import { MemSQLFunctionActivatorEditorState } from '../../../../stores/editor/editor-state/element-editor-state/function-activator/MemSQLFunctionActivatorEditorState.js';
+import { flowResult } from 'mobx';
+import { useRef } from 'react';
+import {
+  type RelationalDatabaseConnectionOption,
+  buildRelationalDatabaseConnectionOption,
+} from '../connection-editor/RelationalDatabaseConnectionEditor.js';
+import { ActivatorOwnershipForm } from './ActivatorFormComponents.js';
+
+export const MemSQLFunctionActivatorEditor = observer(() => {
+  const editorStore = useEditorStore();
+  const applicationStore = useApplicationStore();
+  const editorState = editorStore.tabManagerState.getCurrentEditorState(
+    MemSQLFunctionActivatorEditorState,
+  );
+  const isReadOnly = editorState.isReadOnly;
+  const activator = editorState.activator;
+
+  const connectionSelectorRef = useRef<SelectComponent>(null);
+  const connectionFilterOption = createFilter({
+    ignoreCase: true,
+    ignoreAccents: false,
+    stringify: (option: { data: RelationalDatabaseConnectionOption }): string =>
+      option.data.value.path,
+  });
+  const connectionOptions = editorStore.graphManagerState.usableConnections
+    .filter(
+      (connection) =>
+        connection.connectionValue instanceof RelationalDatabaseConnection &&
+        connection.connectionValue.type === DatabaseType.MemSQL,
+    )
+    .map(buildRelationalDatabaseConnectionOption);
+
+  const initializeActivationConnection = (
+    val: PackageableConnection | undefined,
+  ): PackageableConnection | undefined => {
+    if (val) {
+      editorState.updateConnection(val);
+    }
+    return !val
+      ? undefined
+      : activator.activationConfiguration.activationConnection
+          ?.packageableConnection.value;
+  };
+
+  const activationConnection = activator.activationConfiguration
+    .activationConnection
+    ? activator.activationConfiguration.activationConnection
+        .packageableConnection.value
+    : initializeActivationConnection(connectionOptions.at(0)?.value);
+
+  const changeConnection = (val: RelationalDatabaseConnectionOption): void => {
+    if (!isReadOnly && val.value === activationConnection) {
+      return;
+    }
+    editorState.updateConnection(val.value);
+  };
+  const changeDescription: React.ChangeEventHandler<HTMLTextAreaElement> = (
+    event,
+  ) => {
+    if (!isReadOnly) {
+      editorState.updateAppDescription(event.target.value);
+    }
+  };
+  const visitFunction = (): void =>
+    editorState.editorStore.graphEditorMode.openElement(
+      activator.function.value,
+    );
+  const visitConnection = (): void => {
+    if (activationConnection) {
+      editorState.editorStore.graphEditorMode.openElement(activationConnection);
+    }
+  };
+  const validate = (): void => {
+    flowResult(editorState.validate()).catch(
+      applicationStore.alertUnhandledError,
+    );
+  };
+  const deploy = (): void => {
+    flowResult(editorState.deployToSandbox()).catch(
+      applicationStore.alertUnhandledError,
+    );
+  };
+
+  return (
+    <div className="mem-sql-function-activator-editor">
+      <Panel>
+        <PanelHeader title="Mem SQL Function" />
+        <PanelLoadingIndicator
+          isLoading={Boolean(
+            editorState.validateState.isInProgress ||
+              editorState.deployState.isInProgress,
+          )}
+        />
+        <PanelContent>
+          <div className="mem-sql-function-activator-editor__header">
+            <div className="mem-sql-function-activator-editor__header__label">
+              Mem SQL Function
+            </div>
+            <div className="mem-sql-function-activator-editor__header__actions">
+              <button
+                className="mem-sql-function-activator-editor__header__actions__action mem-sql-function-activator-editor__header__actions__action--primary"
+                onClick={validate}
+                disabled={editorState.validateState.isInProgress}
+                tabIndex={-1}
+                title="Click Validate to verify your activator before deployment"
+              >
+                Validate
+              </button>
+              <button
+                className="mem-sql-function-activator-editor__header__actions__action mem-sql-function-activator-editor__header__actions__action--primary"
+                onClick={deploy}
+                disabled={editorState.deployState.isInProgress}
+                title="Deploy to sandbox"
+                tabIndex={-1}
+              >
+                Deploy to Sandbox
+              </button>
+            </div>
+          </div>
+          <PanelForm>
+            <div className="panel__content__form__section">
+              <div className="panel__content__form__section__header__label">
+                Function
+              </div>
+            </div>
+            <div className="mem-sql-function-activator-editor__configuration__items">
+              <div className="mem-sql-function-activator-editor__configuration__item">
+                <div className="btn--sm mem-sql-function-activator-editor__configuration__item__label">
+                  <PURE_FunctionIcon />
+                </div>
+                <input
+                  className="panel__content__form__section__input"
+                  spellCheck={false}
+                  disabled={true}
+                  value={generateFunctionPrettyName(activator.function.value, {
+                    fullPath: true,
+                    spacing: false,
+                  })}
+                />
+                <button
+                  className="btn--dark btn--sm mem-sql-function-activator-editor__configuration__item__btn"
+                  onClick={visitFunction}
+                  tabIndex={-1}
+                  title="See Function"
+                >
+                  <LongArrowRightIcon />
+                </button>
+              </div>
+            </div>
+          </PanelForm>
+          <PanelForm>
+            <div className="panel__content__form__section">
+              <div className="panel__content__form__section__header__label">
+                Connection
+              </div>
+            </div>
+            <div className="mem-sql-function-activator-editor__configuration__items">
+              <div className="mem-sql-function-activator-editor__configuration__item">
+                <div className="btn--sm mem-sql-function-activator-editor__configuration__item__label">
+                  <PURE_ConnectionIcon />
+                </div>
+                <CustomSelectorInput
+                  inputRef={connectionSelectorRef}
+                  className="mem-sql-function-activator-editor__config__connection-selector__input"
+                  options={connectionOptions}
+                  onChange={changeConnection}
+                  value={
+                    activationConnection
+                      ? buildRelationalDatabaseConnectionOption(
+                          activationConnection,
+                        )
+                      : undefined
+                  }
+                  darkMode={
+                    !applicationStore.layoutService
+                      .TEMPORARY__isLightColorThemeEnabled
+                  }
+                  placeholder="Choose a connection"
+                  filterOption={connectionFilterOption}
+                />
+                <button
+                  className="btn--dark btn--sm mem-sql-function-activator-editor__configuration__item__btn"
+                  onClick={visitConnection}
+                  disabled={!activationConnection}
+                  tabIndex={-1}
+                  title="See Connection"
+                >
+                  <LongArrowRightIcon />
+                </button>
+              </div>
+            </div>
+          </PanelForm>
+          <PanelForm>
+            <PanelFormTextField
+              value={activator.functionName}
+              isReadOnly={isReadOnly}
+              name="Activator Identifer"
+              placeholder="Specify the name of the UDF for this activator..."
+              update={(value: string | undefined): void =>
+                editorState.updateApplicationName(value ?? '')
+              }
+            />
+          </PanelForm>
+          <PanelForm>
+            <div className="panel__content__form__section">
+              <div className="panel__content__form__section__header__label">
+                Description
+              </div>
+              <div className="panel__content__form__section__header__prompt">{`Provide a brief description of Mem SQL Function`}</div>
+              <textarea
+                className="panel__content__form__section__textarea service-editor__documentation__input"
+                spellCheck={false}
+                disabled={isReadOnly}
+                value={activator.description}
+                onChange={changeDescription}
+              />
+            </div>
+          </PanelForm>
+          <PanelForm>
+            <ActivatorOwnershipForm
+              activator={activator}
+              isReadOnly={isReadOnly}
+            />
+          </PanelForm>
+        </PanelContent>
+      </Panel>
+    </div>
+  );
+});

package/src/components/editor/editor-group/ingest-editor/IngestDefinitionEditor.tsx

@@ -43,7 +43,7 @@ import { useAuth } from 'react-oidc-context';
 import {
   IngestDefinitionDeploymentResponse,
   IngestDefinitionValidationResponse,
-} from '../../../../stores/ingestion/IngestionDeploymentResponse.js';
+} from '@finos/legend-server-lakehouse';
 
 const IngestValidationError = observer(
   (props: {

package/src/components/editor/editor-group/service-editor/ServiceExecutionQueryEditor.tsx

@@ -69,7 +69,6 @@ import { EXTERNAL_APPLICATION_NAVIGATION__generateServiceQueryCreatorUrl } from
 import type { EditorStore } from '../../../../stores/editor/EditorStore.js';
 import { pureExecution_setFunction } from '../../../../stores/graph-modifier/DSL_Service_GraphModifierHelper.js';
 import { ServiceEditorState } from '../../../../stores/editor/editor-state/element-editor-state/service/ServiceEditorState.js';
-import { openDataCube } from '../../../../stores/editor/data-cube/LegendStudioDataCubeHelper.js';
 
 const ServiceExecutionResultViewer = observer(
   (props: { executionState: ServicePureExecutionState }) => {
@@ -238,7 +237,7 @@ export const ServiceExecutionQueryEditor = observer(
 
     const openServiceCubeViewer =
       editorStore.applicationStore.guardUnhandledError(async () => {
-        await openDataCube(service, editorStore);
+        await executionState.handleOpeningDataCube(service, editorStore);
       });
 
     const openQueryInLegendQuery = (): void => {

package/src/index.ts

@@ -120,3 +120,5 @@ export type { EmbeddedDataTypeOption } from './stores/editor/editor-state/elemen
 export { SnowflakeAppFunctionActivatorEdtiorState } from './stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.js';
 export { SnowflakeAppFunctionActivatorEditor } from './components/editor/editor-group/function-activator/SnowflakeAppFunctionActivatorEditor.js';
 export { HostedServiceFunctionActivatorEditorState } from './stores/editor/editor-state/element-editor-state/function-activator/HostedServiceFunctionActivatorEditorState.js';
+export { MemSQLFunctionActivatorEditorState } from './stores/editor/editor-state/element-editor-state/function-activator/MemSQLFunctionActivatorEditorState.js';
+export { MemSQLFunctionActivatorEditor } from './components/editor/editor-group/function-activator/MemSQLFunctionActivatorEditor.js';

package/src/stores/editor/EditorGraphState.ts

@@ -92,6 +92,7 @@ import {
   HostedService,
   DataProduct,
   IngestDefinition,
+  MemSQLFunction,
 } from '@finos/legend-graph';
 import { CONFIGURATION_EDITOR_TAB } from './editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.js';
 import { PACKAGEABLE_ELEMENT_TYPE } from './utils/ModelClassifierUtils.js';
@@ -860,6 +861,8 @@ export class EditorGraphState {
       return PACKAGEABLE_ELEMENT_TYPE._DATA_PRODUCT;
     } else if (element instanceof IngestDefinition) {
       return PACKAGEABLE_ELEMENT_TYPE.INGEST_DEFINITION;
+    } else if (element instanceof MemSQLFunction) {
+      return PACKAGEABLE_ELEMENT_TYPE.MEM_SQL_FUNCTION;
     }
     const extraElementTypeLabelGetters = this.editorStore.pluginManager
       .getApplicationPlugins()

package/src/stores/editor/EditorStore.ts

@@ -121,8 +121,8 @@ import {
   LazyTextEditorStore,
 } from '../lazy-text-editor/LazyTextEditorStore.js';
 import type { QueryBuilderDataCubeViewerState } from '@finos/legend-query-builder';
-import { IngestionManager } from '../ingestion/IngestionManager.js';
 import { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
+import { LakehouseIngestionManager } from '@finos/legend-server-lakehouse';
 
 export abstract class EditorExtensionState {
   /**
@@ -138,7 +138,7 @@ export class EditorStore implements CommandRegistrar {
   readonly applicationStore: LegendStudioApplicationStore;
   readonly sdlcServerClient: SDLCServerClient;
   readonly depotServerClient: DepotServerClient;
-  readonly ingestionManager: IngestionManager | undefined;
+  readonly ingestionManager: LakehouseIngestionManager | undefined;
   readonly pluginManager: LegendStudioPluginManager;
 
   /**
@@ -314,9 +314,11 @@ export class EditorStore implements CommandRegistrar {
     const ingestionConifg =
       applicationStore.config.options.ingestDeploymentConfig;
     if (ingestionConifg) {
-      this.ingestionManager = new IngestionManager(
-        ingestionConifg,
-        this.applicationStore,
+      this.ingestionManager = new LakehouseIngestionManager(
+        ingestionConifg.discoveryUrl,
+        ingestionConifg.deployment.defaultServer,
+        ingestionConifg.deployment.useDefaultServer,
+        this.applicationStore.tracerService,
       );
     }
 

package/src/stores/editor/EditorTabManagerState.ts

@@ -37,6 +37,7 @@ import {
   HostedService,
   DataProduct,
   IngestDefinition,
+  MemSQLFunction,
 } from '@finos/legend-graph';
 import {
   type Clazz,
@@ -65,6 +66,7 @@ import { TabManagerState, type TabState } from '@finos/legend-lego/application';
 import { INTERNAL__UnknownFunctionActivatorEdtiorState } from './editor-state/element-editor-state/function-activator/INTERNAL__UnknownFunctionActivatorEditorState.js';
 import { SnowflakeAppFunctionActivatorEdtiorState } from './editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.js';
 import { HostedServiceFunctionActivatorEditorState } from './editor-state/element-editor-state/function-activator/HostedServiceFunctionActivatorEditorState.js';
+import { MemSQLFunctionActivatorEditorState } from './editor-state/element-editor-state/function-activator/MemSQLFunctionActivatorEditorState.js';
 import { ArtifactGenerationViewerState } from './editor-state/ArtifactGenerationViewerState.js';
 import { DataProductEditorState } from './editor-state/element-editor-state/dataProduct/DataProductEditorState.js';
 import { IngestDefinitionEditorState } from './editor-state/element-editor-state/ingest/IngestDefinitionEditorState.js';
@@ -199,6 +201,8 @@ export class EditorTabManagerState extends TabManagerState {
         this.editorStore,
         element,
       );
+    } else if (element instanceof MemSQLFunction) {
+      return new MemSQLFunctionActivatorEditorState(this.editorStore, element);
     } else if (element instanceof INTERNAL__UnknownFunctionActivator) {
       return new INTERNAL__UnknownFunctionActivatorEdtiorState(
         this.editorStore,

package/src/stores/editor/data-cube/LegendStudioDataCubeHelper.ts

@@ -24,6 +24,7 @@ import {
   RawLambda,
   RuntimePointer,
   Service,
+  type ParameterValue,
 } from '@finos/legend-graph';
 import type { EditorStore } from '../EditorStore.js';
 import {
@@ -46,6 +47,8 @@ export const isElementSupportedByDataCube = (
 export const openDataCube = async (
   element: PackageableElement,
   editorStore: EditorStore,
+  parameterValues?: ParameterValue[],
+  letFuncsRawLambda?: RawLambda,
 ): Promise<void> => {
   try {
     let specification: DataCubeSpecification;
@@ -54,12 +57,19 @@ export const openDataCube = async (
     if (element instanceof ConcreteFunctionDefinition) {
       const body = element.expressionSequence;
       const rawLambda = new RawLambda([], body);
+      rawLambda.parameters = element.parameters.map((parameter) =>
+        editorStore.graphManagerState.graphManager.serializeRawValueSpecification(
+          parameter,
+        ),
+      );
       engine = new QueryBuilderDataCubeEngine(
         rawLambda,
-        undefined,
+        parameterValues,
         undefined,
         undefined,
         editorStore.graphManagerState,
+        undefined,
+        letFuncsRawLambda,
       );
       specification = await engine.generateInitialSpecification();
     } else if (element instanceof Service) {
@@ -94,10 +104,12 @@ export const openDataCube = async (
       }
       engine = new QueryBuilderDataCubeEngine(
         exec.func,
-        undefined,
+        parameterValues,
         mapping?.path,
         runtime?.packageableRuntime.value.path,
         editorStore.graphManagerState,
+        undefined,
+        letFuncsRawLambda,
       );
       specification = await engine.generateInitialSpecification();
     } else {

package/src/stores/editor/editor-state/element-editor-state/FunctionActivatorState.ts

@@ -26,6 +26,8 @@ import {
   SnowflakeAppDeploymentConfiguration,
   DeploymentOwner,
   HostedService,
+  MemSQLFunction,
+  MemSQLDeploymentConfiguration,
 } from '@finos/legend-graph';
 import { uuid, type GeneratorFn } from '@finos/legend-shared';
 import { FUNCTION_ACTIVATE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
@@ -116,6 +118,19 @@ export class FunctionActivatorState {
           PackageableElementExplicitReference.create(functionElement);
         return hostedService;
       }
+      case FUNCTION_ACTIVATE_TYPE.MEM_SQL_FUNCTION: {
+        const activatorName = this.activatorPath.includes('::')
+          ? extractElementNameFromPath(this.activatorPath)
+          : this.activatorPath;
+        const memSQLFun = new MemSQLFunction(activatorName);
+        memSQLFun.functionName = '';
+        memSQLFun.description = '';
+        memSQLFun.ownership = new DeploymentOwner('', memSQLFun);
+        memSQLFun.function =
+          PackageableElementExplicitReference.create(functionElement);
+        memSQLFun.activationConfiguration = new MemSQLDeploymentConfiguration();
+        return memSQLFun;
+      }
       default:
         return undefined;
     }

package/src/stores/editor/editor-state/element-editor-state/FunctionEditorState.ts

@@ -68,9 +68,11 @@ import {
   QueryBuilderTelemetryHelper,
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
+  getRawLambdaForLetFuncs,
 } from '@finos/legend-query-builder';
 import { FunctionActivatorState } from './FunctionActivatorState.js';
 import { FunctionTestableState } from './function-activator/testable/FunctionTestableState.js';
+import { openDataCube } from '../../data-cube/LegendStudioDataCubeHelper.js';
 
 export enum FUNCTION_EDITOR_TAB {
   DEFINITION = 'DEFINITION',
@@ -249,6 +251,24 @@ export class FunctionParametersState extends LambdaParametersState {
     );
   }
 
+  openDataCubeModal(
+    query: RawLambda,
+    element: PackageableElement,
+    editorStore: EditorStore,
+  ): void {
+    this.parameterStates = this.build(query);
+    this.parameterValuesEditorState.open(
+      (): Promise<void> =>
+        this.functionEditorState
+          .openingDataCube(element, editorStore)
+          .catch(
+            this.functionEditorState.editorStore.applicationStore
+              .alertUnhandledError,
+          ),
+      PARAMETER_SUBMIT_ACTION.RUN,
+    );
+  }
+
   build(lambda: RawLambda): LambdaParameterState[] {
     const parameters = buildLambdaVariableExpressions(
       lambda,
@@ -531,6 +551,36 @@ export class FunctionEditorState extends ElementEditorState {
     }
   }
 
+  async handleOpeningDataCube(
+    element: PackageableElement,
+    editorStore: EditorStore,
+  ): Promise<void> {
+    const query = this.bodyExpressionSequence;
+    const parameters = (query.parameters ?? []) as object[];
+    if (parameters.length) {
+      this.parametersState.openDataCubeModal(query, element, editorStore);
+    } else {
+      await openDataCube(element, editorStore);
+    }
+  }
+
+  async openingDataCube(
+    element: PackageableElement,
+    editorStore: EditorStore,
+  ): Promise<void> {
+    const params = buildExecutionParameterValues(
+      this.parametersState.parameterStates,
+      this.editorStore.graphManagerState,
+    );
+
+    const letFuncsRawLambda = getRawLambdaForLetFuncs(
+      this.parametersState.parameterStates,
+      this.editorStore.graphManagerState,
+    );
+
+    await openDataCube(element, editorStore, params, letFuncsRawLambda);
+  }
+
   *handleRunFunc(): GeneratorFn<void> {
     if (this.isRunningFunc) {
       return;