@finos/legend-application-studio 28.15.4 → 28.15.6

package/src/components/editor/editor-group/function-activator/SnowflakeAppFunctionActivatorEditor.tsx

@@ -33,17 +33,19 @@ import {
   generateFunctionPrettyName,
   RelationalDatabaseConnection,
   DatabaseType,
+  DeploymentOwner,
 } from '@finos/legend-graph';
 import { observer } from 'mobx-react-lite';
 import { useApplicationStore } from '@finos/legend-application';
 import { useEditorStore } from '../../EditorStoreProvider.js';
 import { SnowflakeAppFunctionActivatorEdtiorState } from '../../../../stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.js';
 import { flowResult } from 'mobx';
-import { useRef } from 'react';
+import { useRef, useState } from 'react';
 import {
   buildRelationalDatabaseConnectionOption,
   type RelationalDatabaseConnectionOption,
 } from '../connection-editor/RelationalDatabaseConnectionEditor.js';
+import { activator_setDeploymentOwner } from '../../../../stores/graph-modifier/DSL_FunctionActivator_GraphModifierHelper.js';
 
 export const SnowflakeAppFunctionActivatorEditor = observer(() => {
   const editorStore = useEditorStore();
@@ -51,7 +53,9 @@ export const SnowflakeAppFunctionActivatorEditor = observer(() => {
   const editorState = editorStore.tabManagerState.getCurrentEditorState(
     SnowflakeAppFunctionActivatorEdtiorState,
   );
+  const isReadOnly = editorState.isReadOnly;
   const activator = editorState.activator;
+  const ownership = activator.ownership;
   const connectionSelectorRef = useRef<SelectComponent>(null);
   const connectionFilterOption = createFilter({
     ignoreCase: true,
@@ -86,7 +90,7 @@ export const SnowflakeAppFunctionActivatorEditor = observer(() => {
     : initializeActivationConnection(connectionOptions.at(0)?.value);
 
   const changeConnection = (val: RelationalDatabaseConnectionOption): void => {
-    if (val.value === activationConnection) {
+    if (!isReadOnly && val.value === activationConnection) {
       return;
     }
     editorState.updateConnection(val.value);
@@ -94,7 +98,9 @@ export const SnowflakeAppFunctionActivatorEditor = observer(() => {
   const changeDescription: React.ChangeEventHandler<HTMLTextAreaElement> = (
     event,
   ) => {
-    editorState.updateAppDescription(event.target.value);
+    if (!isReadOnly) {
+      editorState.updateAppDescription(event.target.value);
+    }
   };
   const visitFunction = (): void =>
     editorState.editorStore.graphEditorMode.openElement(
@@ -116,6 +122,17 @@ export const SnowflakeAppFunctionActivatorEditor = observer(() => {
     );
   };
 
+  //Ownership
+  const [ownerInputValue, setOwner] = useState<string>('');
+  const updateDeploymentIdentifier: React.ChangeEventHandler<
+    HTMLInputElement
+  > = (event) => {
+    if (!isReadOnly) {
+      setOwner(event.target.value);
+      activator_setDeploymentOwner(ownership, event.target.value);
+    }
+  };
+
   return (
     <div className="snowflake-app-function-activator-editor">
       <Panel>
@@ -225,6 +242,7 @@ export const SnowflakeAppFunctionActivatorEditor = observer(() => {
           <PanelForm>
             <PanelFormTextField
               value={activator.applicationName}
+              isReadOnly={isReadOnly}
               name="Activator Identifer"
               placeholder="Specify the name of the UDTF for this activator..."
               update={(value: string | undefined): void =>
@@ -241,11 +259,41 @@ export const SnowflakeAppFunctionActivatorEditor = observer(() => {
               <textarea
                 className="panel__content__form__section__textarea service-editor__documentation__input"
                 spellCheck={false}
+                disabled={isReadOnly}
                 value={activator.description}
                 onChange={changeDescription}
               />
             </div>
           </PanelForm>
+          <PanelForm>
+            <div>
+              <div className="panel__content__form__section">
+                <div className="panel__content__form__section__header__label">
+                  Ownership
+                </div>
+                <div className="panel__content__form__section__header__prompt">
+                  The ownership model you want to use to control your snowflake
+                  app.
+                </div>
+              </div>
+              {ownership instanceof DeploymentOwner && (
+                <div className="panel__content__form__section">
+                  <div>
+                    <div className="panel__content__form__section__header__label">
+                      Deployment Identifier :
+                    </div>
+                    <input
+                      className="panel__content__form__section__input"
+                      spellCheck={false}
+                      disabled={isReadOnly}
+                      value={ownerInputValue}
+                      onChange={updateDeploymentIdentifier}
+                    />
+                  </div>
+                </div>
+              )}
+            </div>
+          </PanelForm>
         </PanelContent>
       </Panel>
     </div>

package/src/components/project-reviewer/ProjectReviewSideBar.tsx

@@ -90,7 +90,7 @@ export const ProjectReviewerSideBar = observer(() => {
   }
   // Actions
   const isDispatchingAction =
-    reviewStore.fetchComparisonState.isInProgress ||
+    reviewStore.buildReviewReportState.isInProgress ||
     reviewStore.approveState.isInProgress ||
     reviewStore.closeState.isInProgress ||
     reviewStore.commitState.isInProgress ||

package/src/components/project-reviewer/ProjectReviewer.tsx

@@ -65,7 +65,7 @@ const ProjectReviewerStatusBar = observer(() => {
     ? 'closing review...'
     : reviewStore.reOpenState.isInProgress
     ? 'reopening review...'
-    : reviewStore.fetchComparisonState.isInProgress
+    : reviewStore.buildReviewReportState.isInProgress
     ? 'loading changes...'
     : undefined;
   const toggleAssistant = (): void =>

package/src/stores/editor/EditorGraphState.ts

@@ -89,6 +89,7 @@ import {
   ExecutionEnvironmentInstance,
   SnowflakeApp,
   GraphEntities,
+  HostedService,
 } from '@finos/legend-graph';
 import { CONFIGURATION_EDITOR_TAB } from './editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.js';
 import { PACKAGEABLE_ELEMENT_TYPE } from './utils/ModelClassifierUtils.js';
@@ -872,6 +873,8 @@ export class EditorGraphState {
       return PACKAGEABLE_ELEMENT_TYPE.EXECUTION_ENVIRONMENT;
     } else if (element instanceof SnowflakeApp) {
       return PACKAGEABLE_ELEMENT_TYPE.SNOWFLAKE_APP;
+    } else if (element instanceof HostedService) {
+      return PACKAGEABLE_ELEMENT_TYPE.HOSTED_SERVICE;
     }
     const extraElementTypeLabelGetters = this.editorStore.pluginManager
       .getApplicationPlugins()

package/src/stores/editor/EditorTabManagerState.ts

@@ -34,6 +34,7 @@ import {
   Service,
   INTERNAL__UnknownFunctionActivator,
   SnowflakeApp,
+  HostedService,
 } from '@finos/legend-graph';
 import {
   type Clazz,
@@ -61,6 +62,7 @@ import type { DSL_LegendStudioApplicationPlugin_Extension } from '../LegendStudi
 import { TabManagerState } from '@finos/legend-lego/application';
 import { INTERNAL__UnknownFunctionActivatorEdtiorState } from './editor-state/element-editor-state/function-activator/INTERNAL__UnknownFunctionActivatorEditorState.js';
 import { SnowflakeAppFunctionActivatorEdtiorState } from './editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.js';
+import { HostedServiceFunctionActivatorEditorState } from './editor-state/element-editor-state/function-activator/HostedServiceFunctionActivatorEditorState.js';
 
 export class EditorTabManagerState extends TabManagerState {
   readonly editorStore: EditorStore;
@@ -133,6 +135,11 @@ export class EditorTabManagerState extends TabManagerState {
         this.editorStore,
         element,
       );
+    } else if (element instanceof HostedService) {
+      return new HostedServiceFunctionActivatorEditorState(
+        this.editorStore,
+        element,
+      );
     } else if (element instanceof INTERNAL__UnknownFunctionActivator) {
       return new INTERNAL__UnknownFunctionActivatorEdtiorState(
         this.editorStore,

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

@@ -23,12 +23,15 @@ import {
   LogEvent,
   assertErrorThrown,
   guaranteeNonNullable,
+  guaranteeType,
+  isType,
 } from '@finos/legend-shared';
 import {
   type CompilationError,
   type PackageableElement,
   GRAPH_MANAGER_EVENT,
   isElementReadOnly,
+  INTERNAL__UnknownPackageableElement,
 } from '@finos/legend-graph';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 import type { ElementFileGenerationState } from './ElementFileGenerationState.js';
@@ -198,12 +201,26 @@ export abstract class ElementEditorState extends EditorState {
       );
     } catch (error) {
       assertErrorThrown(error);
-      this.setTextContent(
-        generateMultiLineCommentForError(
-          `Can't generate protocol JSON for element`,
-          error,
-        ),
+      const isUnknownEntity = isType(
+        this.element,
+        INTERNAL__UnknownPackageableElement,
       );
+      if (isUnknownEntity) {
+        const unknownEntity = guaranteeType(
+          this.element,
+          INTERNAL__UnknownPackageableElement,
+        );
+        this.setTextContent(
+          JSON.stringify(unknownEntity.content, undefined, DEFAULT_TAB_SIZE),
+        );
+      } else {
+        this.setTextContent(
+          generateMultiLineCommentForError(
+            `Can't generate protocol JSON for element`,
+            error,
+          ),
+        );
+      }
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
         error,

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

@@ -25,8 +25,9 @@ import {
   extractPackagePathFromPath,
   SnowflakeAppDeploymentConfiguration,
   DeploymentOwner,
+  HostedService,
 } from '@finos/legend-graph';
-import { type GeneratorFn } from '@finos/legend-shared';
+import { uuid, type GeneratorFn } from '@finos/legend-shared';
 import { FUNCTION_ACTIVATE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
 
 const BASE_ACTIVATOR_NAME = 'NewActivator';
@@ -100,6 +101,21 @@ export class FunctionActivatorState {
           new SnowflakeAppDeploymentConfiguration();
         return snowflakeApp;
       }
+      case FUNCTION_ACTIVATE_TYPE.HOSTED_SERVICE: {
+        const activatorName = this.activatorPath.includes('::')
+          ? extractElementNameFromPath(this.activatorPath)
+          : this.activatorPath;
+        const hostedService = new HostedService(activatorName);
+        hostedService.documentation = '';
+        hostedService.ownership = new DeploymentOwner('', hostedService);
+        hostedService.pattern = `/${uuid()}`;
+        hostedService.autoActivateUpdates = true;
+        hostedService.storeModel = false;
+        hostedService.generateLineage = false;
+        hostedService.function =
+          PackageableElementExplicitReference.create(functionElement);
+        return hostedService;
+      }
       default:
         return undefined;
     }

package/src/stores/editor/editor-state/element-editor-state/function-activator/HostedServiceFunctionActivatorEditorState.ts

@@ -0,0 +1,212 @@
+/**
+ * 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 {
+  InMemoryGraphData,
+  HostedService,
+  observe_HostedService,
+  DeploymentOwner,
+  UserList,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  guaranteeType,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { makeObservable, action, flow, computed } from 'mobx';
+import type { EditorStore } from '../../../EditorStore.js';
+import { ElementEditorState } from '../ElementEditorState.js';
+import { activator_setOwnership } from '../../../../graph-modifier/DSL_FunctionActivator_GraphModifierHelper.js';
+import { User } from '@finos/legend-server-sdlc';
+
+//Ownership
+enum HostedServiceOwnershipType {
+  DEPLOYMENT_OWNERSHIP = 'deploymentOwnership',
+  USERLIST_OWNERSHIP = 'userListOwnership',
+}
+export const MINIMUM_HOSTED_SERVICE_OWNERS = 2;
+export const DeploymentOwnershipLabel = 'Deployment';
+export const UserlistOwnershipLabel = 'User List';
+
+export const OWNERSHIP_OPTIONS = [
+  {
+    label: DeploymentOwnershipLabel,
+    value: HostedServiceOwnershipType.DEPLOYMENT_OWNERSHIP,
+  },
+  {
+    label: UserlistOwnershipLabel,
+    value: HostedServiceOwnershipType.USERLIST_OWNERSHIP,
+  },
+];
+
+export type HostedServiceOwnerOption = {
+  label: string;
+  value: string;
+};
+
+export class HostedServiceFunctionActivatorEditorState extends ElementEditorState {
+  readonly validateState = ActionState.create();
+  readonly deployState = ActionState.create();
+
+  constructor(editorStore: EditorStore, element: HostedService) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      activator: computed,
+      reprocess: action,
+      updateDocumentation: action,
+      updatePattern: action,
+      setSelectedOwnership: action,
+      selectedOwnership: computed,
+      storeModel: action,
+      generateLineage: action,
+      validate: flow,
+      deployToSandbox: flow,
+      searchUsers: flow,
+    });
+  }
+
+  get activator(): HostedService {
+    return observe_HostedService(
+      guaranteeType(
+        this.element,
+        HostedService,
+        'Element inside hosted service state must be a HostedService',
+      ),
+    );
+  }
+
+  updateDocumentation(val: string): void {
+    this.activator.documentation = val;
+  }
+
+  updatePattern(val: string): void {
+    this.activator.pattern = val;
+  }
+
+  storeModel(val: boolean): void {
+    this.activator.storeModel = val;
+  }
+
+  generateLineage(val: boolean): void {
+    this.activator.generateLineage = val;
+  }
+
+  get selectedOwnership(): HostedServiceOwnerOption | undefined {
+    const ownership = this.activator.ownership;
+    if (ownership instanceof DeploymentOwner) {
+      return {
+        label: DeploymentOwnershipLabel,
+        value: HostedServiceOwnershipType.DEPLOYMENT_OWNERSHIP,
+      };
+    } else if (ownership instanceof UserList) {
+      return {
+        label: UserlistOwnershipLabel,
+        value: HostedServiceOwnershipType.USERLIST_OWNERSHIP,
+      };
+    }
+    return undefined;
+  }
+
+  setSelectedOwnership(o: HostedServiceOwnerOption): void {
+    switch (o.value) {
+      case HostedServiceOwnershipType.DEPLOYMENT_OWNERSHIP: {
+        activator_setOwnership(
+          this.activator,
+          new DeploymentOwner('', this.activator),
+        );
+        break;
+      }
+      case HostedServiceOwnershipType.USERLIST_OWNERSHIP: {
+        const currentUserId =
+          this.editorStore.graphManagerState.graphManager.TEMPORARY__getEngineConfig()
+            .currentUserId;
+        activator_setOwnership(
+          this.activator,
+          new UserList(currentUserId ? [currentUserId] : [], this.activator),
+        );
+        break;
+      }
+      default: {
+        this.editorStore.applicationStore.notificationService.notifyError(
+          'Unsupported ownership type',
+        );
+      }
+    }
+  }
+
+  *validate(): GeneratorFn<void> {
+    this.validateState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.validateFunctionActivator(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Hosted Service is valid`,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.validateState.complete();
+    }
+  }
+
+  *deployToSandbox(): GeneratorFn<void> {
+    this.deployState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        'Hosted Service Function Activator has been deployed successfully',
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.deployState.complete();
+    }
+  }
+
+  *searchUsers(name: string): GeneratorFn<User[]> {
+    try {
+      return (
+        (yield this.editorStore.sdlcServerClient.getUsers(
+          name,
+        )) as PlainObject<User>[]
+      ).map((p) => User.serialization.fromJson(p));
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      return [];
+    }
+  }
+
+  reprocess(
+    newElement: HostedService,
+    editorStore: EditorStore,
+  ): HostedServiceFunctionActivatorEditorState {
+    return new HostedServiceFunctionActivatorEditorState(
+      editorStore,
+      newElement,
+    );
+  }
+}

package/src/stores/editor/utils/ModelClassifierUtils.ts

@@ -70,6 +70,7 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   SECTION_INDEX = 'SECTION_INDEX',
   DATA = 'DATA',
   SNOWFLAKE_APP = 'SNOWFLAKE_APP',
+  HOSTED_SERVICE = 'HOSTED_SERVICE',
 
   TEMPORARY__LOCAL_CONNECTION = 'LOCAL_CONNECTION',
   INTERNAL__UNKNOWN = 'UNKNOWN',

package/src/stores/graph-modifier/DSL_FunctionActivator_GraphModifierHelper.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 HostedService,
+  DEFAULT_HOSTED_SERVICE_PATTERN,
+  type FunctionActivator,
+  type Ownership,
+  observe_FunctionActivatorOwnership,
+  type DeploymentOwner,
+  type UserList,
+} from '@finos/legend-graph';
+import { action } from 'mobx';
+
+export const hostedService_setDocumentation = action(
+  (hostedService: HostedService, val: string): void => {
+    hostedService.documentation = val;
+  },
+);
+
+export const hostedService_setAutoActivateUpdates = action(
+  (hostedService: HostedService, val: boolean): void => {
+    hostedService.autoActivateUpdates = val;
+  },
+);
+
+export const hostedService_setPattern = action(
+  (hostedService: HostedService, val: string): void => {
+    hostedService.pattern = val;
+  },
+);
+
+export const hostedService_removePatternParameter = action(
+  (hostedService: HostedService, value: string): void => {
+    const newPattern = hostedService.pattern
+      .replace(new RegExp(`\\/\\{${value}\\}`, 'ug'), '')
+      .replace(/\/{2,}/gu, '/');
+    hostedService.pattern =
+      newPattern !== '' ? newPattern : DEFAULT_HOSTED_SERVICE_PATTERN;
+  },
+);
+
+export const hostedService_setStoreModel = action(
+  (hostedService: HostedService, val: boolean): void => {
+    hostedService.storeModel = val;
+  },
+);
+
+export const hostedService_setGenerateLineage = action(
+  (hostedService: HostedService, val: boolean): void => {
+    hostedService.generateLineage = val;
+  },
+);
+
+export const activator_setOwnership = action(
+  (activator: FunctionActivator, value: Ownership): void => {
+    activator.ownership = observe_FunctionActivatorOwnership(value);
+  },
+);
+
+export const activator_setDeploymentOwner = action(
+  (deploymentOwner: DeploymentOwner, value: string): void => {
+    deploymentOwner.id = value;
+  },
+);
+
+export const activator_addUserOwner = action(
+  (userList: UserList, value: string): void => {
+    userList.users.push(value);
+  },
+);
+
+export const activator_updateUserOwnership = action(
+  (userList: UserList, value: string, index: number): void => {
+    userList.users[index] = value;
+  },
+);
+
+export const activator_deleteValueFromUserOwnership = action(
+  (userList: UserList, index: number): void => {
+    userList.users.splice(index, 1);
+  },
+);