@finos/legend-application-studio 26.0.2 → 26.0.3

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

@@ -0,0 +1,178 @@
+/**
+ * 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 {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
+import type { FunctionEditorState } from './FunctionEditorState.js';
+import {
+  INTERNAL__UnknownFunctionActivator,
+  type FunctionActivatorConfiguration,
+  PackageableElementExplicitReference,
+  buildPath,
+  generateFunctionPrettyName,
+} from '@finos/legend-graph';
+import { ProtocolValueBuilderState } from './ProtocolValueBuilderState.js';
+import {
+  generateEnumerableNameFromToken,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { INTERNAL__UnknownFunctionActivator_setContent } from '../../../graph-modifier/DomainGraphModifierHelper.js';
+
+const BASE_ACTIVATOR_NAME = 'NewActivator';
+export const FUNCTION_ACTIVATOR_EXCLUDED_PATHS = [
+  'meta::protocols::pure::vX_X_X::metamodel::functionActivator::FunctionActivator.function',
+  'meta::protocols::pure::vX_X_X::metamodel::domain::AnnotatedElement.stereotypes',
+  'meta::protocols::pure::vX_X_X::metamodel::domain::AnnotatedElement.taggedValues',
+  'meta::protocols::pure::vX_X_X::metamodel::domain::AnnotatedElement.sourceInformation',
+  'meta::protocols::pure::vX_X_X::metamodel::PackageableElement.sourceInformation',
+  'meta::protocols::pure::vX_X_X::metamodel::PackageableElement.package',
+  'meta::protocols::pure::vX_X_X::metamodel::PackageableElement.name',
+  'meta::protocols::pure::vX_X_X::metamodel::PackageableElement._type',
+];
+
+export class FunctionActivatorBuilderState {
+  readonly functionEditorState: FunctionEditorState;
+
+  currentActivatorConfiguration?: FunctionActivatorConfiguration | undefined;
+  functionActivatorProtocolValueBuilderState?:
+    | ProtocolValueBuilderState
+    | undefined;
+  activatorName = BASE_ACTIVATOR_NAME;
+  functionActivator?: INTERNAL__UnknownFunctionActivator | undefined;
+
+  constructor(functionEditorState: FunctionEditorState) {
+    makeObservable(this, {
+      currentActivatorConfiguration: observable,
+      functionActivatorProtocolValueBuilderState: observable,
+      functionActivator: observable,
+      activatorName: observable,
+      isDuplicated: computed,
+      isValid: computed,
+      setActivatorName: action,
+      setCurrentActivatorConfiguration: action,
+      activate: flow,
+    });
+
+    this.functionEditorState = functionEditorState;
+  }
+
+  get isDuplicated(): boolean {
+    return Boolean(
+      this.functionEditorState.editorStore.graphManagerState.graph.getNullableElement(
+        buildPath(
+          this.functionEditorState.functionElement.package?.path,
+          this.activatorName,
+        ),
+      ),
+    );
+  }
+
+  get isValid(): boolean {
+    if (!this.functionActivator) {
+      return false;
+    }
+    return this.activatorName.length !== 0 && !this.isDuplicated;
+  }
+
+  setActivatorName(val: string): void {
+    this.activatorName = val;
+    if (this.functionActivator) {
+      this.functionActivator.name = val;
+    }
+  }
+
+  setCurrentActivatorConfiguration(
+    val: FunctionActivatorConfiguration | undefined,
+  ): void {
+    this.currentActivatorConfiguration = val;
+    if (val) {
+      this.functionActivatorProtocolValueBuilderState =
+        new ProtocolValueBuilderState(val.configurationType, {
+          graph: val.graph,
+          initialValue: undefined,
+          excludedPaths: FUNCTION_ACTIVATOR_EXCLUDED_PATHS,
+          onValueChange: (value: PlainObject) => {
+            if (this.functionActivator) {
+              INTERNAL__UnknownFunctionActivator_setContent(
+                this.functionActivator,
+                value,
+              );
+            }
+          },
+          decorateValue: (value: PlainObject): PlainObject => {
+            value._type = val.packageableElementJSONType;
+            value.package =
+              this.functionEditorState.functionElement.package?.path;
+            value.name = this.activatorName;
+            value.function = generateFunctionPrettyName(
+              this.functionEditorState.functionElement,
+              {
+                fullPath: true,
+                spacing: false,
+              },
+            ).replaceAll(' ', '');
+            return value;
+          },
+        });
+      this.activatorName = generateEnumerableNameFromToken(
+        this.functionEditorState.functionElement.package?.children.map(
+          (child) => child.name,
+        ) ?? [],
+        BASE_ACTIVATOR_NAME,
+      );
+      this.functionActivator = new INTERNAL__UnknownFunctionActivator(
+        this.activatorName,
+      );
+      this.functionActivator.function =
+        PackageableElementExplicitReference.create(
+          this.functionEditorState.functionElement,
+        );
+      this.functionActivator.content =
+        this.functionActivatorProtocolValueBuilderState.getValue();
+    } else {
+      this.functionActivatorProtocolValueBuilderState = undefined;
+    }
+  }
+
+  *activate(): GeneratorFn<void> {
+    if (!this.isValid || !this.functionActivator) {
+      return;
+    }
+
+    try {
+      yield flowResult(
+        this.functionEditorState.editorStore.graphEditorMode.addElement(
+          this.functionActivator,
+          this.functionEditorState.functionElement.package?.path,
+          true,
+        ),
+      );
+    } catch {
+      this.functionEditorState.editorStore.applicationStore.notificationService.notifyError(
+        `Can't activate function`,
+      );
+    } finally {
+      this.setCurrentActivatorConfiguration(undefined);
+    }
+  }
+}

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

@@ -36,16 +36,18 @@ import {
   isStubbed_PackageableElement,
 } from '@finos/legend-graph';
 import { LambdaEditorState } from '@finos/legend-query-builder';
+import { FunctionActivatorBuilderState } from './FunctionActivatorBuilderState.js';
 
-export enum FUNCTION_SPEC_TAB {
-  GENERAL = 'GENERAL',
+export enum FUNCTION_EDITOR_TAB {
+  DEFINITION = 'DEFINITION',
   TAGGED_VALUES = 'TAGGED_VALUES',
   STEREOTYPES = 'STEREOTYPES',
 }
 
-export class FunctionBodyEditorState extends LambdaEditorState {
-  editorStore: EditorStore;
-  functionElement: ConcreteFunctionDefinition;
+export class FunctionDefinitionEditorState extends LambdaEditorState {
+  readonly editorStore: EditorStore;
+  readonly functionElement: ConcreteFunctionDefinition;
+
   isConvertingFunctionBodyToString = false;
 
   constructor(
@@ -153,8 +155,10 @@ export class FunctionBodyEditorState extends LambdaEditorState {
 }
 
 export class FunctionEditorState extends ElementEditorState {
-  selectedTab: FUNCTION_SPEC_TAB;
-  functionBodyEditorState: FunctionBodyEditorState;
+  readonly functionDefinitionEditorState: FunctionDefinitionEditorState;
+  readonly activatorBuilderState: FunctionActivatorBuilderState;
+
+  selectedTab: FUNCTION_EDITOR_TAB;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {
     super(editorStore, element);
@@ -171,11 +175,12 @@ export class FunctionEditorState extends ElementEditorState {
       ConcreteFunctionDefinition,
       'Element inside function editor state must be a function',
     );
-    this.selectedTab = FUNCTION_SPEC_TAB.GENERAL;
-    this.functionBodyEditorState = new FunctionBodyEditorState(
+    this.selectedTab = FUNCTION_EDITOR_TAB.DEFINITION;
+    this.functionDefinitionEditorState = new FunctionDefinitionEditorState(
       element,
       this.editorStore,
     );
+    this.activatorBuilderState = new FunctionActivatorBuilderState(this);
   }
 
   get functionElement(): ConcreteFunctionDefinition {
@@ -185,7 +190,8 @@ export class FunctionEditorState extends ElementEditorState {
       'Element inside function editor state must be a function',
     );
   }
-  setSelectedTab(tab: FUNCTION_SPEC_TAB): void {
+
+  setSelectedTab(tab: FUNCTION_EDITOR_TAB): void {
     this.selectedTab = tab;
   }
 
@@ -193,8 +199,10 @@ export class FunctionEditorState extends ElementEditorState {
     let revealed = false;
     try {
       if (compilationError.sourceInformation) {
-        this.setSelectedTab(FUNCTION_SPEC_TAB.GENERAL);
-        this.functionBodyEditorState.setCompilationError(compilationError);
+        this.setSelectedTab(FUNCTION_EDITOR_TAB.DEFINITION);
+        this.functionDefinitionEditorState.setCompilationError(
+          compilationError,
+        );
         revealed = true;
       }
     } catch (error) {
@@ -209,7 +217,7 @@ export class FunctionEditorState extends ElementEditorState {
   }
 
   override clearCompilationError(): void {
-    this.functionBodyEditorState.setCompilationError(undefined);
+    this.functionDefinitionEditorState.setCompilationError(undefined);
   }
 
   reprocess(

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

@@ -0,0 +1,136 @@
+/**
+ * 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 {
+  generateFunctionPrettyName,
+  InMemoryGraphData,
+  type INTERNAL__UnknownFunctionActivator,
+} from '@finos/legend-graph';
+import type { EditorStore } from '../../EditorStore.js';
+import { ElementEditorState } from './ElementEditorState.js';
+import { action, flow, makeObservable } from 'mobx';
+import {
+  ActionState,
+  assertErrorThrown,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { ProtocolValueBuilderState } from './ProtocolValueBuilderState.js';
+import { INTERNAL__UnknownFunctionActivator_setContent } from '../../../graph-modifier/DomainGraphModifierHelper.js';
+import { FUNCTION_ACTIVATOR_EXCLUDED_PATHS } from './FunctionActivatorBuilderState.js';
+
+export class INTERNAL__UnknownFunctionActivatorEdtiorState extends ElementEditorState {
+  readonly activator: INTERNAL__UnknownFunctionActivator;
+  readonly validateState = ActionState.create();
+  readonly publishToSandboxState = ActionState.create();
+  protocolValueBuilderState?: ProtocolValueBuilderState | undefined;
+
+  constructor(
+    editorStore: EditorStore,
+    element: INTERNAL__UnknownFunctionActivator,
+  ) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      reprocess: action,
+      validate: flow,
+      publishToSandbox: flow,
+    });
+
+    this.activator = element;
+    const matchingFunctionActivatorConfiguration =
+      this.editorStore.graphState.functionActivatorConfigurations.find(
+        (config) =>
+          config.packageableElementJSONType === this.activator.content._type,
+      );
+    this.protocolValueBuilderState = matchingFunctionActivatorConfiguration
+      ? new ProtocolValueBuilderState(
+          matchingFunctionActivatorConfiguration.configurationType,
+          {
+            graph: matchingFunctionActivatorConfiguration.graph,
+            initialValue: this.activator.content,
+            excludedPaths: FUNCTION_ACTIVATOR_EXCLUDED_PATHS,
+            onValueChange: (value: PlainObject) => {
+              INTERNAL__UnknownFunctionActivator_setContent(
+                this.activator,
+                value,
+              );
+            },
+            decorateValue: (value: PlainObject): PlainObject => {
+              value._type =
+                matchingFunctionActivatorConfiguration.packageableElementJSONType;
+              value.package = this.activator.package?.path;
+              value.name = this.activator.name;
+              value.function = generateFunctionPrettyName(
+                this.activator.function.value,
+                {
+                  fullPath: true,
+                  spacing: false,
+                },
+              ).replaceAll(' ', '');
+              return value;
+            },
+          },
+        )
+      : undefined;
+  }
+
+  *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();
+    }
+  }
+
+  *publishToSandbox(): GeneratorFn<void> {
+    this.publishToSandboxState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Function activator is published to sandbox`,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.publishToSandboxState.complete();
+    }
+  }
+
+  reprocess(
+    newElement: INTERNAL__UnknownFunctionActivator,
+    editorStore: EditorStore,
+  ): INTERNAL__UnknownFunctionActivatorEdtiorState {
+    return new INTERNAL__UnknownFunctionActivatorEdtiorState(
+      editorStore,
+      newElement,
+    );
+  }
+}