@finos/legend-application-studio 13.1.1 → 13.1.2

package/src/components/editor/edit-panel/connection-editor/RelationalDatabaseConnectionEditor.tsx

@@ -45,6 +45,7 @@ import {
   ApiTokenAuthenticationStrategy,
   UsernamePasswordAuthenticationStrategy,
   GCPWorkloadIdentityFederationAuthenticationStrategy,
+  MiddleTierUsernamePasswordAuthenticationStrategy,
   EmbeddedH2DatasourceSpecification,
   LocalH2DatasourceSpecification,
   SnowflakeDatasourceSpecification,
@@ -114,6 +115,7 @@ import {
   usernamePasswordAuthenticationStrategy_setUserNameVaultReference,
   gcpWorkloadIdentityFederationAuthenticationStrategy_setServiceAccountEmail,
   gcpWorkloadIdentityFederationAuthenticationStrategy_setAdditionalGcpScopes,
+  middleTierUsernamePasswordAuthenticationStrategy_setVaultReference,
 } from '../../../../stores/graphModifier/StoreRelational_GraphModifierHelper.js';
 
 /**
@@ -1014,6 +1016,31 @@ const UsernamePasswordAuthenticationStrategyEditor = observer(
     );
   },
 );
+// Middle Tier Username Password Authentication Strategy obtains credentials(username and password) from the provided vault reference
+const MiddleTierUsernamePasswordAuthenticationStrategyEditor = observer(
+  (props: {
+    authSpec: MiddleTierUsernamePasswordAuthenticationStrategy;
+    isReadOnly: boolean;
+  }) => {
+    const { authSpec, isReadOnly } = props;
+    return (
+      <>
+        <ConnectionEditor_StringEditor
+          isReadOnly={isReadOnly}
+          value={authSpec.vaultReference}
+          propertyName={'vault reference'}
+          description="Specifies the cred vault reference containing connection credentials"
+          update={(value: string | undefined): void =>
+            middleTierUsernamePasswordAuthenticationStrategy_setVaultReference(
+              authSpec,
+              value ?? '',
+            )
+          }
+        />
+      </>
+    );
+  },
+);
 
 const GCPWorkloadIdentityFederationAuthenticationStrategyEditor = observer(
   (props: {
@@ -1238,6 +1265,15 @@ const renderAuthenticationStrategyEditor = (
         isReadOnly={isReadOnly}
       />
     );
+  } else if (
+    authSpec instanceof MiddleTierUsernamePasswordAuthenticationStrategy
+  ) {
+    return (
+      <MiddleTierUsernamePasswordAuthenticationStrategyEditor
+        authSpec={authSpec}
+        isReadOnly={isReadOnly}
+      />
+    );
   } else if (
     authSpec instanceof GCPWorkloadIdentityFederationAuthenticationStrategy
   ) {

package/src/components/editor/edit-panel/service-editor/testable/ServiceTestDataEditor.tsx

@@ -212,12 +212,14 @@ export const NewConnectionDataModal = observer(
     const dataElementOptions = testDataState.editorStore.dataOptions;
     const newConnectionState = testDataState.newConnectionDataState;
     const dataElement = newConnectionState.dataElement;
-    const selectedOption = dataElement ? buildElementOption(dataElement) : null;
+    const selectedDataElement = dataElement
+      ? buildElementOption(dataElement)
+      : null;
     const onDataElementChange = (val: {
       label: string;
       value?: DataElement;
     }): void => {
-      if (val.value !== selectedOption?.value && val.value) {
+      if (val.value !== selectedDataElement?.value && val.value) {
         newConnectionState.setDataElement(val.value);
       }
     };
@@ -265,7 +267,7 @@ export const NewConnectionDataModal = observer(
     // external format
     const selectedEmbeddedType = newConnectionState.embeddedDataType
       ? {
-          label: prettyCONSTName(newConnectionState.embeddedDataType.label),
+          label: prettyCONSTName(newConnectionState.embeddedDataType.value),
           value: newConnectionState.embeddedDataType.value,
         }
       : undefined;
@@ -301,42 +303,67 @@ export const NewConnectionDataModal = observer(
       >
         <form
           onSubmit={handleSubmit}
-          className="modal modal--dark search-modal"
+          className="modal service-test-data-modal modal--dark"
         >
-          <div className="modal__title">Create a connection test data</div>
-          <div className="explorer__new-element-modal__driver">
-            <CustomSelectorInput
-              className="explorer__new-element-modal__driver__dropdown"
-              options={connectionOptions}
-              onChange={onConnectionSelectionChange}
-              value={selectedConnection}
-              isClearable={false}
-              darkMode={true}
-            />
+          <div className="modal__header">
+            <div className="modal__title">Create a connection test data</div>
           </div>
-          <div className="explorer__new-element-modal__driver">
-            <CustomSelectorInput
-              className="explorer__new-element-modal__driver__dropdown"
-              options={embeddedOptions}
-              onChange={onEmbeddedTypeChange}
-              value={selectedEmbeddedType}
-              isClearable={false}
-              darkMode={true}
-            />
-          </div>
-          {selectedEmbeddedType?.value === EmbeddedDataType.DATA_ELEMENT && (
-            <div className="explorer__new-element-modal__driver">
-              <CustomSelectorInput
-                className="panel__content__form__section__dropdown data-element-reference-editor__value__dropdown"
-                disabled={isReadOnly}
-                options={dataElementOptions}
-                onChange={onDataElementChange}
-                value={selectedOption}
-                darkMode={true}
-              />
+          <div className="modal__body">
+            <div className="panel__content__form__section">
+              <div className="panel__content__form__section__header__label">
+                Connection ID
+              </div>
+              <div className="panel__content__form__section__header__prompt">
+                Connection in runtime to povide test data for
+              </div>
+              <div className="explorer__new-element-modal__driver">
+                <CustomSelectorInput
+                  className="explorer__new-element-modal__driver__dropdown"
+                  options={connectionOptions}
+                  onChange={onConnectionSelectionChange}
+                  value={selectedConnection}
+                  isClearable={false}
+                  darkMode={true}
+                />
+              </div>
             </div>
-          )}
-          <div className="search-modal__actions">
+            <div className="panel__content__form__section">
+              <div className="panel__content__form__section__header__label">
+                Data Type
+              </div>
+              <div className="panel__content__form__section__header__prompt">
+                Test data type that will be loaded to your test connection
+              </div>
+              <div className="explorer__new-element-modal__driver">
+                <CustomSelectorInput
+                  className="explorer__new-element-modal__driver__dropdown"
+                  options={embeddedOptions}
+                  onChange={onEmbeddedTypeChange}
+                  value={selectedEmbeddedType}
+                  isClearable={false}
+                  darkMode={true}
+                />
+              </div>
+            </div>
+            {selectedEmbeddedType?.value === EmbeddedDataType.DATA_ELEMENT && (
+              <div className="panel__content__form__section">
+                <div className="panel__content__form__section__header__label">
+                  Data Element
+                </div>
+                <div className="explorer__new-element-modal__driver">
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown data-element-reference-editor__value__dropdown"
+                    disabled={isReadOnly}
+                    options={dataElementOptions}
+                    onChange={onDataElementChange}
+                    value={selectedDataElement}
+                    darkMode={true}
+                  />
+                </div>
+              </div>
+            )}
+          </div>
+          <div className="modal__footer">
             <button
               type="button"
               className="btn btn--dark"

package/src/components/editor/edit-panel/uml-editor/AssociationEditor.tsx

@@ -74,7 +74,6 @@ import {
   stub_Stereotype,
   getFirstAssociatedProperty,
   getSecondAssociatedProperty,
-  getOtherAssociatedProperty,
 } from '@finos/legend-graph';
 import {
   property_setName,
@@ -120,12 +119,7 @@ const AssociationPropertyBasicEditor = observer(
     // Generic Type
     const [isEditingType, setIsEditingType] = useState(false);
     // TODO: make this so that association can only refer to classes from the same graph space
-    const propertyTypeOptions = editorStore.classOptions.filter(
-      (classOption) =>
-        classOption.value !==
-        getOtherAssociatedProperty(association, property).genericType.value
-          .rawType,
-    );
+    const propertyTypeOptions = editorStore.classOptions;
     const propertyType = property.genericType.value.rawType;
     const propertyTypeName = getClassPropertyType(propertyType);
     const filterOption = createFilter({

package/src/stores/LegendStudioBaseStore.ts

@@ -14,14 +14,31 @@
  * limitations under the License.
  */
 
-import { type GeneratorFn, ActionState } from '@finos/legend-shared';
+import {
+  type GeneratorFn,
+  type PlainObject,
+  HttpStatus,
+  NetworkClientError,
+  ActionState,
+  LogEvent,
+  assertErrorThrown,
+} from '@finos/legend-shared';
 import {
   type ApplicationStore,
+  ActionAlertActionType,
+  ActionAlertType,
   ApplicationTelemetry,
-  LegendApplicationSDLCSetupState,
 } from '@finos/legend-application';
-import { flow, flowResult, makeObservable } from 'mobx';
-import type { SDLCServerClient } from '@finos/legend-server-sdlc';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
+import { User, SDLCServerClient } from '@finos/legend-server-sdlc';
+import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioAppEvent.js';
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import type { LegendStudioPluginManager } from '../application/LegendStudioPluginManager.js';
 import type { LegendStudioApplicationConfig } from '../application/LegendStudioApplicationConfig.js';
@@ -37,11 +54,14 @@ export type LegendStudioApplicationStore = ApplicationStore<
 
 export class LegendStudioBaseStore {
   applicationStore: LegendStudioApplicationStore;
+  sdlcServerClient: SDLCServerClient;
   depotServerClient: DepotServerClient;
   pluginManager: LegendStudioPluginManager;
 
   initState = ActionState.create();
-  applicationSDLCSetupState: LegendApplicationSDLCSetupState;
+
+  isSDLCAuthorized = false;
+  SDLCServerTermsOfServicesUrlsToView: string[] = [];
 
   constructor(
     applicationStore: LegendStudioApplicationStore,
@@ -49,23 +69,23 @@ export class LegendStudioBaseStore {
     depotServerClient: DepotServerClient,
     pluginManager: LegendStudioPluginManager,
   ) {
-    makeObservable(this, {
+    makeObservable<LegendStudioBaseStore, 'initializeSDLCServerClient'>(this, {
+      isSDLCAuthorized: observable,
+      SDLCServerTermsOfServicesUrlsToView: observable,
+      needsToAcceptSDLCServerTermsOfServices: computed,
       initialize: flow,
+      initializeSDLCServerClient: flow,
+      dismissSDLCServerTermsOfServicesAlert: action,
     });
 
     this.applicationStore = applicationStore;
-    this.applicationSDLCSetupState = new LegendApplicationSDLCSetupState(
-      applicationStore,
-      sdlcServerClient,
-    );
+    this.sdlcServerClient = sdlcServerClient;
     this.depotServerClient = depotServerClient;
 
     this.pluginManager = pluginManager;
 
     // Register plugins
-    this.applicationSDLCSetupState.sdlcServerClient.setTracerService(
-      this.applicationStore.tracerService,
-    );
+    this.sdlcServerClient.setTracerService(this.applicationStore.tracerService);
     this.depotServerClient.setTracerService(
       this.applicationStore.tracerService,
     );
@@ -81,15 +101,26 @@ export class LegendStudioBaseStore {
     this.initState.inProgress();
 
     // setup SDLC server client
-    yield flowResult(
-      this.applicationSDLCSetupState.initializeSDLCServerClient(),
-    );
+    yield flowResult(this.initializeSDLCServerClient());
+
+    let currentUserID = UNKNOWN_USER_ID;
+    try {
+      const currentUser = User.serialization.fromJson(
+        (yield this.sdlcServerClient.getCurrentUser()) as PlainObject<User>,
+      );
+      this.sdlcServerClient.setCurrentUser(currentUser);
+      currentUserID = currentUser.userId;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyWarning(error.message);
+    }
 
     // setup telemetry service
-    this.applicationStore.telemetryService.setUserId(
-      this.applicationSDLCSetupState.sdlcServerClient.currentUser?.userId ??
-        UNKNOWN_USER_ID,
-    );
+    this.applicationStore.telemetryService.setUserId(currentUserID);
 
     ApplicationTelemetry.logEvent_ApplicationInitialized(
       this.applicationStore.telemetryService,
@@ -109,4 +140,100 @@ export class LegendStudioBaseStore {
 
     this.initState.complete();
   }
+
+  private *initializeSDLCServerClient(): GeneratorFn<void> {
+    try {
+      this.isSDLCAuthorized =
+        (yield this.sdlcServerClient.isAuthorized()) as boolean;
+      if (!this.isSDLCAuthorized) {
+        this.applicationStore.navigator.jumpTo(
+          SDLCServerClient.authorizeCallbackUrl(
+            this.applicationStore.config.sdlcServerUrl,
+            this.applicationStore.navigator.getCurrentLocation(),
+          ),
+        );
+      } else {
+        // Only proceed intialization after passing authorization check
+
+        // check terms of service agreement status
+        this.SDLCServerTermsOfServicesUrlsToView =
+          (yield this.sdlcServerClient.hasAcceptedTermsOfService()) as string[];
+        if (this.SDLCServerTermsOfServicesUrlsToView.length) {
+          this.applicationStore.setActionAlertInfo({
+            message: `Please read and accept the SDLC servers' terms of service`,
+            prompt: `Click 'Done' when you have accepted all the terms`,
+            type: ActionAlertType.CAUTION,
+            actions: [
+              {
+                label: 'See terms of services',
+                default: true,
+                handler: (): void =>
+                  this.SDLCServerTermsOfServicesUrlsToView.forEach((url) =>
+                    this.applicationStore.navigator.openNewWindow(url),
+                  ),
+                type: ActionAlertActionType.PROCEED,
+              },
+              {
+                label: 'Done',
+                type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+                handler: (): void => {
+                  this.dismissSDLCServerTermsOfServicesAlert();
+                  this.applicationStore.navigator.reload();
+                },
+              },
+            ],
+          });
+        }
+
+        // fetch server features config
+        yield this.sdlcServerClient.fetchServerFeaturesConfiguration();
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      if (
+        // eslint-disable-next-line no-process-env
+        process.env.NODE_ENV === 'development' &&
+        error instanceof NetworkClientError &&
+        error.response.status === HttpStatus.UNAUTHORIZED
+      ) {
+        this.applicationStore.setActionAlertInfo({
+          message:
+            'The first time the application starts in development mode, the developer would need to authenticate using SDLC server. Please do so then manually reload the app',
+          type: ActionAlertType.STANDARD,
+          actions: [
+            {
+              label: 'Authenticate using SDLC',
+              type: ActionAlertActionType.PROCEED,
+              default: true,
+              handler: (): void => {
+                this.applicationStore.navigator.openNewWindow(
+                  this.sdlcServerClient.currentUserUrl,
+                );
+                this.applicationStore.setBlockingAlert({
+                  message:
+                    'Waiting for the developer to authenticate using SDLC server',
+                  prompt:
+                    'Please manually reload the application after authentication',
+                });
+              },
+            },
+          ],
+        });
+      } else {
+        this.applicationStore.log.error(
+          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+          error,
+        );
+        this.applicationStore.notifyError(error);
+      }
+    }
+  }
+
+  get needsToAcceptSDLCServerTermsOfServices(): boolean {
+    return Boolean(this.SDLCServerTermsOfServicesUrlsToView.length);
+  }
+
+  dismissSDLCServerTermsOfServicesAlert(): void {
+    this.SDLCServerTermsOfServicesUrlsToView = [];
+  }
 }

package/src/stores/editor/NewElementState.ts

@@ -190,7 +190,7 @@ export class NewPackageableRuntimeDriver extends NewElementDriver<PackageableRun
       isValid: computed,
     });
 
-    const mappings = this.editorStore.graphManagerState.graph.ownMappings;
+    const mappings = this.editorStore.graphManagerState.graph.mappings;
     if (mappings.length) {
       this.mapping = mappings[0];
     }
@@ -240,7 +240,7 @@ export class NewPureModelConnectionDriver extends NewConnectionValueDriver<PureM
       isValid: computed,
     });
 
-    const classes = this.editorStore.graphManagerState.graph.ownClasses;
+    const classes = this.editorStore.graphManagerState.graph.classes;
     if (classes.length) {
       this.class = classes[0];
     }
@@ -302,7 +302,7 @@ export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDri
     if (store instanceof Database) {
       selectedStore = store;
     } else {
-      const dbs = this.editorStore.graphManagerState.graph.ownDatabases;
+      const dbs = this.editorStore.graphManagerState.graph.databases;
       selectedStore = dbs.length ? (dbs[0] as Database) : stub_Database();
     }
     return new RelationalDatabaseConnection(
@@ -533,6 +533,7 @@ export class NewGenerationSpecificationDriver extends NewElementDriver<Generatio
   }
 
   get isValid(): boolean {
+    // only one generation specification should exist
     return !this.editorStore.graphManagerState.graph.ownGenerationSpecifications
       .length;
   }

package/src/stores/editor-state/element-editor-state/connection/ConnectionEditorState.ts

@@ -42,6 +42,7 @@ import {
   SnowflakePublicAuthenticationStrategy,
   GCPApplicationDefaultCredentialsAuthenticationStrategy,
   GCPWorkloadIdentityFederationAuthenticationStrategy,
+  MiddleTierUsernamePasswordAuthenticationStrategy,
   EmbeddedH2DatasourceSpecification,
   LocalH2DatasourceSpecification,
   DatabricksDatasourceSpecification,
@@ -94,6 +95,7 @@ export enum CORE_AUTHENTICATION_STRATEGY_TYPE {
   OAUTH = 'OAUTH',
   USERNAME_PASSWORD = 'USERNAME_PASSWORD',
   GCP_WORKLOAD_IDENTITY_FEDERATION = 'GCP_WORKLOAD_IDENTITY_FEDERATION',
+  MIDDLE_TIER_USERNAME_PASSWORD = 'MIDDLE_TIER_USERNAME_PASSWORD',
 }
 
 export class RelationalDatabaseConnectionValueState extends ConnectionValueState {
@@ -262,6 +264,10 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
       auth instanceof GCPWorkloadIdentityFederationAuthenticationStrategy
     ) {
       return CORE_AUTHENTICATION_STRATEGY_TYPE.GCP_WORKLOAD_IDENTITY_FEDERATION;
+    } else if (
+      auth instanceof MiddleTierUsernamePasswordAuthenticationStrategy
+    ) {
+      return CORE_AUTHENTICATION_STRATEGY_TYPE.MIDDLE_TIER_USERNAME_PASSWORD;
     }
 
     const extraAuthenticationStrategyTypeGetters =
@@ -326,6 +332,10 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
         authStrategy = new OAuthAuthenticationStrategy('', '');
         break;
       }
+      case CORE_AUTHENTICATION_STRATEGY_TYPE.MIDDLE_TIER_USERNAME_PASSWORD: {
+        authStrategy = new MiddleTierUsernamePasswordAuthenticationStrategy('');
+        break;
+      }
       default: {
         const extraAuthenticationStrategyCreators =
           this.editorStore.pluginManager

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

@@ -125,6 +125,7 @@ export class ServiceExecutionParameterState extends LambdaParametersState {
       const parmeterState = new LambdaParameterState(
         p,
         this.executionState.editorStore.changeDetectionState.observerContext,
+        this.executionState.editorStore.graphManagerState.graph,
       );
       parmeterState.mockParameterValue();
       return parmeterState;

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

@@ -44,6 +44,7 @@ import {
   isNonNullable,
   returnUndefOnError,
   getNullableFirstElement,
+  uniq,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
@@ -360,6 +361,6 @@ export class ServiceTestDataState {
     } else if (execution instanceof PureMultiExecution) {
       runtimes = execution.executionParameters.map((t) => t.runtime);
     }
-    return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
+    return uniq(runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime));
   }
 }

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

@@ -136,7 +136,10 @@ export class ServiceValueSpecificationTestParameterState extends ServiceTestPara
   }
 
   resetValueSpec(): void {
-    const mockValue = generateVariableExpressionMockValue(this.varExpression);
+    const mockValue = generateVariableExpressionMockValue(
+      this.varExpression,
+      this.editorStore.graphManagerState.graph,
+    );
     if (mockValue) {
       this.updateValueSpecification(mockValue);
     }
@@ -258,7 +261,10 @@ export class ServiceTestSetupState {
   addExpressionParameterValue(expression: VariableExpression): void {
     try {
       const mockValue = guaranteeNonNullable(
-        generateVariableExpressionMockValue(expression),
+        generateVariableExpressionMockValue(
+          expression,
+          this.editorStore.graphManagerState.graph,
+        ),
       );
       const paramValue = new ParameterValue();
       paramValue.name = expression.name;
@@ -338,7 +344,10 @@ export class ServiceTestSetupState {
       const varExpressions = this.queryVariableExpressions;
       const parameterValueStates = varExpressions
         .map((varExpression) => {
-          const mockValue = generateVariableExpressionMockValue(varExpression);
+          const mockValue = generateVariableExpressionMockValue(
+            varExpression,
+            this.editorStore.graphManagerState.graph,
+          );
           if (mockValue) {
             const paramValue = new ParameterValue();
             paramValue.name = varExpression.name;

package/src/stores/graphModifier/StoreRelational_GraphModifierHelper.ts

@@ -38,6 +38,7 @@ import {
   type StaticDatasourceSpecification,
   type UsernamePasswordAuthenticationStrategy,
   type GCPWorkloadIdentityFederationAuthenticationStrategy,
+  type MiddleTierUsernamePasswordAuthenticationStrategy,
   type ObserverContext,
   type EnumerationMappingReference,
   type TableAlias,
@@ -163,6 +164,15 @@ export const gcpWorkloadIdentityFederationAuthenticationStrategy_setAdditionalGc
     },
   );
 
+export const middleTierUsernamePasswordAuthenticationStrategy_setVaultReference =
+  action(
+    (
+      v: MiddleTierUsernamePasswordAuthenticationStrategy,
+      val: string,
+    ): void => {
+      v.vaultReference = val;
+    },
+  );
 // --------------------------------------------- DatasourceSpecification -------------------------------------
 export const staticDatasourceSpecification_setHost = action(
   (v: StaticDatasourceSpecification, val: string): void => {

package/src/stores/shared/testable/TestableUtils.ts

@@ -63,13 +63,14 @@ export const getAllIdentifiedConnectionsFromRuntime = (
 ): IdentifiedConnection[] => {
   const resolvedRuntimes: EngineRuntime[] = [];
   if (runtime instanceof RuntimePointer) {
-    const engineRuntime = runtime.packageableRuntime.value.runtimeValue;
-    resolvedRuntimes.push(engineRuntime);
+    resolvedRuntimes.push(runtime.packageableRuntime.value.runtimeValue);
   } else if (runtime instanceof EngineRuntime) {
     resolvedRuntimes.push(runtime);
   }
   return resolvedRuntimes
-    .flatMap((e) => e.connections.map((l) => l.storeConnections))
+    .flatMap((e) =>
+      e.connections.map((connection) => connection.storeConnections),
+    )
     .flat();
 };