@finos/legend-application-studio 28.19.1 → 28.19.3

package/src/components/editor/side-bar/CreateNewElementModal.tsx

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { useRef } from 'react';
+import React, { useRef } from 'react';
 import { LEGEND_STUDIO_TEST_ID } from '../../../__lib__/LegendStudioTesting.js';
 import { observer } from 'mobx-react-lite';
 import {
@@ -28,6 +28,7 @@ import {
   CONNECTION_TYPE,
   type RuntimeOption,
   NewLakehouseDataProductDriver,
+  NewRuntimeType,
 } from '../../../stores/editor/NewElementState.js';
 import { Dialog, compareLabelFn, CustomSelectorInput } from '@finos/legend-art';
 import type { EditorStore } from '../../../stores/editor/EditorStore.js';
@@ -178,7 +179,23 @@ const NewRuntimeDriverEditor = observer(() => {
   const newRuntimeDriver = editorStore.newElementState.getNewElementDriver(
     NewPackageableRuntimeDriver,
   );
+  const type = newRuntimeDriver.type;
+  const typeOptions = Object.values(NewRuntimeType).map((typeOption) => ({
+    label: prettyCONSTName(typeOption),
+    value: typeOption,
+  }));
+  const typeOption = {
+    value: type,
+    label: prettyCONSTName(type),
+  };
+  const onTypeChange = (val: {
+    value: NewRuntimeType;
+    label: string;
+  }): void => {
+    newRuntimeDriver.setType(val.value);
+  };
   // mapping
+  const isStandard = type === NewRuntimeType.LEGACY;
   const mapping = newRuntimeDriver.mapping;
   const mappingOptions =
     editorStore.graphManagerState.usableMappings.map(buildElementOption);
@@ -193,22 +210,45 @@ const NewRuntimeDriverEditor = observer(() => {
     }
   };
 
-  if (!mapping) {
-    // TODO: show warning
-    return <div>no mapping found</div>;
-  }
   return (
-    <div className="explorer__new-element-modal__driver">
-      <CustomSelectorInput
-        className="explorer__new-element-modal__driver__dropdown"
-        options={mappingOptions}
-        onChange={onMappingSelectionChange}
-        value={selectedMappingOption}
-        darkMode={
-          !applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled
-        }
-      />
-    </div>
+    <>
+      <div className="panel__content__form__section__header__label">
+        Runtime Type
+      </div>
+      <div className="explorer__new-element-modal__driver">
+        <CustomSelectorInput
+          className="explorer__new-element-modal__driver__dropdown"
+          options={typeOptions}
+          onChange={onTypeChange}
+          value={typeOption}
+          darkMode={
+            !applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled
+          }
+        />
+      </div>
+      {isStandard &&
+        (mapping ? (
+          <>
+            <div className="panel__content__form__section__header__label">
+              Mapping
+            </div>
+            <div className="explorer__new-element-modal__driver">
+              <CustomSelectorInput
+                className="explorer__new-element-modal__driver__dropdown"
+                options={mappingOptions}
+                onChange={onMappingSelectionChange}
+                value={selectedMappingOption}
+                darkMode={
+                  !applicationStore.layoutService
+                    .TEMPORARY__isLightColorThemeEnabled
+                }
+              />
+            </div>
+          </>
+        ) : (
+          <div>no mapping found</div>
+        ))}
+    </>
   );
 });
 

package/src/stores/editor/NewElementState.ts

@@ -39,7 +39,6 @@ import {
 } from './editor-state/GraphGenerationState.js';
 import {
   type PackageableElement,
-  type Runtime,
   type Store,
   ModelStore,
   type Connection,
@@ -85,6 +84,8 @@ import {
   GenericTypeExplicitReference,
   GenericType,
   DataProduct,
+  LakehouseRuntime,
+  type Runtime,
 } from '@finos/legend-graph';
 import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
 import {
@@ -203,8 +204,14 @@ export abstract class NewElementDriver<T extends PackageableElement> {
   abstract createElement(name: string): T;
 }
 
+export enum NewRuntimeType {
+  LEGACY = 'LEGACY',
+  LAKEHOUSE = 'LAKEHOUSE',
+}
+
 export class NewPackageableRuntimeDriver extends NewElementDriver<PackageableRuntime> {
   mapping?: Mapping | undefined;
+  type = NewRuntimeType.LEGACY;
 
   constructor(editorStore: EditorStore) {
     super(editorStore);
@@ -213,24 +220,42 @@ export class NewPackageableRuntimeDriver extends NewElementDriver<PackageableRun
       mapping: observable,
       setMapping: action,
       isValid: computed,
+      type: observable,
+      setType: action,
     });
 
-    const mappings = this.editorStore.graphManagerState.graph.mappings;
-    if (mappings.length) {
-      this.mapping = mappings[0];
+    const firstMapping = this.editorStore.graphManagerState.graph.mappings[0];
+    this.mapping = firstMapping;
+    if (!firstMapping) {
+      this.type = NewRuntimeType.LAKEHOUSE;
     }
   }
 
+  setType(val: NewRuntimeType): void {
+    this.type = val;
+  }
+
   setMapping(mapping: Mapping): void {
     this.mapping = mapping;
   }
 
   get isValid(): boolean {
-    return Boolean(this.mapping);
+    if (this.type === NewRuntimeType.LEGACY) {
+      return Boolean(this.mapping);
+    }
+    return true;
   }
 
   createElement(name: string): PackageableRuntime {
     const runtime = new PackageableRuntime(name);
+    if (this.type === NewRuntimeType.LAKEHOUSE) {
+      const lakehouseRuntime = new LakehouseRuntime();
+      lakehouseRuntime.environment = '';
+      lakehouseRuntime.warehouse = '';
+      lakehouseRuntime.connectionPointer = undefined;
+      runtime.runtimeValue = lakehouseRuntime;
+      return runtime;
+    }
     runtime.runtimeValue = new EngineRuntime();
     runtime_addMapping(
       runtime.runtimeValue,

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

@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
-import { computed, action, observable, makeObservable } from 'mobx';
+import { computed, action, observable, makeObservable, flow } from 'mobx';
 import type { EditorStore } from '../../EditorStore.js';
+import type { IngestDeploymentServerConfig } from '@finos/legend-server-lakehouse';
 import {
   guaranteeType,
   uuid,
@@ -25,6 +26,8 @@ import {
   addUniqueEntry,
   assertErrorThrown,
   filterByType,
+  type GeneratorFn,
+  removeSuffix,
 } from '@finos/legend-shared';
 import { ElementEditorState } from './ElementEditorState.js';
 import type { RuntimeExplorerTreeNodeData } from '../../utils/TreeUtils.js';
@@ -65,6 +68,7 @@ import {
   isStubbed_StoreConnections,
   getAllIdentifiedConnections,
   generateIdentifiedConnectionId,
+  LakehouseRuntime,
 } from '@finos/legend-graph';
 import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
 import { packageableElementReference_setValue } from '../../../graph-modifier/DomainGraphModifierHelper.js';
@@ -76,6 +80,7 @@ import {
   runtime_deleteMapping,
 } from '../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
 import { CUSTOM_LABEL } from '../../NewElementState.js';
+import { lakehouseRuntime_setConnection } from '../../../graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.js';
 
 export const getClassMappingStore = (
   setImplementation: SetImplementation,
@@ -341,11 +346,11 @@ export const getRuntimeExplorerTreeData = (
 export abstract class RuntimeEditorTabState {
   readonly uuid = uuid();
   editorStore: EditorStore;
-  runtimeEditorState: RuntimeEditorState;
+  runtimeEditorState: EngineRuntimeEditorState;
 
   constructor(
     editorStore: EditorStore,
-    runtimeEditorState: RuntimeEditorState,
+    runtimeEditorState: EngineRuntimeEditorState,
   ) {
     this.editorStore = editorStore;
     this.runtimeEditorState = runtimeEditorState;
@@ -375,7 +380,7 @@ export abstract class IdentifiedConnectionsEditorTabState extends RuntimeEditorT
 
   constructor(
     editorStore: EditorStore,
-    runtimeEditorState: RuntimeEditorState,
+    runtimeEditorState: EngineRuntimeEditorState,
   ) {
     super(editorStore, runtimeEditorState);
 
@@ -454,7 +459,7 @@ export class IdentifiedConnectionsPerStoreEditorTabState extends IdentifiedConne
 
   constructor(
     editorStore: EditorStore,
-    runtimeEditorState: RuntimeEditorState,
+    runtimeEditorState: EngineRuntimeEditorState,
     store: Store,
   ) {
     super(editorStore, runtimeEditorState);
@@ -557,7 +562,7 @@ export class IdentifiedConnectionsPerClassEditorTabState extends IdentifiedConne
 
   constructor(
     editorStore: EditorStore,
-    runtimeEditorState: RuntimeEditorState,
+    runtimeEditorState: EngineRuntimeEditorState,
     _class: Class,
   ) {
     super(editorStore, runtimeEditorState);
@@ -641,23 +646,17 @@ export class IdentifiedConnectionsPerClassEditorTabState extends IdentifiedConne
 
 export class RuntimeEditorRuntimeTabState extends RuntimeEditorTabState {}
 
-export class RuntimeEditorState {
-  /**
-   * NOTE: used to force component remount on state change
-   */
-  readonly uuid = uuid();
+export class EngineRuntimeEditorState {
   editorStore: EditorStore;
-  runtime: Runtime;
+  state: RuntimeEditorState;
   runtimeValue: EngineRuntime;
-  isEmbeddedRuntime: boolean;
   explorerTreeData: TreeData<RuntimeExplorerTreeNodeData>;
   currentTabState?: RuntimeEditorTabState | undefined;
 
-  constructor(
-    editorStore: EditorStore,
-    runtime: Runtime,
-    isEmbeddedRuntime: boolean,
-  ) {
+  constructor(state: RuntimeEditorState, value: EngineRuntime) {
+    this.editorStore = state.editorStore;
+    this.state = state;
+    this.runtimeValue = value;
     makeObservable(this, {
       explorerTreeData: observable.ref,
       currentTabState: observable,
@@ -672,17 +671,9 @@ export class RuntimeEditorState {
       reprocessRuntimeExplorerTree: action,
       reprocessCurrentTabState: action,
     });
-
-    this.editorStore = editorStore;
-    this.runtime = runtime;
-    this.isEmbeddedRuntime = isEmbeddedRuntime;
-    this.runtimeValue =
-      runtime instanceof RuntimePointer
-        ? runtime.packageableRuntime.value.runtimeValue
-        : guaranteeType(runtime, EngineRuntime);
     this.explorerTreeData = getRuntimeExplorerTreeData(
-      this.runtime,
-      this.editorStore,
+      this.runtimeValue,
+      this.state.editorStore,
     );
     this.openTabFor(this.runtimeValue); // open runtime tab on init
   }
@@ -855,7 +846,10 @@ export class RuntimeEditorState {
     const openedTreeNodeIds = Array.from(this.explorerTreeData.nodes.values())
       .filter((node) => node.isOpen)
       .map((node) => node.id);
-    const treeData = getRuntimeExplorerTreeData(this.runtime, this.editorStore);
+    const treeData = getRuntimeExplorerTreeData(
+      this.runtimeValue,
+      this.editorStore,
+    );
     openedTreeNodeIds.forEach((nodeId) => {
       const node = treeData.nodes.get(nodeId);
       if (node && !node.isOpen) {
@@ -897,6 +891,126 @@ export class RuntimeEditorState {
   }
 }
 
+export enum LakehouseRuntimeType {
+  ENVIRONMENT = 'ENVIRONMENT',
+  CONNECTION = 'CONNECTION',
+}
+
+export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
+  declare runtimeValue: LakehouseRuntime;
+  availableEnvs: IngestDeploymentServerConfig[] | undefined;
+  lakehouseRuntimeType = LakehouseRuntimeType.ENVIRONMENT;
+
+  constructor(state: RuntimeEditorState, value: LakehouseRuntime) {
+    super(state, value);
+    makeObservable(this, {
+      availableEnvs: observable,
+      fetchLakehouseSummaries: flow,
+      setEnvSummaries: action,
+      lakehouseRuntimeType: observable,
+      setLakehouseRuntimeType: action,
+      envOptions: computed,
+    });
+    this.runtimeValue = value;
+    // fix when metamodel is more clear on this
+    if (value.connectionPointer) {
+      this.lakehouseRuntimeType = LakehouseRuntimeType.CONNECTION;
+    }
+  }
+
+  setLakehouseRuntimeType(val: LakehouseRuntimeType): void {
+    if (val !== this.lakehouseRuntimeType) {
+      this.lakehouseRuntimeType = val;
+      if (val === LakehouseRuntimeType.CONNECTION) {
+        this.runtimeValue.environment = undefined;
+        this.runtimeValue.warehouse = undefined;
+      } else {
+        this.setConnection(undefined);
+      }
+    }
+  }
+
+  setConnection(val: PackageableConnection | undefined): void {
+    lakehouseRuntime_setConnection(this.runtimeValue, val);
+  }
+
+  get envOptions(): { label: string; value: string }[] {
+    return this.availableEnvs?.map((e) => this.convertEnvToOption(e)) ?? [];
+  }
+
+  convertEnvToOption(val: IngestDeploymentServerConfig): {
+    label: string;
+    value: string;
+  } {
+    const discoveryUrlSuffix =
+      this.editorStore.applicationStore.config.options.ingestDeploymentConfig
+        ?.discoveryUrlSuffix;
+    const host = new URL(val.ingestServerUrl).host;
+    const value = discoveryUrlSuffix
+      ? removeSuffix(host, discoveryUrlSuffix)
+      : host;
+    return {
+      label: value,
+      value,
+    };
+  }
+
+  setEnvSummaries(val: IngestDeploymentServerConfig[] | undefined): void {
+    this.availableEnvs = val;
+  }
+
+  *fetchLakehouseSummaries(token?: string | undefined): GeneratorFn<void> {
+    try {
+      const ingestionManager = this.editorStore.ingestionManager;
+      this.setEnvSummaries(undefined);
+      if (ingestionManager) {
+        const res = (yield ingestionManager.fetchLakehouseEnvironmentSummaries(
+          token,
+        )) as unknown as IngestDeploymentServerConfig[] | undefined;
+        this.setEnvSummaries(res);
+        if (!this.runtimeValue.environment && this.envOptions.length) {
+          this.runtimeValue.environment = this.envOptions[0]?.value;
+        }
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+    }
+  }
+}
+
+export class RuntimeEditorState {
+  /**
+   * NOTE: used to force component remount on state change
+   */
+  readonly uuid = uuid();
+  editorStore: EditorStore;
+  runtime: Runtime;
+  runtimeValueEditorState: EngineRuntimeEditorState;
+  isEmbeddedRuntime: boolean;
+
+  constructor(
+    editorStore: EditorStore,
+    runtime: Runtime,
+    isEmbeddedRuntime: boolean,
+  ) {
+    makeObservable(this, {
+      runtimeValueEditorState: observable,
+    });
+
+    this.editorStore = editorStore;
+    this.runtime = runtime;
+    this.isEmbeddedRuntime = isEmbeddedRuntime;
+    const runtimeValue =
+      runtime instanceof RuntimePointer
+        ? runtime.packageableRuntime.value.runtimeValue
+        : guaranteeType(runtime, EngineRuntime);
+    this.runtimeValueEditorState =
+      runtimeValue instanceof LakehouseRuntime
+        ? new LakehouseRuntimeEditorState(this, runtimeValue)
+        : new EngineRuntimeEditorState(this, runtimeValue);
+  }
+}
+
 export class PackageableRuntimeEditorState extends ElementEditorState {
   runtimeEditorState: RuntimeEditorState;
 

package/src/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 {
+  ConnectionPointer,
+  type PackageableConnection,
+  PackageableElementExplicitReference,
+  type LakehouseRuntime,
+} from '@finos/legend-graph';
+import { action } from 'mobx';
+
+export const lakehouseRuntime_setWarehouse = action(
+  (runtime: LakehouseRuntime, warehouse: string | undefined) => {
+    runtime.warehouse = warehouse;
+  },
+);
+
+export const lakehouseRuntime_setEnvironment = action(
+  (runtime: LakehouseRuntime, environment: string | undefined) => {
+    runtime.environment = environment;
+  },
+);
+
+export const lakehouseRuntime_setConnection = action(
+  (
+    runtime: LakehouseRuntime,
+    connection: PackageableConnection | undefined,
+  ) => {
+    runtime.connectionPointer =
+      connection !== undefined
+        ? new ConnectionPointer(
+            PackageableElementExplicitReference.create(connection),
+          )
+        : undefined;
+  },
+);

package/tsconfig.json

@@ -198,6 +198,7 @@
     "./src/stores/graph-modifier/DSL_ExternalFormat_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_FunctionActivator_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_Generation_GraphModifierHelper.ts",
+    "./src/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_Mapping_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_Service_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DomainGraphModifierHelper.ts",