@finos/legend-application-studio 13.0.0

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

@@ -0,0 +1,312 @@
+/**
+ * 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, makeAutoObservable } from 'mobx';
+import {
+  type ServiceEditorState,
+  MINIMUM_SERVICE_OWNERS,
+} from '../../../editor-state/element-editor-state/service/ServiceEditorState.js';
+import type { EditorStore } from '../../../EditorStore.js';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  ActionState,
+  prettyCONSTName,
+  assertNonEmptyString,
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+  getNullableFirstElement,
+  assertTrue,
+} from '@finos/legend-shared';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../LegendStudioAppEvent.js';
+import { Version } from '@finos/legend-server-sdlc';
+import {
+  type ServiceRegistrationResult,
+  ServiceExecutionMode,
+} from '@finos/legend-graph';
+import { ServiceRegistrationEnvInfo } from '../../../../application/LegendStudioApplicationConfig.js';
+import {
+  ActionAlertActionType,
+  ActionAlertType,
+} from '@finos/legend-application';
+
+export const LATEST_PROJECT_REVISION = 'Latest Project Revision';
+
+const getServiceExecutionMode = (mode: string): ServiceExecutionMode => {
+  switch (mode) {
+    case ServiceExecutionMode.FULL_INTERACTIVE:
+      return ServiceExecutionMode.FULL_INTERACTIVE;
+    case ServiceExecutionMode.SEMI_INTERACTIVE:
+      return ServiceExecutionMode.SEMI_INTERACTIVE;
+    case ServiceExecutionMode.PROD:
+      return ServiceExecutionMode.PROD;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported service execution mode '${mode}'`,
+      );
+  }
+};
+
+const URL_SEPARATOR = '/';
+
+interface ServiceVersionOption {
+  label: string;
+  value: Version | string;
+}
+
+export enum SERVICE_REGISTRATION_PHASE {
+  REGISTERING_SERVICE = 'REGISTERING_SERVICE',
+  ACTIVATING_SERVICE = 'ACTIVATING_SERVICE',
+}
+
+export class ServiceRegistrationState {
+  editorStore: EditorStore;
+  serviceEditorState: ServiceEditorState;
+  registrationState = ActionState.create();
+  serviceEnv?: string | undefined;
+  serviceExecutionMode?: ServiceExecutionMode | undefined;
+  projectVersion?: Version | string | undefined;
+  activatePostRegistration = true;
+
+  constructor(
+    editorStore: EditorStore,
+    serviceEditorState: ServiceEditorState,
+  ) {
+    makeAutoObservable(this, {
+      editorStore: false,
+      executionModes: computed,
+      updateVersion: action,
+      setProjectVersion: action,
+      initialize: action,
+      updateType: action,
+      updateEnv: action,
+      setActivatePostRegistration: action,
+    });
+
+    this.editorStore = editorStore;
+    this.serviceEditorState = serviceEditorState;
+    this.initialize();
+    this.registrationState.setMessageFormatter(prettyCONSTName);
+  }
+
+  setServiceEnv(val: string | undefined): void {
+    this.serviceEnv = val;
+  }
+  setServiceExecutionMode(val: ServiceExecutionMode | undefined): void {
+    this.serviceExecutionMode = val;
+  }
+  setProjectVersion(val: Version | string | undefined): void {
+    this.projectVersion = val;
+  }
+
+  setActivatePostRegistration(val: boolean): void {
+    this.activatePostRegistration = val;
+  }
+
+  initialize(): void {
+    this.serviceEnv = getNullableFirstElement(
+      this.editorStore.applicationStore.config.options
+        .TEMPORARY__serviceRegistrationConfig,
+    )?.env;
+    this.serviceExecutionMode = this.executionModes[0];
+    this.updateVersion();
+  }
+
+  updateVersion(): void {
+    if (this.serviceExecutionMode === ServiceExecutionMode.SEMI_INTERACTIVE) {
+      this.projectVersion = LATEST_PROJECT_REVISION;
+    } else if (this.serviceExecutionMode === ServiceExecutionMode.PROD) {
+      this.projectVersion = this.editorStore.sdlcState.projectVersions[0];
+    } else {
+      this.projectVersion = undefined;
+    }
+  }
+
+  updateType(val: ServiceExecutionMode | undefined): void {
+    this.setServiceExecutionMode(val);
+    this.updateVersion();
+  }
+
+  updateEnv(val: string | undefined): void {
+    this.setServiceEnv(val);
+    this.setServiceExecutionMode(this.executionModes[0]);
+  }
+
+  get options(): ServiceRegistrationEnvInfo[] {
+    if (this.editorStore.sdlcServerClient.features.canCreateVersion) {
+      return this.editorStore.applicationStore.config.options
+        .TEMPORARY__serviceRegistrationConfig;
+    }
+    return this.editorStore.applicationStore.config.options.TEMPORARY__serviceRegistrationConfig.map(
+      (_envConfig) => {
+        const envConfig = new ServiceRegistrationEnvInfo();
+        envConfig.env = _envConfig.env;
+        envConfig.executionUrl = _envConfig.executionUrl;
+        envConfig.managementUrl = _envConfig.managementUrl;
+        // NOTE: For projects that we cannot create a version for, only fully-interactive mode is supported
+        envConfig.modes = _envConfig.modes.filter(
+          (mode) => mode === ServiceExecutionMode.FULL_INTERACTIVE,
+        );
+        return envConfig;
+      },
+    ).filter((envConfig) => envConfig.modes.length);
+  }
+
+  get executionModes(): ServiceExecutionMode[] {
+    return (
+      this.options.find((e) => e.env === this.serviceEnv)?.modes ?? []
+    ).map(getServiceExecutionMode);
+  }
+
+  get versionOptions(): ServiceVersionOption[] | undefined {
+    if (
+      this.editorStore.sdlcServerClient.features.canCreateVersion &&
+      this.serviceExecutionMode !== ServiceExecutionMode.FULL_INTERACTIVE
+    ) {
+      const options: ServiceVersionOption[] =
+        this.editorStore.sdlcState.projectVersions.map((version) => ({
+          label: version.id.id,
+          value: version,
+        }));
+      if (this.serviceExecutionMode !== ServiceExecutionMode.PROD) {
+        return [
+          {
+            label: prettyCONSTName(LATEST_PROJECT_REVISION),
+            value: LATEST_PROJECT_REVISION,
+          },
+          ...options,
+        ];
+      }
+      return options;
+    }
+    return undefined;
+  }
+
+  *registerService(): GeneratorFn<void> {
+    try {
+      this.registrationState.inProgress();
+      this.validateServiceForRegistration();
+      const config = guaranteeNonNullable(
+        this.options.find((info) => info.env === this.serviceEnv),
+      );
+      const serverUrl = config.executionUrl;
+      const versionInput =
+        this.projectVersion instanceof Version
+          ? this.projectVersion.id.id
+          : undefined;
+      const projectConfig = guaranteeNonNullable(
+        this.editorStore.projectConfigurationEditorState.projectConfiguration,
+      );
+      this.registrationState.setMessage(
+        SERVICE_REGISTRATION_PHASE.REGISTERING_SERVICE,
+      );
+      const serviceRegistrationResult =
+        (yield this.editorStore.graphManagerState.graphManager.registerService(
+          this.serviceEditorState.service,
+          this.editorStore.graphManagerState.graph,
+          projectConfig.groupId,
+          projectConfig.artifactId,
+          versionInput,
+          serverUrl,
+          guaranteeNonNullable(this.serviceExecutionMode),
+        )) as ServiceRegistrationResult;
+      if (this.activatePostRegistration) {
+        this.registrationState.setMessage(
+          SERVICE_REGISTRATION_PHASE.ACTIVATING_SERVICE,
+        );
+        yield this.editorStore.graphManagerState.graphManager.activateService(
+          serverUrl,
+          serviceRegistrationResult.serviceInstanceId,
+        );
+      }
+      assertNonEmptyString(
+        serviceRegistrationResult.pattern,
+        'Service registration pattern is missing',
+      );
+      const message = `Service with patten ${
+        serviceRegistrationResult.pattern
+      } registered ${this.activatePostRegistration ? 'and activated ' : ''}`;
+      const encodedServicePattern =
+        URL_SEPARATOR +
+        encodeURIComponent(
+          serviceRegistrationResult.pattern[0] === URL_SEPARATOR
+            ? serviceRegistrationResult.pattern.substring(1)
+            : serviceRegistrationResult.pattern,
+        );
+      this.editorStore.setActionAlertInfo({
+        message,
+        prompt: 'You can now launch and monitor the operation of your service',
+        type: ActionAlertType.STANDARD,
+        onEnter: (): void => this.editorStore.setBlockGlobalHotkeys(true),
+        onClose: (): void => this.editorStore.setBlockGlobalHotkeys(false),
+        actions: [
+          {
+            label: 'Launch Service',
+            type: ActionAlertActionType.PROCEED,
+            handler: (): void => {
+              this.editorStore.applicationStore.navigator.openNewWindow(
+                `${config.managementUrl}${encodedServicePattern}`,
+              );
+            },
+            default: true,
+          },
+          {
+            label: 'Close',
+            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+          },
+        ],
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notifyError(error);
+    } finally {
+      this.registrationState.reset();
+      this.registrationState.setMessage(undefined);
+    }
+  }
+
+  validateServiceForRegistration(): void {
+    this.serviceEditorState.service.owners.forEach((owner) =>
+      assertNonEmptyString(owner, `Service can't have an empty owner name`),
+    );
+    assertTrue(
+      this.serviceEditorState.service.owners.length >= MINIMUM_SERVICE_OWNERS,
+      `Service needs to have at least 2 owners in order to be registered`,
+    );
+    guaranteeNonNullable(
+      this.serviceEnv,
+      'Service registration environment can not be empty',
+    );
+    guaranteeNonNullable(
+      this.serviceExecutionMode,
+      'Service type can not be empty',
+    );
+    if (
+      this.serviceExecutionMode === ServiceExecutionMode.PROD ||
+      this.serviceExecutionMode === ServiceExecutionMode.SEMI_INTERACTIVE
+    ) {
+      guaranteeNonNullable(
+        this.projectVersion,
+        'Service version can not be empty in Semi-interactive and Prod service type',
+      );
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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 { EditorStore } from '../../../EditorStore.js';
+import type { ServiceEditorState } from './ServiceEditorState.js';
+
+export class ServiceTestRunnerState {
+  editorStore: EditorStore;
+  serviceEditorState: ServiceEditorState;
+
+  constructor(
+    editorStore: EditorStore,
+    serviceEditorState: ServiceEditorState,
+  ) {
+    this.editorStore = editorStore;
+    this.serviceEditorState = serviceEditorState;
+  }
+}

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

@@ -0,0 +1,365 @@
+/**
+ * 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 TestData,
+  type Connection,
+  type IdentifiedConnection,
+  type Runtime,
+  type EmbeddedData,
+  type RawLambda,
+  type DataElement,
+  ConnectionTestData,
+  PureSingleExecution,
+  PureMultiExecution,
+  DatabaseConnection,
+  buildLambdaVariableExpressions,
+  VariableExpression,
+  PrimitiveType,
+  Enumeration,
+  DataElementReference,
+  PackageableElementExplicitReference,
+  ConnectionPointer,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  deleteEntry,
+  filterByType,
+  guaranteeNonNullable,
+  isNonNullable,
+  returnUndefOnError,
+  getNullableFirstElement,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../../../../EditorStore.js';
+import {
+  service_addConnectionTestData,
+  service_setConnectionTestDataEmbeddedData,
+} from '../../../../graphModifier/DSLService_GraphModifierHelper.js';
+import {
+  createMockEnumerationProperty,
+  createMockPrimitiveProperty,
+} from '../../../../shared/MockDataUtil.js';
+import {
+  createRelationalDataFromCSV,
+  EmbeddedDataConnectionTypeVisitor,
+  getAllIdentifiedConnectionsFromRuntime,
+  TEMPORARY_EmbeddedDataConnectionVisitor,
+} from '../../../../shared/testable/TestableUtils.js';
+import { EmbeddedDataType } from '../../../ExternalFormatState.js';
+import {
+  type EmbeddedDataTypeOption,
+  EmbeddedDataEditorState,
+} from '../../data/DataEditorState.js';
+import { createEmbeddedData } from '../../data/EmbeddedDataState.js';
+import type { ServiceTestSuiteState } from './ServiceTestableState.js';
+
+const buildTestDataParameters = (
+  rawLambda: RawLambda,
+  editorStore: EditorStore,
+): (string | number | boolean)[] =>
+  buildLambdaVariableExpressions(rawLambda, editorStore.graphManagerState)
+    .filter(filterByType(VariableExpression))
+    .map((varExpression) => {
+      if (varExpression.multiplicity.lowerBound !== 0) {
+        const type = varExpression.genericType?.value.rawType;
+        if (type instanceof PrimitiveType) {
+          return createMockPrimitiveProperty(type, varExpression.name);
+        } else if (type instanceof Enumeration) {
+          return createMockEnumerationProperty(type);
+        }
+      }
+      return undefined;
+    })
+    .filter(isNonNullable);
+
+export class ConnectionTestDataState {
+  readonly editorStore: EditorStore;
+  readonly testDataState: ServiceTestDataState;
+  connectionData: ConnectionTestData;
+  embeddedEditorState: EmbeddedDataEditorState;
+  generatingTestDataSate = ActionState.create();
+  anonymizeGeneratedData = true;
+
+  constructor(
+    testDataState: ServiceTestDataState,
+    connectionData: ConnectionTestData,
+  ) {
+    makeObservable(this, {
+      generatingTestDataSate: observable,
+      embeddedEditorState: observable,
+      anonymizeGeneratedData: observable,
+      setAnonymizeGeneratedData: action,
+      generateTestData: flow,
+    });
+    this.testDataState = testDataState;
+    this.editorStore = testDataState.editorStore;
+    this.connectionData = connectionData;
+    this.embeddedEditorState = new EmbeddedDataEditorState(
+      this.testDataState.editorStore,
+      connectionData.testData,
+    );
+  }
+  get identifiedConnection(): IdentifiedConnection | undefined {
+    return this.getAllIdentifiedConnections().find(
+      (c) => c.id === this.connectionData.connectionId,
+    );
+  }
+
+  setAnonymizeGeneratedData(val: boolean): void {
+    this.anonymizeGeneratedData = val;
+  }
+
+  *generateTestData(): GeneratorFn<void> {
+    try {
+      this.generatingTestDataSate.inProgress();
+      const connection = guaranteeNonNullable(
+        this.resolveConnectionValue(this.connectionData.connectionId),
+        `Unable to resolve connection id '${this.connectionData.connectionId}`,
+      );
+
+      let embeddedData: EmbeddedData;
+      if (connection instanceof DatabaseConnection) {
+        const serviceExecutionParameters = guaranteeNonNullable(
+          this.testDataState.testSuiteState.testableState.serviceEditorState
+            .executionState.serviceExecutionParameters,
+        );
+
+        const value =
+          (yield this.editorStore.graphManagerState.graphManager.generateExecuteTestData(
+            serviceExecutionParameters.query,
+            buildTestDataParameters(
+              serviceExecutionParameters.query,
+              this.editorStore,
+            ),
+            serviceExecutionParameters.mapping,
+            serviceExecutionParameters.runtime,
+            this.editorStore.graphManagerState.graph,
+            {
+              anonymizeGeneratedData: this.anonymizeGeneratedData,
+            },
+          )) as string;
+        embeddedData = createRelationalDataFromCSV(value);
+      } else {
+        embeddedData = connection.accept_ConnectionVisitor(
+          new TEMPORARY_EmbeddedDataConnectionVisitor(this.editorStore),
+        );
+      }
+      service_setConnectionTestDataEmbeddedData(
+        this.connectionData,
+        embeddedData,
+        this.editorStore.changeDetectionState.observerContext,
+      );
+      this.embeddedEditorState = new EmbeddedDataEditorState(
+        this.testDataState.editorStore,
+        this.connectionData.testData,
+      );
+      this.generatingTestDataSate.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(
+        `Unable to generate test data: ${error.message}`,
+      );
+      this.generatingTestDataSate.fail();
+    }
+  }
+
+  resolveConnectionValue(id: string): Connection | undefined {
+    const connection = this.getAllIdentifiedConnections().find(
+      (c) => c.id === id,
+    )?.connection;
+    if (connection instanceof ConnectionPointer) {
+      return connection.packageableConnection.value.connectionValue;
+    }
+    return connection;
+  }
+
+  getAllIdentifiedConnections(): IdentifiedConnection[] {
+    const service =
+      this.testDataState.testSuiteState.testableState.serviceEditorState
+        .service;
+    const execution = service.execution;
+    let runtimes: Runtime[] = [];
+    if (execution instanceof PureSingleExecution) {
+      runtimes = [execution.runtime];
+    } else if (execution instanceof PureMultiExecution) {
+      runtimes = execution.executionParameters.map((t) => t.runtime);
+    }
+    return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
+  }
+}
+
+export class NewConnectionDataState {
+  readonly testSuiteState: ServiceTestDataState;
+  showModal = false;
+  connection: IdentifiedConnection | undefined;
+  embeddedDataType: EmbeddedDataTypeOption | undefined;
+  dataElement: DataElement | undefined;
+
+  constructor(suite: ServiceTestDataState) {
+    makeObservable(this, {
+      showModal: observable,
+      connection: observable,
+      embeddedDataType: observable,
+      dataElement: observable,
+      setModal: action,
+      openModal: action,
+      setEmbeddedDataType: action,
+      handleConnectionChange: action,
+      setDataElement: action,
+    });
+    this.testSuiteState = suite;
+    this.dataElement = this.testSuiteState.editorStore.dataOptions[0]?.value;
+  }
+
+  setModal(val: boolean): void {
+    this.showModal = val;
+  }
+
+  setDataElement(val: DataElement | undefined): void {
+    this.dataElement = val;
+  }
+
+  setEmbeddedDataType(val: EmbeddedDataTypeOption | undefined): void {
+    this.embeddedDataType = val;
+  }
+
+  openModal(): void {
+    this.setModal(true);
+    this.connection = this.testSuiteState.allIdentifiedConnections[0];
+    if (this.connection) {
+      this.handleConnectionChange(this.connection);
+    }
+  }
+
+  setConnection(val: IdentifiedConnection | undefined): void {
+    this.connection = val;
+  }
+
+  handleConnectionChange(val: IdentifiedConnection): void {
+    const connectionValue = val.connection;
+    const type = returnUndefOnError(() =>
+      connectionValue.accept_ConnectionVisitor(
+        new EmbeddedDataConnectionTypeVisitor(this.testSuiteState.editorStore),
+      ),
+    );
+    this.setEmbeddedDataType(type ? { label: type, value: type } : undefined);
+  }
+
+  createConnectionTestData(): ConnectionTestData {
+    const val = guaranteeNonNullable(this.connection);
+    const embeddedDataType = guaranteeNonNullable(this.embeddedDataType);
+    const connectionTestData = new ConnectionTestData();
+    connectionTestData.connectionId = val.id;
+    let testData: EmbeddedData;
+    if (
+      this.embeddedDataType?.value === EmbeddedDataType.DATA_ELEMENT &&
+      this.dataElement
+    ) {
+      const value = new DataElementReference();
+      value.dataElement = PackageableElementExplicitReference.create(
+        this.dataElement,
+      );
+      testData = value;
+    } else {
+      testData = createEmbeddedData(
+        embeddedDataType.value,
+        this.testSuiteState.editorStore,
+      );
+    }
+    connectionTestData.testData = testData;
+    return connectionTestData;
+  }
+}
+
+export class ServiceTestDataState {
+  readonly editorStore: EditorStore;
+  readonly testSuiteState: ServiceTestSuiteState;
+  testData: TestData;
+  selectedDataState: ConnectionTestDataState | undefined;
+  newConnectionDataState: NewConnectionDataState;
+
+  constructor(testData: TestData, testSuiteState: ServiceTestSuiteState) {
+    makeObservable(this, {
+      setSelectedDataState: action,
+      openConnectionTestData: action,
+      createConnectionTestData: action,
+      newConnectionDataState: observable,
+      selectedDataState: observable,
+    });
+    this.testData = testData;
+    this.testSuiteState = testSuiteState;
+    this.editorStore = testSuiteState.editorStore;
+    const connectionData = getNullableFirstElement(
+      testData.connectionsTestData,
+    );
+    if (connectionData) {
+      this.selectedDataState = new ConnectionTestDataState(
+        this,
+        connectionData,
+      );
+    }
+    this.newConnectionDataState = new NewConnectionDataState(this);
+  }
+
+  createConnectionTestData(): void {
+    const connectionTestData =
+      this.newConnectionDataState.createConnectionTestData();
+    service_addConnectionTestData(
+      this.testSuiteState.suite,
+      connectionTestData,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+    this.selectedDataState = new ConnectionTestDataState(
+      this,
+      connectionTestData,
+    );
+  }
+
+  setSelectedDataState(val: ConnectionTestDataState | undefined): void {
+    this.selectedDataState = val;
+  }
+
+  deleteConnectionTestData(val: ConnectionTestData): void {
+    deleteEntry(this.testData.connectionsTestData, val);
+    if (this.selectedDataState?.connectionData === val) {
+      const data = getNullableFirstElement(this.testData.connectionsTestData);
+      this.selectedDataState = data
+        ? new ConnectionTestDataState(this, data)
+        : undefined;
+    }
+  }
+
+  openConnectionTestData(val: ConnectionTestData): void {
+    if (this.selectedDataState?.connectionData !== val) {
+      this.setSelectedDataState(new ConnectionTestDataState(this, val));
+    }
+  }
+  get allIdentifiedConnections(): IdentifiedConnection[] {
+    const service =
+      this.testSuiteState.testableState.serviceEditorState.service;
+    const execution = service.execution;
+    let runtimes: Runtime[] = [];
+    if (execution instanceof PureSingleExecution) {
+      runtimes = [execution.runtime];
+    } else if (execution instanceof PureMultiExecution) {
+      runtimes = execution.executionParameters.map((t) => t.runtime);
+    }
+    return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
+  }
+}