@finos/legend-application-studio 22.2.1 → 22.3.0

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

@@ -22,6 +22,7 @@ import {
   type GeneratorFn,
   LogEvent,
   assertErrorThrown,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import {
   type CompilationError,
@@ -30,6 +31,8 @@ import {
   isElementReadOnly,
 } from '@finos/legend-graph';
 import { TAB_SIZE } from '@finos/legend-application';
+import type { ElementFileGenerationState } from './ElementFileGenerationState.js';
+import type { ElementXTSchemaGenerationState } from './ElementExternalFormatGenerationState.js';
 
 const generateMultiLineCommentForError = (
   message: string,
@@ -37,10 +40,64 @@ const generateMultiLineCommentForError = (
 ): string =>
   `/**\n * ${message}. Error: ${error.message.replace(/\n/gu, '\n * ')}\n */`;
 
+export enum ELEMENT_GENERATION_MODE {
+  FILE_GENERATION = 'FILE_GENERATION',
+  EXTERNAL_FORMAT = 'EXTERNAL_FORMAT',
+}
+export abstract class ElementGenerationModeState {
+  elementEditorState: ElementEditorState;
+  editorStore: EditorStore;
+
+  constructor(
+    editorStore: EditorStore,
+    elementEditorState: ElementEditorState,
+  ) {
+    this.elementEditorState = elementEditorState;
+    this.editorStore = editorStore;
+  }
+
+  abstract get label(): string;
+}
+
+export class ExternalFormatElementGenerationViewModeState extends ElementGenerationModeState {
+  generationState: ElementXTSchemaGenerationState;
+
+  constructor(
+    editorStore: EditorStore,
+    elementEditorState: ElementEditorState,
+    generationState: ElementXTSchemaGenerationState,
+  ) {
+    super(editorStore, elementEditorState);
+    this.generationState = generationState;
+  }
+  get label(): string {
+    return this.generationState.description.name;
+  }
+}
+
+export class FileGenerationViewModeState extends ElementGenerationModeState {
+  elementGenerationState: ElementFileGenerationState;
+
+  constructor(
+    editorStore: EditorStore,
+    elementEditorState: ElementEditorState,
+    elementGenerationState: ElementFileGenerationState,
+  ) {
+    super(editorStore, elementEditorState);
+    this.elementGenerationState = elementGenerationState;
+  }
+
+  get label(): string {
+    return this.editorStore.graphState.graphGenerationState.getFileGenerationConfiguration(
+      this.elementGenerationState.fileGenerationType,
+    ).label;
+  }
+}
+
 export abstract class ElementEditorState extends EditorState {
   element: PackageableElement;
   editMode = ELEMENT_NATIVE_VIEW_MODE.FORM;
-  generationViewMode?: string | undefined;
+  generationModeState: ElementGenerationModeState | undefined;
   textContent = '';
   isReadOnly = false;
 
@@ -50,15 +107,15 @@ export abstract class ElementEditorState extends EditorState {
     makeObservable(this, {
       element: observable,
       editMode: observable,
-      generationViewMode: observable,
       textContent: observable,
       isReadOnly: observable,
+      generationModeState: observable,
       label: computed,
       description: computed,
       elementPath: computed,
       setTextContent: action,
       setEditMode: action,
-      setGenerationViewMode: action,
+      changeGenerationModeState: action,
       generateElementProtocol: action,
       generateElementGrammar: flow,
     });
@@ -91,11 +148,39 @@ export abstract class ElementEditorState extends EditorState {
     this.editMode = mode;
     // changing edit mode will clear any existing generation view mode
     // as edit mode always takes precedence
-    this.setGenerationViewMode(undefined);
+    this.setGenerationModeState(undefined);
+  }
+
+  setGenerationModeState(state: ElementGenerationModeState | undefined): void {
+    this.generationModeState = state;
   }
 
-  setGenerationViewMode(mode: string | undefined): void {
-    this.generationViewMode = mode;
+  changeGenerationModeState(mode: string, type: ELEMENT_GENERATION_MODE): void {
+    if (type === ELEMENT_GENERATION_MODE.FILE_GENERATION) {
+      const elementGenerationState =
+        this.editorStore.elementGenerationStates.find(
+          (state) => state.fileGenerationType === mode,
+        );
+      this.setGenerationModeState(
+        new FileGenerationViewModeState(
+          this.editorStore,
+          this,
+          guaranteeNonNullable(elementGenerationState),
+        ),
+      );
+    } else {
+      const xt =
+        this.editorStore.graphState.graphGenerationState.externalFormatState.schemaGenerationStates.find(
+          (e) => e.description.name === mode,
+        );
+      this.setGenerationModeState(
+        new ExternalFormatElementGenerationViewModeState(
+          this.editorStore,
+          this,
+          guaranteeNonNullable(xt),
+        ),
+      );
+    }
   }
 
   generateElementProtocol(): void {

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

@@ -0,0 +1,266 @@
+/**
+ * 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 ExternalFormatDescription,
+  type GenerationProperty,
+  type SchemaSet,
+  GenerationOutput,
+  ConfigurationProperty,
+  ModelUnit,
+  observe_ModelUnit,
+  GenerationPropertyItemType,
+  PackageableElementExplicitReference,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  uuid,
+  assertErrorThrown,
+  LogEvent,
+  isEmpty,
+  deepEqual,
+  AssertionError,
+} from '@finos/legend-shared';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../../EditorStore.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../LegendStudioAppEvent.js';
+import { GENERATION_FILE_ROOT_NAME } from '../../shared/FileSystemTreeUtils.js';
+import {
+  configurationProperty_addConfigurationProperty,
+  configurationProperty_setValue,
+} from '../../shared/modifier/DSL_Generation_GraphModifierHelper.js';
+import { GeneratedFileStructureState } from '../FileGenerationState.js';
+import { ElementEditorState } from './ElementEditorState.js';
+
+export class ExternalFormatConfigurationSpecification {
+  configurationProperties: ConfigurationProperty[] = [];
+  modelUnit: ModelUnit;
+
+  constructor() {
+    makeObservable(this, {
+      configurationProperties: observable,
+    });
+    this.modelUnit = observe_ModelUnit(new ModelUnit());
+  }
+}
+
+const getNullableFileGenerationConfig = (
+  config: ExternalFormatConfigurationSpecification,
+  name: string,
+): ConfigurationProperty | undefined =>
+  config.configurationProperties.find((property) => name === property.name);
+
+export class XTGenerationState extends GeneratedFileStructureState {
+  readonly elementXTSchemaGenerationState: ElementXTSchemaGenerationState;
+  readonly configSpecification: ExternalFormatConfigurationSpecification;
+
+  constructor(
+    elementXTSchemaGenerationState: ElementXTSchemaGenerationState,
+    fileGeneration: ExternalFormatConfigurationSpecification,
+  ) {
+    super(
+      GENERATION_FILE_ROOT_NAME,
+      elementXTSchemaGenerationState.editorStore,
+    );
+    makeObservable(this, {
+      configSpecification: observable,
+      resetGenerator: action,
+      updateFileGenerationParameters: action,
+      generate: flow,
+    });
+    this.elementXTSchemaGenerationState = elementXTSchemaGenerationState;
+    this.configSpecification = fileGeneration;
+  }
+
+  get rootFolder(): string {
+    return '';
+  }
+
+  get generationParentId(): undefined {
+    return undefined;
+  }
+
+  resetGenerator(): void {
+    this.configSpecification.configurationProperties = [];
+  }
+
+  *generate(): GeneratorFn<void> {
+    this.generatingAction.inProgress();
+    try {
+      const modelUnit = this.configSpecification.modelUnit;
+      const properties = [...this.configSpecification.configurationProperties];
+      this.addInferredConfigurationProperties(properties);
+      const result =
+        (yield this.editorStore.graphManagerState.graphManager.generateSchemaFromExternalFormatConfig(
+          modelUnit,
+          undefined,
+          properties,
+          this.editorStore.graphManagerState.graph,
+        )) as SchemaSet[];
+      const output = result
+        .map((schemaSet) =>
+          schemaSet.schemas.map((e) => {
+            const o = new GenerationOutput();
+            o.content = e.content;
+            o.fileName = e.location ?? '';
+            o.format = schemaSet.format;
+            return o;
+          }),
+        )
+        .flat();
+      this.processGenerationResult(output);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.fileSystemState.selectedNode = undefined;
+      this.processGenerationResult([]);
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notifyError(error);
+    } finally {
+      this.generatingAction.complete();
+    }
+  }
+
+  addInferredConfigurationProperties(
+    properties: ConfigurationProperty[],
+  ): void {
+    const SCHEMA_FORMAT_PROPERTY_NAME = 'format';
+    if (!properties.find((e) => e.name === SCHEMA_FORMAT_PROPERTY_NAME)) {
+      const genProperty = new ConfigurationProperty(
+        SCHEMA_FORMAT_PROPERTY_NAME,
+        this.elementXTSchemaGenerationState.description.name,
+      );
+      properties.push(genProperty);
+    }
+    this.elementXTSchemaGenerationState.description.schemaGenerationProperties
+      .filter(
+        (property) =>
+          property.required &&
+          property.defaultValue &&
+          !properties.find((pv) => pv.name === property.name),
+      )
+      .forEach((toAdd) => {
+        const value = new ConfigurationProperty(toAdd.name, toAdd.defaultValue);
+        configurationProperty_addConfigurationProperty(properties, value);
+      });
+  }
+
+  updateFileGenerationParameters(
+    config: ExternalFormatConfigurationSpecification,
+    generationProperty: GenerationProperty,
+    newValue: unknown,
+  ): void {
+    if (generationProperty.type === GenerationPropertyItemType.MAP) {
+      if (
+        !newValue ||
+        isEmpty(newValue) ||
+        deepEqual(newValue, generationProperty.defaultValue)
+      ) {
+        config.configurationProperties = config.configurationProperties.filter(
+          (e) => e.name !== generationProperty.name,
+        );
+      } else {
+        const configProperty = getNullableFileGenerationConfig(
+          config,
+          generationProperty.name,
+        );
+        if (configProperty) {
+          configurationProperty_setValue(configProperty, {
+            ...(newValue as object),
+          });
+        } else {
+          const newItem = new ConfigurationProperty(
+            generationProperty.name,
+            newValue,
+          );
+          configurationProperty_addConfigurationProperty(
+            config.configurationProperties,
+            newItem,
+          );
+        }
+      }
+    } else {
+      const configProperty = getNullableFileGenerationConfig(
+        config,
+        generationProperty.name,
+      );
+      let useDefaultValue = generationProperty.defaultValue === newValue;
+      if (generationProperty.type === GenerationPropertyItemType.BOOLEAN) {
+        useDefaultValue =
+          (generationProperty.defaultValue === 'true') ===
+          (newValue as boolean);
+      }
+      const newConfigValue = useDefaultValue ? undefined : newValue;
+      if (newConfigValue !== undefined) {
+        if (configProperty) {
+          configurationProperty_setValue(configProperty, newConfigValue);
+        } else {
+          const newItem = new ConfigurationProperty(
+            generationProperty.name,
+            newConfigValue,
+          );
+          configurationProperty_addConfigurationProperty(
+            config.configurationProperties,
+            newItem,
+          );
+        }
+      } else {
+        config.configurationProperties = config.configurationProperties.filter(
+          (e) => e.name !== generationProperty.name,
+        );
+      }
+    }
+  }
+}
+
+export class ElementXTSchemaGenerationState {
+  readonly uuid = uuid();
+  editorStore: EditorStore;
+  description: ExternalFormatDescription;
+  xtGenerationState: XTGenerationState;
+
+  constructor(
+    editorStore: EditorStore,
+    description: ExternalFormatDescription,
+  ) {
+    makeObservable(this, {
+      xtGenerationState: observable,
+      regenerate: flow,
+    });
+    this.editorStore = editorStore;
+    this.description = description;
+
+    this.xtGenerationState = new XTGenerationState(
+      this,
+      new ExternalFormatConfigurationSpecification(),
+    );
+  }
+
+  *regenerate(): GeneratorFn<void> {
+    const currentState = this.editorStore.tabManagerState.currentTab;
+    if (currentState instanceof ElementEditorState) {
+      this.xtGenerationState.configSpecification.modelUnit.packageableElementIncludes =
+        [PackageableElementExplicitReference.create(currentState.element)];
+      yield flowResult(this.xtGenerationState.generate());
+    } else {
+      throw new AssertionError(
+        'Generation state must have at least an element editor opened',
+      );
+    }
+  }
+}

package/src/stores/editor-state/element-editor-state/mapping/MappingExecutionState.ts

@@ -760,7 +760,7 @@ export class MappingExecutionState extends MappingEditorTabState {
       ) {
         this.isExecuting = true;
         const result =
-          (yield this.editorStore.graphManagerState.graphManager.executeMapping(
+          (yield this.editorStore.graphManagerState.graphManager.runQuery(
             query,
             this.mappingEditorState.mapping,
             runtime,

package/src/stores/editor-state/element-editor-state/mapping/MappingTestState.ts

@@ -647,7 +647,7 @@ export class MappingTestState extends MappingEditorTabState {
       const runtime = this.inputDataState.runtime;
       this.isExecutingTest = true;
       const result =
-        (yield this.editorStore.graphManagerState.graphManager.executeMapping(
+        (yield this.editorStore.graphManagerState.graphManager.runQuery(
           query,
           this.mappingEditorState.mapping,
           runtime,
@@ -707,7 +707,7 @@ export class MappingTestState extends MappingEditorTabState {
     try {
       const runtime = this.inputDataState.runtime;
       this.isRunningTest = true;
-      promise = this.editorStore.graphManagerState.graphManager.executeMapping(
+      promise = this.editorStore.graphManagerState.graphManager.runQuery(
         this.test.query,
         this.mappingEditorState.mapping,
         runtime,

package/src/stores/editor-state/element-editor-state/service/ServiceEditorState.ts

@@ -14,8 +14,13 @@
  * limitations under the License.
  */
 
-import { observable, computed, action, makeObservable } from 'mobx';
-import { guaranteeType } from '@finos/legend-shared';
+import { observable, computed, action, makeObservable, flow } from 'mobx';
+import {
+  type GeneratorFn,
+  type PlainObject,
+  assertErrorThrown,
+  guaranteeType,
+} from '@finos/legend-shared';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
   type ServiceExecutionState,
@@ -33,6 +38,7 @@ import {
   PureMultiExecution,
 } from '@finos/legend-graph';
 import { ServiceTestableState } from './testable/ServiceTestableState.js';
+import { User } from '@finos/legend-server-sdlc';
 
 export enum SERVICE_TAB {
   GENERAL = 'GENERAL',
@@ -59,6 +65,7 @@ export class ServiceEditorState extends ElementEditorState {
       resetExecutionState: action,
       service: computed,
       reprocess: action,
+      searchUsers: flow,
     });
 
     this.executionState = this.buildExecutionState();
@@ -119,6 +126,20 @@ export class ServiceEditorState extends ElementEditorState {
     );
   }
 
+  *searchUsers(name: string): GeneratorFn<User[]> {
+    try {
+      return (
+        (yield this.editorStore.sdlcServerClient.getUsers(
+          name,
+        )) as PlainObject<User>[]
+      ).map((p) => User.serialization.fromJson(p));
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(error);
+      return [];
+    }
+  }
+
   reprocess(
     newElement: PackageableElement,
     editorStore: EditorStore,