@finos/legend-application-studio 22.5.0 → 22.6.0

package/src/components/editor/side-bar/RegisterService.tsx

@@ -0,0 +1,139 @@
+/**
+ * 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 { useState } from 'react';
+import { observer } from 'mobx-react-lite';
+import { LEGEND_STUDIO_TEST_ID } from '../../LegendStudioTestID.js';
+import { useEditorStore } from '../EditorStoreProvider.js';
+import {
+  ContextMenu,
+  PanelContent,
+  PURE_ServiceIcon,
+  clsx,
+  PlayIcon,
+  Dialog,
+  Modal,
+  TimesIcon,
+  EmptyWindowRestoreIcon,
+  WindowMaximizeIcon,
+} from '@finos/legend-art';
+import type { BulkServiceRegistrationState } from '../../../stores/sidebar-state/BulkServiceRegistrationState.js';
+import { BulkServiceRegistrationEditor } from '../edit-panel/service-editor/BulkServiceRegistrationEditor.js';
+import { noop } from '@finos/legend-shared';
+
+export const RegisterService = observer(
+  (props: { bulkServiceRegistrationState: BulkServiceRegistrationState }) => {
+    const editorStore = useEditorStore();
+    const services = editorStore.graphManagerState.graph.ownServices;
+    const [open, setOpen] = useState(false);
+
+    const [isMaximized, setIsMaximized] = useState(false);
+    const toggleMaximize = (): void => setIsMaximized(!isMaximized);
+
+    const renderTestables = (): React.ReactNode => (
+      <>
+        {services.map((service) => (
+          <ContextMenu key={service._UUID}>
+            <div
+              className={clsx(
+                'tree-view__node__container global-test-runner__explorer__testable-tree__node__container',
+              )}
+            >
+              <div className="global-test-runner__explorer__testable-tree__node__result__icon__type">
+                <PURE_ServiceIcon />
+              </div>
+              <div className="global-test-runner__item__link__content">
+                <span className="global-test-runner__item__link__content__id">
+                  {service.name}
+                </span>
+              </div>
+            </div>
+          </ContextMenu>
+        ))}
+      </>
+    );
+
+    return (
+      <div
+        data-testid={LEGEND_STUDIO_TEST_ID.GLOBAL_TEST_RUNNER}
+        className="panel global-test-runner"
+      >
+        <div className="panel__header side-bar__header">
+          <div className="panel__header__title global-test-runner__header__title">
+            <div className="panel__header__title__content side-bar__header__title__content">
+              REGISTER SERVICES
+            </div>
+          </div>
+          <div className="panel__header__actions side-bar__header__actions"></div>
+          <button
+            className="panel__header__action side-bar__header__action global-test-runner__refresh-btn"
+            onClick={() => setOpen(true)}
+            tabIndex={-1}
+            title="Register All Services"
+          >
+            <PlayIcon />
+          </button>
+          <Dialog onClose={noop} open={open}>
+            <Modal
+              darkMode={true}
+              className={clsx('editor-modal query-builder__dialog', {
+                'query-builder__dialog--expanded': isMaximized,
+              })}
+            >
+              <div className="query-builder__dialog__header">
+                <div className="query-builder__dialog__header__actions"></div>
+                <button
+                  className="query-builder__dialog__header__action"
+                  tabIndex={-1}
+                  onClick={toggleMaximize}
+                >
+                  {isMaximized ? (
+                    <EmptyWindowRestoreIcon />
+                  ) : (
+                    <WindowMaximizeIcon />
+                  )}
+                </button>
+                <button
+                  className="query-builder__dialog__header__action"
+                  tabIndex={-1}
+                  onClick={() => setOpen(false)}
+                >
+                  <TimesIcon />
+                </button>
+              </div>
+              <BulkServiceRegistrationEditor />;
+            </Modal>
+          </Dialog>
+        </div>
+        <div className="panel__content side-bar__content">
+          <div className="panel side-bar__panel">
+            <div className="panel__header">
+              <div className="panel__header__title">
+                <div className="panel__header__title__content">SERVICES</div>
+              </div>
+              <div
+                className="side-bar__panel__header__changes-count"
+                data-testid={
+                  LEGEND_STUDIO_TEST_ID.SIDEBAR_PANEL_HEADER__CHANGES_COUNT
+                }
+              ></div>
+            </div>
+            <PanelContent>{renderTestables()}</PanelContent>
+          </div>
+        </div>
+      </div>
+    );
+  },
+);

package/src/components/editor/side-bar/SideBar.tsx

@@ -25,6 +25,7 @@ import { ProjectOverview } from './ProjectOverview.js';
 import { WorkflowManager } from './WorkflowManager.js';
 import { useEditorStore } from '../EditorStoreProvider.js';
 import { GlobalTestRunner } from './testable/GlobalTestRunner.js';
+import { RegisterService } from './RegisterService.js';
 
 /**
  * Wrapper component around different implementations of sidebar, such as to view domain, to manage SDLC, etc.
@@ -58,6 +59,14 @@ export const SideBar = observer(() => {
             globalTestRunnerState={editorStore.globalTestRunnerState}
           />
         );
+      case ACTIVITY_MODE.REGISTER_SERVICES:
+        return (
+          <RegisterService
+            bulkServiceRegistrationState={
+              editorStore.bulkServiceRegistrationState
+            }
+          />
+        );
       default:
         return null;
     }

package/src/stores/EditorConfig.ts

@@ -36,6 +36,7 @@ export enum ACTIVITY_MODE {
   PROJECT_OVERVIEW = 'PROJECT_OVERVIEW',
   WORKFLOW_MANAGER = 'WORKFLOW_MANAGER',
   GLOBAL_TEST_RUNNER = 'GLOBAL_TEST_RUNNER',
+  REGISTER_SERVICES = 'REGISTER_SERVICES',
 }
 
 export enum AUX_PANEL_MODE {

package/src/stores/EditorStore.ts

@@ -138,6 +138,7 @@ import { EmbeddedQueryBuilderState } from './EmbeddedQueryBuilderState.js';
 import { LEGEND_STUDIO_COMMAND_KEY } from './LegendStudioCommand.js';
 import { EditorTabManagerState } from './EditorTabManagerState.js';
 import type { ProjectViewerEditorMode } from './project-viewer/ProjectViewerEditorMode.js';
+import { BulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -183,6 +184,7 @@ export class EditorStore implements CommandRegistrar {
   devToolState: DevToolState;
   embeddedQueryBuilderState: EmbeddedQueryBuilderState;
   newElementState: NewElementState;
+  bulkServiceRegistrationState: BulkServiceRegistrationState;
   /**
    * Since we want to share element generation state across all element in the editor, we will create 1 element generate state
    * per file generation configuration type.
@@ -281,6 +283,10 @@ export class EditorStore implements CommandRegistrar {
       this.sdlcState,
     );
     this.newElementState = new NewElementState(this);
+    this.bulkServiceRegistrationState = new BulkServiceRegistrationState(
+      this,
+      this.sdlcState,
+    );
     // special (singleton) editors
     this.grammarTextEditorState = new GrammarTextEditorState(this);
     this.modelImporterState = new ModelImporterState(this);

package/src/stores/sidebar-state/BulkServiceRegistrationState.ts

@@ -0,0 +1,370 @@
+/**
+ * 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, makeObservable, observable, flow } from 'mobx';
+import type { EditorSDLCState } from '../EditorSDLCState.js';
+import type { EditorStore } from '../EditorStore.js';
+import {
+  type PureExecution,
+  areMultiplicitiesEqual,
+  buildLambdaVariableExpressions,
+  generateMultiplicityString,
+  Multiplicity,
+  VariableExpression,
+  ServiceExecutionMode,
+  type BulkRegistrationResultFail,
+  BulkRegistrationResultSuccess,
+  type BulkServiceRegistrationResult,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertNonEmptyString,
+  assertTrue,
+  filterByType,
+  getNullableFirstElement,
+  guaranteeNonNullable,
+  prettyCONSTName,
+  UnsupportedOperationError,
+  assertErrorThrown,
+  LogEvent,
+} from '@finos/legend-shared';
+import { Version } from '@finos/legend-server-sdlc';
+import { MINIMUM_SERVICE_OWNERS } from '../editor-state/element-editor-state/service/ServiceEditorState.js';
+import { ServiceRegistrationEnvironmentConfig } from '../../application/LegendStudioApplicationConfig.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
+import { generateServiceManagementUrl } from '../editor-state/element-editor-state/service/ServiceRegistrationState.js';
+
+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}'`,
+      );
+  }
+};
+interface ServiceVersionOption {
+  label: string;
+  value: Version | string;
+}
+interface ServiceRegistrationResult {
+  successfulServices: string[];
+  failedServices: string[];
+  serviceLinks: string[];
+}
+export class ServiceConfigState {
+  readonly editorStore: EditorStore;
+  readonly registrationOptions: ServiceRegistrationEnvironmentConfig[] = [];
+  readonly registrationState = ActionState.create();
+  registrationResult: ServiceRegistrationResult | undefined;
+  serviceEnv?: string | undefined;
+  serviceExecutionMode?: ServiceExecutionMode | undefined;
+  projectVersion?: Version | string | undefined;
+  enableModesWithVersioning: boolean;
+  TEMPORARY__useStoreModel = false;
+
+  constructor(
+    editorStore: EditorStore,
+    registrationOptions: ServiceRegistrationEnvironmentConfig[],
+    enableModesWithVersioning: boolean,
+  ) {
+    makeObservable(this, {
+      serviceEnv: observable,
+      serviceExecutionMode: observable,
+      projectVersion: observable,
+      enableModesWithVersioning: observable,
+      TEMPORARY__useStoreModel: observable,
+      executionModes: computed,
+      options: computed,
+      versionOptions: computed,
+      setServiceEnv: action,
+      setServiceExecutionMode: action,
+      setProjectVersion: action,
+
+      setUseStoreModelWithFullInteractive: action,
+      initialize: action,
+
+      updateVersion: action,
+      updateType: action,
+      updateEnv: action,
+    });
+
+    this.editorStore = editorStore;
+    this.registrationOptions = registrationOptions;
+    this.enableModesWithVersioning = enableModesWithVersioning;
+    this.initialize();
+    this.registrationState.setMessageFormatter(prettyCONSTName);
+  }
+
+  get options(): ServiceRegistrationEnvironmentConfig[] {
+    if (this.enableModesWithVersioning) {
+      return this.registrationOptions;
+    }
+    return this.registrationOptions
+      .map((_envConfig) => {
+        const envConfig = new ServiceRegistrationEnvironmentConfig();
+        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.enableModesWithVersioning &&
+      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;
+  }
+
+  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;
+  }
+
+  setUseStoreModelWithFullInteractive(val: boolean): void {
+    this.TEMPORARY__useStoreModel = val;
+  }
+
+  initialize(): void {
+    this.serviceEnv = getNullableFirstElement(this.registrationOptions)?.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]);
+  }
+}
+
+export class BulkServiceRegistrationState {
+  editorStore: EditorStore;
+  sdlcState: EditorSDLCState;
+  serviceConfigState: ServiceConfigState;
+  showSuccessModel = false;
+
+  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
+    makeObservable(this, {
+      showSuccessModel: observable,
+      editorStore: false,
+      sdlcState: false,
+      registerServices: flow,
+      setSuccessModal: action,
+    });
+    this.editorStore = editorStore;
+    this.sdlcState = sdlcState;
+    this.serviceConfigState = new ServiceConfigState(
+      editorStore,
+      editorStore.applicationStore.config.options.TEMPORARY__serviceRegistrationConfig,
+      editorStore.sdlcServerClient.featuresConfigHasBeenFetched &&
+        editorStore.sdlcServerClient.features.canCreateVersion,
+    );
+  }
+  setSuccessModal(val: boolean): void {
+    this.showSuccessModel = val;
+  }
+  *registerServices(): GeneratorFn<void> {
+    const successfulServices: string[] = [];
+    const failedServices: string[] = [];
+    const serviceManagementURL: string[] = [];
+
+    this.serviceConfigState.registrationState.inProgress();
+    this.validateServiceForRegistration();
+    try {
+      const projectConfig = guaranteeNonNullable(
+        this.editorStore.projectConfigurationEditorState.projectConfiguration,
+      );
+
+      const versionInput =
+        this.serviceConfigState.projectVersion instanceof Version
+          ? this.serviceConfigState.projectVersion.id.id
+          : undefined;
+
+      const config = guaranteeNonNullable(
+        this.serviceConfigState.options.find(
+          (info) => info.env === this.serviceConfigState.serviceEnv,
+        ),
+      );
+      const serviceRegistrationResult =
+        (yield this.editorStore.graphManagerState.graphManager.bulkServiceRegistration(
+          this.editorStore.graphManagerState.graph.ownServices,
+          this.editorStore.graphManagerState.graph,
+          projectConfig.groupId,
+          projectConfig.artifactId,
+          versionInput,
+          config.executionUrl,
+          guaranteeNonNullable(this.serviceConfigState.serviceExecutionMode),
+          {
+            TEMPORARY__useStoreModel:
+              this.serviceConfigState.TEMPORARY__useStoreModel,
+          },
+        )) as BulkServiceRegistrationResult[];
+
+      serviceRegistrationResult.forEach((result) => {
+        if (result instanceof BulkRegistrationResultSuccess) {
+          const serviceURL = generateServiceManagementUrl(
+            config.managementUrl,
+            result.pattern,
+          );
+          serviceManagementURL.push(serviceURL);
+          successfulServices.push(result.pattern);
+        } else {
+          failedServices.push(
+            `${result.servicePath} ERROR: ${
+              (result as BulkRegistrationResultFail).errorMessage
+            }`,
+          );
+        }
+      });
+      this.serviceConfigState.registrationResult = {
+        successfulServices: successfulServices,
+        serviceLinks: serviceManagementURL,
+        failedServices: failedServices,
+      };
+      this.showSuccessModel = true;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.serviceConfigState.registrationState.reset();
+      this.serviceConfigState.registrationState.setMessage(undefined);
+    }
+  }
+
+  validateServiceForRegistration(): void {
+    const services = this.editorStore.graphManagerState.graph.ownServices;
+
+    services.forEach((service) => {
+      service.owners.forEach((owner) =>
+        assertNonEmptyString(owner, `Service can't have an empty owner name`),
+      );
+      assertTrue(
+        service.owners.length >= MINIMUM_SERVICE_OWNERS,
+        `Service needs to have at least 2 owners in order to be registered`,
+      );
+      guaranteeNonNullable(
+        this.serviceConfigState.serviceEnv,
+        'Service registration environment can not be empty',
+      );
+      guaranteeNonNullable(
+        this.serviceConfigState.serviceExecutionMode,
+        'Service type can not be empty',
+      );
+      if (
+        this.serviceConfigState.serviceExecutionMode ===
+          ServiceExecutionMode.PROD ||
+        this.serviceConfigState.serviceExecutionMode ===
+          ServiceExecutionMode.SEMI_INTERACTIVE
+      ) {
+        guaranteeNonNullable(
+          this.serviceConfigState.projectVersion,
+          'Service version can not be empty in Semi-interactive and Prod service type',
+        );
+      }
+
+      // validate service parameter multiplicities
+      const SUPPORTED_SERVICE_PARAMETER_MULTIPLICITIES = [
+        Multiplicity.ONE,
+        Multiplicity.ZERO_MANY,
+        Multiplicity.ZERO_ONE,
+      ];
+      const invalidParams = buildLambdaVariableExpressions(
+        (service.execution as PureExecution).func,
+        this.editorStore.graphManagerState,
+      )
+        .filter(filterByType(VariableExpression))
+        .filter(
+          (p) =>
+            !SUPPORTED_SERVICE_PARAMETER_MULTIPLICITIES.some((m) =>
+              areMultiplicitiesEqual(m, p.multiplicity),
+            ),
+        );
+      assertTrue(
+        invalidParams.length === 0,
+        `Parameter(s)${invalidParams.map(
+          (p) =>
+            ` ${p.name}: [${generateMultiplicityString(
+              p.multiplicity.lowerBound,
+              p.multiplicity.upperBound,
+            )}]`,
+        )} has/have unsupported multiplicity. Supported multiplicities include ${SUPPORTED_SERVICE_PARAMETER_MULTIPLICITIES.map(
+          (m) => ` [${generateMultiplicityString(m.lowerBound, m.upperBound)}]`,
+        )}.`,
+      );
+    });
+  }
+}

package/tsconfig.json

@@ -143,6 +143,7 @@
     "./src/stores/shared/modifier/STO_Relational_GraphModifierHelper.ts",
     "./src/stores/shared/modifier/Testable_GraphModifierHelper.ts",
     "./src/stores/shared/testable/TestableUtils.ts",
+    "./src/stores/sidebar-state/BulkServiceRegistrationState.ts",
     "./src/stores/sidebar-state/LocalChangesState.ts",
     "./src/stores/sidebar-state/ProjectDependantEditorState.ts",
     "./src/stores/sidebar-state/ProjectOverviewState.ts",
@@ -221,6 +222,7 @@
     "./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/BulkServiceRegistrationEditor.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",
@@ -244,6 +246,7 @@
     "./src/components/editor/side-bar/LocalChanges.tsx",
     "./src/components/editor/side-bar/ProjectDependantsEditor.tsx",
     "./src/components/editor/side-bar/ProjectOverview.tsx",
+    "./src/components/editor/side-bar/RegisterService.tsx",
     "./src/components/editor/side-bar/SideBar.tsx",
     "./src/components/editor/side-bar/WorkflowManager.tsx",
     "./src/components/editor/side-bar/WorkspaceReview.tsx",