@finos/legend-application-studio 21.0.1 → 22.1.0

package/src/stores/editor-state/ProjectConfigurationEditorState.ts

@@ -42,14 +42,16 @@ import {
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
 import {
-  type ProjectVersionDependencies,
+  type ProjectDependencyGraphReport,
+  type ProjectDependencyVersionNode,
   MASTER_SNAPSHOT_ALIAS,
   ProjectData,
-  ProjectDependencyInfo,
   ProjectDependencyCoordinates,
+  RawProjectDependencyReport,
+  buildDependencyReport,
+  buildConflictsPaths,
 } from '@finos/legend-server-depot';
-import { TAB_SIZE } from '@finos/legend-application';
-import { generateGAVCoordinates } from '@finos/legend-storage';
+import type { TreeData, TreeNodeData } from '@finos/legend-art';
 
 export enum CONFIGURATION_EDITOR_TAB {
   PROJECT_STRUCTURE = 'PROJECT_STRUCTURE',
@@ -57,61 +59,65 @@ export enum CONFIGURATION_EDITOR_TAB {
   PLATFORM_CONFIGURATIONS = 'PLATFORM_CONFIGURATIONS',
 }
 
-export enum DEPENDENCY_INFO_TYPE {
-  DEPENDENCY_TREE = 'dependency tree',
-  CONFLICTS = 'conflicts',
+export class DependencyTreeNodeData implements TreeNodeData {
+  value: ProjectDependencyVersionNode;
+  id: string;
+  label: string;
+  childrenIds?: string[] | undefined;
+
+  constructor(id: string, value: ProjectDependencyVersionNode) {
+    this.id = id;
+    this.value = value;
+    this.label = value.id;
+  }
+  isSelected?: boolean | undefined;
+  isOpen?: boolean | undefined;
 }
 
-const getDependencyTreeString = (
-  dependant: ProjectVersionDependencies,
-  tab: string,
-): string => {
-  const prefix = tab + (dependant.dependencies.length ? '+-' : '\\-');
-  const gav = generateGAVCoordinates(
-    dependant.groupId,
-    dependant.artifactId,
-    dependant.versionId,
-  );
-  return `${prefix + gav}\n${dependant.dependencies
-    .map((e) => getDependencyTreeString(e, tab + ' '.repeat(TAB_SIZE)))
-    .join('')}`;
+export const buildDependencyNodeChildren = (
+  parentNode: DependencyTreeNodeData,
+  treeNodes: Map<string, DependencyTreeNodeData>,
+): void => {
+  if (!parentNode.childrenIds) {
+    const value = parentNode.value;
+    const childrenNodes = value.dependencies.map((projectVersion) => {
+      const childId = `${parentNode.id}.${projectVersion.id}`;
+      const childNode = new DependencyTreeNodeData(childId, projectVersion);
+      treeNodes.set(childId, childNode);
+      return childNode;
+    });
+    parentNode.childrenIds = childrenNodes.map((c) => c.id);
+  }
 };
 
-export const getDependencyTreeStringFromInfo = (
-  info: ProjectDependencyInfo,
-): string => info.tree.map((e) => getDependencyTreeString(e, '')).join('\n');
-
-const getConflictPathString = (path: string): string => {
-  const seperator = '>';
-  const projects = path.split(seperator);
-  let result = '';
-  let currentTab = ' '.repeat(TAB_SIZE);
-  projects.forEach((p) => {
-    result += `${currentTab + p}\n`;
-    currentTab = currentTab + ' '.repeat(TAB_SIZE);
+const buildDependencyTreeData = (
+  report: ProjectDependencyGraphReport,
+): TreeData<DependencyTreeNodeData> => {
+  const nodes = new Map<string, DependencyTreeNodeData>();
+  const rootNodes = report.graph.rootNodes.map((versionNode) => {
+    const node = new DependencyTreeNodeData(versionNode.id, versionNode);
+    nodes.set(node.id, node);
+    buildDependencyNodeChildren(node, nodes);
+    return node;
   });
-  return result;
+  const rootIds = rootNodes.map((node) => node.id);
+  return { rootIds, nodes };
 };
 
-export const getConflictsString = (info: ProjectDependencyInfo): string =>
-  info.conflicts
-    .map((c) => {
-      const base = `project:\n${
-        ' '.repeat(TAB_SIZE) +
-        generateGAVCoordinates(c.groupId, c.artifactId, undefined)
-      }`;
-      const versions = `versions:\n${c.versions
-        .map((v) => ' '.repeat(TAB_SIZE) + v)
-        .join('\n')}`;
-      const paths = `paths:\n${c.conflictPaths
-        .map(
-          (p, idx) =>
-            `${' '.repeat(TAB_SIZE) + (idx + 1)}:\n${getConflictPathString(p)}`,
-        )
-        .join('')}`;
-      return `${base}\n${versions}\n${paths}`;
-    })
-    .join('\n\n');
+const buildFlattenDependencyTreeData = (
+  report: ProjectDependencyGraphReport,
+): TreeData<DependencyTreeNodeData> => {
+  const nodes = new Map<string, DependencyTreeNodeData>();
+  const rootIds: string[] = [];
+  Array.from(report.graph.nodes.entries()).forEach(([key, value]) => {
+    const id = value.id;
+    const node = new DependencyTreeNodeData(id, value);
+    nodes.set(id, node);
+    rootIds.push(id);
+    buildDependencyNodeChildren(node, nodes);
+  });
+  return { rootIds, nodes };
+};
 
 export class ProjectConfigurationEditorState extends EditorState {
   sdlcState: EditorSDLCState;
@@ -122,8 +128,11 @@ export class ProjectConfigurationEditorState extends EditorState {
   projects = new Map<string, ProjectData>();
   queryHistory = new Set<string>();
   latestProjectStructureVersion: ProjectStructureVersion | undefined;
-  dependencyInfo: ProjectDependencyInfo | undefined;
-  dependencyInfoModalType: DEPENDENCY_INFO_TYPE | undefined;
+  dependencyReport: ProjectDependencyGraphReport | undefined;
+  dependencyTreeData: TreeData<DependencyTreeNodeData> | undefined;
+  flattenDependencyTreeData: TreeData<DependencyTreeNodeData> | undefined;
+  dependencyTreeReportModal = false;
+  dependencyConflictModal = false;
   fetchingDependencyInfoState = ActionState.create();
   updatingConfigurationState = ActionState.create();
   fetchingProjectVersionsState = ActionState.create();
@@ -143,14 +152,20 @@ export class ProjectConfigurationEditorState extends EditorState {
       associatedProjectsAndVersionsFetched: observable,
       fetchingProjectVersionsState: observable,
       latestProjectStructureVersion: observable,
-      dependencyInfo: observable,
-      dependencyInfoModalType: observable,
+      dependencyReport: observable,
+      dependencyTreeReportModal: observable,
       fetchingDependencyInfoState: observable,
+      dependencyConflictModal: observable,
+      dependencyTreeData: observable.ref,
+      flattenDependencyTreeData: observable.ref,
       originalConfig: computed,
       setOriginalProjectConfiguration: action,
+      setDependencyConflictModal: action,
+      clearTrees: action,
       setProjectConfiguration: action,
-      setDependencyInfoModal: action,
+      setDependencyTreeReportModal: action,
       setSelectedTab: action,
+      setDependencyTreeData: action,
       fectchAssociatedProjectsAndVersions: flow,
       updateProjectConfiguration: flow,
       updateToLatestStructure: flow,
@@ -178,15 +193,36 @@ export class ProjectConfigurationEditorState extends EditorState {
     this.selectedTab = tab;
   }
 
-  setDependencyInfoModal(type: DEPENDENCY_INFO_TYPE | undefined): void {
-    this.dependencyInfoModalType = type;
+  setDependencyConflictModal(showModal: boolean): void {
+    this.dependencyConflictModal = showModal;
+  }
+
+  setDependencyTreeReportModal(showModal: boolean): void {
+    this.dependencyTreeReportModal = showModal;
+  }
+
+  setFlattenDependencyTreeData(
+    tree: TreeData<DependencyTreeNodeData> | undefined,
+  ): void {
+    this.flattenDependencyTreeData = tree;
+  }
+
+  clearTrees(): void {
+    this.flattenDependencyTreeData = undefined;
+    this.dependencyTreeData = undefined;
+  }
+
+  setDependencyTreeData(
+    tree: TreeData<DependencyTreeNodeData> | undefined,
+  ): void {
+    this.dependencyTreeData = tree;
   }
 
   get label(): string {
     return 'config';
   }
 
-  match(tab: EditorState): boolean {
+  override match(tab: EditorState): boolean {
     return tab instanceof ProjectConfigurationEditorState;
   }
 
@@ -256,7 +292,8 @@ export class ProjectConfigurationEditorState extends EditorState {
   *fetchDependencyInfo(): GeneratorFn<void> {
     try {
       this.fetchingDependencyInfoState.inProgress();
-      this.dependencyInfo = undefined;
+      this.dependencyReport = undefined;
+      this.clearTrees();
       if (this.projectConfiguration?.projectDependencies) {
         const dependencyCoordinates = (yield flowResult(
           this.editorStore.graphState.buildProjectDependencyCoordinates(
@@ -268,17 +305,18 @@ export class ProjectConfigurationEditorState extends EditorState {
             dependencyCoordinates.map((e) =>
               ProjectDependencyCoordinates.serialization.toJson(e),
             ),
-          )) as PlainObject<ProjectDependencyInfo>;
-        this.dependencyInfo =
-          ProjectDependencyInfo.serialization.fromJson(dependencyInfoRaw);
-      } else {
-        this.dependencyInfo = new ProjectDependencyInfo();
+          )) as PlainObject<RawProjectDependencyReport>;
+        const rawdependencyReport =
+          RawProjectDependencyReport.serialization.fromJson(dependencyInfoRaw);
+        const report = buildDependencyReport(rawdependencyReport);
+        this.dependencyReport = report;
+        this.processReport(report);
       }
       this.fetchingDependencyInfoState.complete();
     } catch (error) {
       assertErrorThrown(error);
       this.fetchingDependencyInfoState.fail();
-      this.dependencyInfo = undefined;
+      this.dependencyReport = undefined;
       this.editorStore.applicationStore.log.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.DEPOT_MANAGER_FAILURE),
         error,
@@ -286,6 +324,19 @@ export class ProjectConfigurationEditorState extends EditorState {
     }
   }
 
+  processReport(report: ProjectDependencyGraphReport): void {
+    this.setDependencyTreeData(buildDependencyTreeData(report));
+    this.setFlattenDependencyTreeData(buildFlattenDependencyTreeData(report));
+    try {
+      report.conflictPaths = buildConflictsPaths(report);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(
+        `Unable to build conflict paths ${error.message}`,
+      );
+    }
+  }
+
   *updateProjectConfiguration(
     updateConfigurationCommand: UpdateProjectConfigurationCommand,
   ): GeneratorFn<void> {

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

@@ -74,7 +74,7 @@ export abstract class ElementEditorState extends EditorState {
     return this.element.path;
   }
 
-  match(tab: EditorState): boolean {
+  override match(tab: EditorState): boolean {
     return tab instanceof ElementEditorState && tab.element === this.element;
   }
 
@@ -158,6 +158,10 @@ export abstract class ElementEditorState extends EditorState {
     return;
   }
 
+  override onOpen(): void {
+    this.editorStore.explorerTreeState.openNode(this.element);
+  }
+
   /**
    * Clone the element editor state to be replaced as processing graph
    *

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

@@ -22,6 +22,7 @@ import {
   UnsupportedServiceExecutionState,
   SingleServicePureExecutionState,
   MultiServicePureExecutionState,
+  InlineServicePureExecutionState,
 } from './ServiceExecutionState.js';
 import { ServiceRegistrationState } from '../../../editor-state/element-editor-state/service/ServiceRegistrationState.js';
 import { ElementEditorState } from '../../../editor-state/element-editor-state/ElementEditorState.js';
@@ -80,12 +81,22 @@ export class ServiceEditorState extends ElementEditorState {
 
   buildExecutionState(): ServiceExecutionState {
     const execution = this.service.execution;
-    if (execution instanceof PureSingleExecution) {
+    if (
+      execution instanceof PureSingleExecution &&
+      execution.mapping &&
+      execution.runtime
+    ) {
       return new SingleServicePureExecutionState(
         this.editorStore,
         this,
         execution,
       );
+    } else if (execution instanceof PureSingleExecution) {
+      return new InlineServicePureExecutionState(
+        this.editorStore,
+        this,
+        execution,
+      );
     } else if (execution instanceof PureMultiExecution) {
       return new MultiServicePureExecutionState(
         this.editorStore,

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

@@ -23,6 +23,7 @@ import {
   stringifyLosslessJSON,
   UnsupportedOperationError,
   filterByType,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import type { ServiceEditorState } from './ServiceEditorState.js';
 import {
@@ -394,13 +395,21 @@ export abstract class ServiceExecutionContextState {
 }
 
 export class SingleExecutionContextState extends ServiceExecutionContextState {
-  declare executionContext: PureSingleExecution;
+  declare executionContext1: PureSingleExecution;
 
   constructor(
     executionContext: PureSingleExecution,
     executionState: ServiceExecutionState,
   ) {
-    super(executionContext, executionState);
+    super(
+      {
+        mapping:
+          executionContext.mapping as PackageableElementReference<Mapping>,
+        runtime: executionContext.runtime as Runtime,
+      },
+      executionState,
+    );
+    this.executionContext1 = executionContext;
     makeObservable(this, {
       executionContext: observable,
       setMapping: action,
@@ -409,15 +418,18 @@ export class SingleExecutionContextState extends ServiceExecutionContextState {
   }
 
   setMapping(value: Mapping): void {
+    this.executionContext.mapping =
+      PackageableElementExplicitReference.create(value);
     pureSingleExecution_setMapping(
-      this.executionContext,
+      this.executionContext1,
       value,
       this.executionState.editorStore.changeDetectionState.observerContext,
     );
   }
   setRuntime(value: Runtime): void {
+    this.executionContext.runtime = value;
     pureSingleExecution_setRuntime(
-      this.executionContext,
+      this.executionContext1,
       value,
       this.executionState.editorStore.changeDetectionState.observerContext,
     );
@@ -656,21 +668,22 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   }
 
   useCustomRuntime(): void {
-    if (this.selectedExecutionContextState) {
-      const customRuntime = new EngineRuntime();
-      runtime_addMapping(
-        customRuntime,
-        PackageableElementExplicitReference.create(
-          this.selectedExecutionContextState.executionContext.mapping.value,
-        ),
-      );
-      decorateRuntimeWithNewMapping(
-        this.selectedExecutionContextState.executionContext.runtime,
-        this.selectedExecutionContextState.executionContext.mapping.value,
-        this.editorStore,
-      );
-      this.selectedExecutionContextState.setRuntime(customRuntime);
-    }
+    const customRuntime = new EngineRuntime();
+    guaranteeNonNullable(this.selectedExecutionContextState);
+    const executionState = this
+      .selectedExecutionContextState as ServiceExecutionContextState;
+    runtime_addMapping(
+      customRuntime,
+      PackageableElementExplicitReference.create(
+        executionState.executionContext.mapping.value,
+      ),
+    );
+    decorateRuntimeWithNewMapping(
+      executionState.executionContext.runtime,
+      executionState.executionContext.mapping.value,
+      this.editorStore,
+    );
+    executionState.setRuntime(customRuntime);
   }
 
   autoSelectRuntimeOnMappingChange(mapping: Mapping): void {
@@ -697,6 +710,48 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   }
 }
 
+export class InlineServicePureExecutionState extends ServicePureExecutionState {
+  declare execution: PureSingleExecution;
+
+  constructor(
+    editorStore: EditorStore,
+    serviceEditorState: ServiceEditorState,
+    execution: PureSingleExecution,
+  ) {
+    super(editorStore, serviceEditorState, execution);
+
+    makeObservable(this, {
+      queryState: observable,
+      isRunningQuery: observable,
+      isGeneratingPlan: observable,
+      isOpeningQueryEditor: observable,
+      executionResultText: observable,
+      executionPlanState: observable,
+      showChangeExecModal: observable,
+      parameterState: observable,
+      setExecutionResultText: action,
+      setQueryState: action,
+      updateExecutionQuery: action,
+      setOpeningQueryEditor: action,
+      generatePlan: flow,
+      handleExecute: flow,
+      runQuery: flow,
+    });
+    this.selectedExecutionContextState =
+      this.getInitiallySelectedExecutionContextState();
+  }
+
+  changeExecution(): void {
+    throw new Error('Method not implemented.');
+  }
+
+  getInitiallySelectedExecutionContextState():
+    | ServiceExecutionContextState
+    | undefined {
+    return undefined;
+  }
+}
+
 export class SingleServicePureExecutionState extends ServicePureExecutionState {
   declare execution: PureSingleExecution;
   declare selectedExecutionContextState: ServiceExecutionContextState;
@@ -754,23 +809,25 @@ export class SingleServicePureExecutionState extends ServicePureExecutionState {
   }
 
   changeExecution(): void {
-    const _execution = new PureMultiExecution(
-      this.multiExecutionKey,
-      this.execution.func,
-      this.serviceEditorState.service,
-    );
-    const _parameter = new KeyedExecutionParameter(
-      `execContext_1`,
-      this.execution.mapping,
-      this.execution.runtime,
-    );
-    _execution.executionParameters = [_parameter];
-    service_setExecution(
-      this.serviceEditorState.service,
-      _execution,
-      this.editorStore.changeDetectionState.observerContext,
-    );
-    this.serviceEditorState.resetExecutionState();
+    if (this.execution.mapping && this.execution.runtime) {
+      const _execution = new PureMultiExecution(
+        this.multiExecutionKey,
+        this.execution.func,
+        this.serviceEditorState.service,
+      );
+      const _parameter = new KeyedExecutionParameter(
+        `execContext_1`,
+        this.execution.mapping,
+        this.execution.runtime,
+      );
+      _execution.executionParameters = [_parameter];
+      service_setExecution(
+        this.serviceEditorState.service,
+        _execution,
+        this.editorStore.changeDetectionState.observerContext,
+      );
+      this.serviceEditorState.resetExecutionState();
+    }
   }
 }
 

package/src/stores/editor-state/element-editor-state/service/testable/ServiceTestDataState.ts

@@ -196,7 +196,7 @@ export class ConnectionTestDataState {
         .service;
     const execution = service.execution;
     let runtimes: Runtime[] = [];
-    if (execution instanceof PureSingleExecution) {
+    if (execution instanceof PureSingleExecution && execution.runtime) {
       runtimes = [execution.runtime];
     } else if (execution instanceof PureMultiExecution) {
       runtimes = execution.executionParameters.map((t) => t.runtime);
@@ -366,7 +366,10 @@ export class ServiceTestDataState {
       this.testSuiteState.testableState.serviceEditorState.service;
     const execution = service.execution;
     let runtimes: Runtime[] = [];
-    if (execution instanceof PureSingleExecution) {
+    if (
+      execution instanceof PureSingleExecution &&
+      execution.runtime !== undefined
+    ) {
       runtimes = [execution.runtime];
     } else if (execution instanceof PureMultiExecution) {
       runtimes = execution.executionParameters.map((t) => t.runtime);

package/src/stores/editor-state/element-editor-state/service/testable/ServiceTestEditorState.ts

@@ -52,19 +52,20 @@ import { generateVariableExpressionMockValue } from '@finos/legend-query-builder
 
 export enum SERIALIZATION_FORMAT {
   PURE = 'PURE',
-  // Temporary remove this option as it is currently not being read correctly.
-  // See https://github.com/finos/legend-engine/pull/799
-  // DEFAULT = 'DEFAULT',
+  DEFAULT = 'DEFAULT',
   PURE_TDSOBJECT = 'PURE_TDSOBJECT',
 }
 
 export enum SERIALIZATION_FORMAT_LABEL {
+  DEFAULT = 'DEFAULT',
   PURE = 'PURE',
   TDS = 'TDS',
 }
 
 const getSerializationFormatLabel = (val: string): string => {
   switch (val) {
+    case SERIALIZATION_FORMAT.DEFAULT:
+      return SERIALIZATION_FORMAT.DEFAULT;
     case SERIALIZATION_FORMAT.PURE:
       return SERIALIZATION_FORMAT.PURE;
     case SERIALIZATION_FORMAT.PURE_TDSOBJECT:
@@ -365,7 +366,10 @@ export class ServiceTestSetupState {
         label: getSerializationFormatLabel(test.serializationFormat),
       };
     }
-    return undefined;
+    return {
+      value: SERIALIZATION_FORMAT.DEFAULT,
+      label: SERIALIZATION_FORMAT.DEFAULT,
+    };
   }
 
   changeSerializationFormat(val: string | undefined): void {

package/src/stores/editor-state/entity-diff-editor-state/EntityChangeConflictEditorState.ts

@@ -328,7 +328,7 @@ export class EntityChangeConflictEditorState extends EntityDiffViewerState {
     );
   }
 
-  match(tab: EditorState): boolean {
+  override match(tab: EditorState): boolean {
     return (
       tab instanceof EntityChangeConflictEditorState &&
       tab.entityPath === this.entityPath

package/src/stores/editor-state/entity-diff-editor-state/EntityDiffViewState.ts

@@ -177,7 +177,7 @@ export class EntityDiffViewState extends EntityDiffViewerState {
     this.fromGrammarText = text;
   }
 
-  match(tab: EditorState): boolean {
+  override match(tab: EditorState): boolean {
     return (
       tab instanceof EntityDiffViewState &&
       tab.fromEntityPath === this.fromEntityPath &&

package/src/stores/shared/FileGenerationTreeUtils.ts

@@ -20,13 +20,15 @@ import {
   returnUndefOnError,
   addUniqueEntry,
 } from '@finos/legend-shared';
-import type { GenerationOutput } from '@finos/legend-graph';
+import {
+  DIRECTORY_PATH_DELIMITER,
+  type GenerationOutput,
+} from '@finos/legend-graph';
 
 export interface GenerationOutputResult {
   generationOutput: GenerationOutput;
   parentId?: string | undefined;
 }
-export const DIRECTORY_PATH_DELIMITER = '/';
 export const GENERATION_FILE_ROOT_NAME = 'GENERATION_FILE_ROOT';
 
 // Generation Directory Model

package/src/stores/shared/modifier/DSL_Service_GraphModifierHelper.ts

@@ -208,7 +208,9 @@ export const pureSingleExecution_setMapping = action(
     value: Mapping,
     observerContext: ObserverContext,
   ): void => {
-    pe.mapping.value = observe_Mapping(value, observerContext);
+    if (pe.mapping) {
+      pe.mapping.value = observe_Mapping(value, observerContext);
+    }
   },
 );
 export const pureSingleExecution_setRuntime = action(

package/tsconfig.json

@@ -210,6 +210,7 @@
     "./src/components/editor/edit-panel/mapping-editor/relational/RelationalPropertyMappingEditor.tsx",
     "./src/components/editor/edit-panel/mapping-editor/relational/TableOrViewSourceTree.tsx",
     "./src/components/editor/edit-panel/project-configuration-editor/ProjectConfigurationEditor.tsx",
+    "./src/components/editor/edit-panel/project-configuration-editor/ProjectDependencyEditor.tsx",
     "./src/components/editor/edit-panel/service-editor/NewServiceModal.tsx",
     "./src/components/editor/edit-panel/service-editor/ServiceEditor.tsx",
     "./src/components/editor/edit-panel/service-editor/ServiceExecutionEditor.tsx",