@finos/legend-application-studio 28.19.2 → 28.19.4

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/editor/editor-state/element-editor-state/function-activator/SnowflakeM2MUdfFunctionActivatorEditorState.ts

@@ -0,0 +1,143 @@
+/**
+ * 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 PackageableConnection,
+  SnowflakeM2MUdf,
+  ConnectionPointer,
+  InMemoryGraphData,
+  PackageableElementExplicitReference,
+  observe_SnowflakeM2MUdfDeploymentConfiguration,
+  observe_SnowflakeM2MUdf,
+  DeploymentOwner,
+  observe_DeploymentOwnership,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  guaranteeType,
+} from '@finos/legend-shared';
+import { makeObservable, action, flow, computed } from 'mobx';
+import type { EditorStore } from '../../../EditorStore.js';
+import { ElementEditorState } from '../ElementEditorState.js';
+
+export class SnowflakeM2MUdfFunctionActivatorEdtiorState extends ElementEditorState {
+  readonly validateState = ActionState.create();
+  readonly deployState = ActionState.create();
+
+  constructor(editorStore: EditorStore, element: SnowflakeM2MUdf) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      activator: computed,
+      reprocess: action,
+      updateOwnership: action,
+      updateDeploymentSchema: action,
+      updateDeploymentStage: action,
+      updateAppDescription: action,
+      updateUdfName: action,
+      updateConnection: action,
+      validate: flow,
+      deployToSandbox: flow,
+    });
+  }
+
+  get activator(): SnowflakeM2MUdf {
+    return observe_SnowflakeM2MUdf(
+      guaranteeType(
+        this.element,
+        SnowflakeM2MUdf,
+        'Element inside snowflake m2m udf function editor state must be a SnowflakeM2MUdf',
+      ),
+    );
+  }
+
+  updateConnection(val: PackageableConnection): void {
+    this.activator.activationConfiguration.activationConnection =
+      new ConnectionPointer(PackageableElementExplicitReference.create(val));
+    observe_SnowflakeM2MUdfDeploymentConfiguration(
+      this.activator.activationConfiguration,
+    );
+  }
+
+  updateOwnership(val: string): void {
+    this.activator.ownership = new DeploymentOwner(val, this.activator);
+    observe_DeploymentOwnership(this.activator.ownership);
+  }
+
+  updateUdfName(val: string): void {
+    this.activator.udfName = val;
+  }
+
+  updateDeploymentSchema(val: string | undefined): void {
+    this.activator.deploymentSchema = val;
+  }
+
+  updateDeploymentStage(val: string | undefined): void {
+    this.activator.deploymentStage = val;
+  }
+
+  updateAppDescription(val: string): void {
+    this.activator.description = val;
+  }
+
+  *validate(): GeneratorFn<void> {
+    this.validateState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.validateFunctionActivator(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Function activator is valid`,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.validateState.complete();
+    }
+  }
+
+  *deployToSandbox(): GeneratorFn<void> {
+    this.deployState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        'SnowflakeM2MUdf Function Activator has been deployed successfully',
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.deployState.complete();
+    }
+  }
+
+  reprocess(
+    newElement: SnowflakeM2MUdf,
+    editorStore: EditorStore,
+  ): SnowflakeM2MUdfFunctionActivatorEdtiorState {
+    return new SnowflakeM2MUdfFunctionActivatorEdtiorState(
+      editorStore,
+      newElement,
+    );
+  }
+}

package/src/stores/editor/utils/ModelClassifierUtils.ts

@@ -70,6 +70,7 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   SECTION_INDEX = 'SECTION_INDEX',
   DATA = 'DATA',
   SNOWFLAKE_APP = 'SNOWFLAKE_APP',
+  SNOWFLAKE_M2M_UDF = 'SNOWFLAKE_M2M_UDF',
   HOSTED_SERVICE = 'HOSTED_SERVICE',
   MEM_SQL_FUNCTION = 'MEM_SQL_FUNCTION',
   // New Strategical Data Product

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

@@ -136,6 +136,7 @@
     "./src/stores/editor/editor-state/element-editor-state/function-activator/MemSQLFunctionActivatorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/PostDeploymentActionEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/function-activator/SnowflakeM2MUdfFunctionActivatorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts",
     "./src/stores/editor/editor-state/element-editor-state/ingest/IngestDefinitionEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/FlatDataInstanceSetImplementationState.ts",
@@ -198,6 +199,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",
@@ -271,6 +273,7 @@
     "./src/components/editor/editor-group/function-activator/INTERNAL__UnknownFunctionActivatorEdtior.tsx",
     "./src/components/editor/editor-group/function-activator/MemSQLFunctionActivatorEditor.tsx",
     "./src/components/editor/editor-group/function-activator/SnowflakeAppFunctionActivatorEditor.tsx",
+    "./src/components/editor/editor-group/function-activator/SnowflakeM2MUdfFunctionActivatorEditor.tsx",
     "./src/components/editor/editor-group/function-activator/testable/FunctionTestableEditor.tsx",
     "./src/components/editor/editor-group/ingest-editor/IngestDefinitionEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/ClassMappingEditor.tsx",