@finos/legend-extension-dsl-service 0.0.1

package/src/stores/studio/UpdateProjectServiceQuerySetupStore.ts

@@ -0,0 +1,281 @@
+/**
+ * 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 { observable, makeObservable, flowResult, flow, action } from 'mobx';
+import {
+  type GeneratorFn,
+  type PlainObject,
+  ActionState,
+  assertErrorThrown,
+  guaranteeNonNullable,
+  LogEvent,
+} from '@finos/legend-shared';
+import {
+  type SDLCServerClient,
+  Workspace,
+  WorkspaceType,
+  Project,
+} from '@finos/legend-server-sdlc';
+import {
+  type LegendStudioApplicationStore,
+  LEGEND_STUDIO_APP_EVENT,
+} from '@finos/legend-application-studio';
+import { generateProjectServiceQueryUpdaterSetupRoute } from './DSL_Service_LegendStudioRouter.js';
+import { CORE_PURE_PATH } from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+
+const MINIMUM_PROJECT_LOADER_SEARCH_LENGTH = 3;
+const DEFAULT_PROJECT_LOADER_LIMIT = 10;
+
+export class UpdateProjectServiceQuerySetupStore {
+  applicationStore: LegendStudioApplicationStore;
+  sdlcServerClient: SDLCServerClient;
+
+  initState = ActionState.create();
+  loadProjectsState = ActionState.create();
+  projects: Project[] = [];
+  currentProject?: Project | undefined;
+
+  loadWorkspacesState = ActionState.create();
+  createWorkspaceState = ActionState.create();
+  groupWorkspaces: Workspace[] = [];
+  currentGroupWorkspace?: Workspace | undefined;
+  showCreateWorkspaceModal = false;
+
+  services: Entity[] = [];
+  currentService?: Entity | undefined;
+
+  constructor(
+    applicationStore: LegendStudioApplicationStore,
+    sdlcServerClient: SDLCServerClient,
+  ) {
+    makeObservable(this, {
+      projects: observable,
+      currentProject: observable,
+      groupWorkspaces: observable,
+      currentGroupWorkspace: observable,
+      showCreateWorkspaceModal: observable,
+      services: observable,
+      currentService: observable,
+      setShowCreateWorkspaceModal: action,
+      resetCurrentProject: action,
+      resetCurrentGroupWorkspace: action,
+      resetCurrentService: action,
+      changeService: action,
+      initialize: flow,
+      loadProjects: flow,
+      changeProject: flow,
+      changeWorkspace: flow,
+      createWorkspace: flow,
+    });
+
+    this.applicationStore = applicationStore;
+    this.sdlcServerClient = sdlcServerClient;
+  }
+
+  setShowCreateWorkspaceModal(val: boolean): void {
+    this.showCreateWorkspaceModal = val;
+  }
+
+  resetCurrentProject(): void {
+    this.currentProject = undefined;
+    this.groupWorkspaces = [];
+    this.resetCurrentGroupWorkspace();
+    this.applicationStore.navigator.goTo(
+      generateProjectServiceQueryUpdaterSetupRoute(undefined),
+    );
+  }
+
+  resetCurrentGroupWorkspace(): void {
+    this.currentGroupWorkspace = undefined;
+    this.services = [];
+    this.resetCurrentService();
+  }
+
+  resetCurrentService(): void {
+    this.currentService = undefined;
+  }
+
+  *initialize(projectId: string | undefined): GeneratorFn<void> {
+    if (!this.initState.isInInitialState) {
+      return;
+    }
+    this.initState.inProgress();
+
+    try {
+      if (projectId) {
+        let project: Project;
+        try {
+          project = Project.serialization.fromJson(
+            (yield this.sdlcServerClient.getProject(
+              projectId,
+            )) as PlainObject<Project>,
+          );
+        } catch {
+          this.applicationStore.navigator.goTo(
+            generateProjectServiceQueryUpdaterSetupRoute(undefined),
+          );
+          this.initState.pass();
+          return;
+        }
+        yield flowResult(this.changeProject(project));
+      }
+
+      this.initState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+      this.initState.fail();
+    }
+  }
+
+  *loadProjects(searchText: string): GeneratorFn<void> {
+    const isValidSearchString =
+      searchText.length >= MINIMUM_PROJECT_LOADER_SEARCH_LENGTH;
+    this.loadProjectsState.inProgress();
+    try {
+      this.projects = (
+        (yield this.sdlcServerClient.getProjects(
+          undefined,
+          isValidSearchString ? searchText : undefined,
+          undefined,
+          DEFAULT_PROJECT_LOADER_LIMIT,
+        )) as PlainObject<Project>[]
+      ).map((v) => Project.serialization.fromJson(v));
+      this.loadProjectsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadProjectsState.fail();
+    }
+  }
+
+  *changeProject(project: Project): GeneratorFn<void> {
+    this.currentProject = project;
+    this.applicationStore.navigator.goTo(
+      generateProjectServiceQueryUpdaterSetupRoute(project.projectId),
+    );
+
+    this.loadWorkspacesState.inProgress();
+    try {
+      const workspacesInConflictResolutionIds = (
+        (yield this.sdlcServerClient.getWorkspacesInConflictResolutionMode(
+          project.projectId,
+        )) as Workspace[]
+      ).map((workspace) => workspace.workspaceId);
+
+      this.groupWorkspaces = (
+        (yield this.sdlcServerClient.getGroupWorkspaces(
+          project.projectId,
+        )) as PlainObject<Workspace>[]
+      )
+        .map((v) => Workspace.serialization.fromJson(v))
+        .filter(
+          (workspace) =>
+            // NOTE we don't handle workspaces that only have conflict resolution but no standard workspace
+            // since that indicates bad state of the SDLC server
+            !workspacesInConflictResolutionIds.includes(
+              workspace.workspaceId,
+            ) && workspace.workspaceType === WorkspaceType.GROUP,
+        );
+
+      if (this.groupWorkspaces.length) {
+        yield flowResult(
+          this.changeWorkspace(guaranteeNonNullable(this.groupWorkspaces[0])),
+        );
+      }
+
+      this.loadWorkspacesState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+      this.loadWorkspacesState.fail();
+    }
+  }
+
+  *changeWorkspace(workspace: Workspace): GeneratorFn<void> {
+    this.currentGroupWorkspace = workspace;
+
+    try {
+      const entities = (yield flowResult(
+        this.sdlcServerClient.getEntities(workspace.projectId, workspace),
+      )) as Entity[];
+      this.services = entities.filter(
+        (entity) => entity.classifierPath === CORE_PURE_PATH.SERVICE,
+      );
+
+      if (this.services.length) {
+        this.changeService(guaranteeNonNullable(this.services[0]));
+      }
+    } catch {
+      this.services = [];
+      this.resetCurrentService();
+    }
+  }
+
+  changeService(service: Entity): void {
+    this.currentService = service;
+  }
+
+  *createWorkspace(projectId: string, workspaceId: string): GeneratorFn<void> {
+    this.createWorkspaceState.inProgress();
+    try {
+      const newGroupWorkspace = Workspace.serialization.fromJson(
+        (yield this.sdlcServerClient.createWorkspace(
+          projectId,
+          workspaceId,
+          WorkspaceType.GROUP,
+        )) as PlainObject<Workspace>,
+      );
+
+      this.applicationStore.notifySuccess(
+        `Workspace '${newGroupWorkspace.workspaceId}' is succesfully created`,
+      );
+
+      const matchingGroupWorkspace = this.groupWorkspaces.find(
+        (workspace) => workspace.workspaceId === newGroupWorkspace.workspaceId,
+      );
+      const groupWorkspaceToSelect =
+        matchingGroupWorkspace ?? newGroupWorkspace;
+
+      yield flowResult(this.changeWorkspace(groupWorkspaceToSelect));
+      this.setShowCreateWorkspaceModal(false);
+
+      // NOTE: do this after closing the modal to not interfere
+      // with validation of existing workspaces in create workspace modal
+      if (!matchingGroupWorkspace) {
+        this.groupWorkspaces.push(newGroupWorkspace);
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_SETUP_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+    } finally {
+      this.createWorkspaceState.reset();
+    }
+  }
+}

package/src/stores/studio/UpdateServiceQuerySetupStore.ts

@@ -0,0 +1,314 @@
+/**
+ * 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 { observable, makeObservable, flowResult, flow, action } from 'mobx';
+import {
+  type GeneratorFn,
+  type PlainObject,
+  ActionState,
+  assertErrorThrown,
+  guaranteeNonNullable,
+  LogEvent,
+} from '@finos/legend-shared';
+import {
+  type DepotServerClient,
+  type StoredEntity,
+  DepotScope,
+  ProjectData,
+  MASTER_SNAPSHOT_ALIAS,
+} from '@finos/legend-server-depot';
+import {
+  extractServiceInfo,
+  type ServiceInfo,
+} from '@finos/legend-query-builder';
+import {
+  type SDLCServerClient,
+  Workspace,
+  WorkspaceType,
+} from '@finos/legend-server-sdlc';
+import {
+  type LegendStudioApplicationStore,
+  LEGEND_STUDIO_APP_EVENT,
+} from '@finos/legend-application-studio';
+import {
+  generateServiceQueryUpdaterSetupRoute,
+  parseServiceCoordinates,
+} from './DSL_Service_LegendStudioRouter.js';
+import { CORE_PURE_PATH } from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+
+const MINIMUM_SERVICE_LOADER_SEARCH_LENGTH = 3;
+const DEFAULT_SERVICE_LOADER_LIMIT = 10;
+
+export class UpdateServiceQuerySetupStore {
+  applicationStore: LegendStudioApplicationStore;
+  sdlcServerClient: SDLCServerClient;
+  depotServerClient: DepotServerClient;
+
+  initState = ActionState.create();
+  loadServicesState = ActionState.create();
+  services: ServiceInfo[] = [];
+  currentProject?: ProjectData | undefined;
+  currentSnapshotService?: ServiceInfo | undefined;
+
+  loadWorkspacesState = ActionState.create();
+  createWorkspaceState = ActionState.create();
+  groupWorkspaces: Workspace[] = [];
+  currentGroupWorkspace?: Workspace | undefined;
+  currentWorkspaceService?: Entity | undefined;
+  checkWorkspaceCompatibilityState = ActionState.create();
+  showCreateWorkspaceModal = false;
+
+  constructor(
+    applicationStore: LegendStudioApplicationStore,
+    sdlcServerClient: SDLCServerClient,
+    depotServerClient: DepotServerClient,
+  ) {
+    makeObservable(this, {
+      services: observable,
+      currentProject: observable,
+      currentSnapshotService: observable,
+      groupWorkspaces: observable,
+      currentGroupWorkspace: observable,
+      currentWorkspaceService: observable,
+      showCreateWorkspaceModal: observable,
+      setShowCreateWorkspaceModal: action,
+      resetCurrentService: action,
+      resetCurrentGroupWorkspace: action,
+      initialize: flow,
+      loadServices: flow,
+      changeService: flow,
+      changeWorkspace: flow,
+      createWorkspace: flow,
+    });
+
+    this.applicationStore = applicationStore;
+    this.sdlcServerClient = sdlcServerClient;
+    this.depotServerClient = depotServerClient;
+  }
+
+  setShowCreateWorkspaceModal(val: boolean): void {
+    this.showCreateWorkspaceModal = val;
+  }
+
+  resetCurrentService(): void {
+    this.currentProject = undefined;
+    this.currentSnapshotService = undefined;
+    this.groupWorkspaces = [];
+    this.resetCurrentGroupWorkspace();
+    this.applicationStore.navigator.goTo(
+      generateServiceQueryUpdaterSetupRoute(undefined, undefined, undefined),
+    );
+  }
+
+  resetCurrentGroupWorkspace(): void {
+    this.currentGroupWorkspace = undefined;
+    this.currentWorkspaceService = undefined;
+  }
+
+  *initialize(serviceCoordinates: string | undefined): GeneratorFn<void> {
+    if (!this.initState.isInInitialState) {
+      return;
+    }
+    this.initState.inProgress();
+
+    try {
+      if (serviceCoordinates) {
+        const { groupId, artifactId, servicePath } =
+          parseServiceCoordinates(serviceCoordinates);
+        yield flowResult(this.changeService(groupId, artifactId, servicePath));
+      }
+
+      this.initState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.DEPOT_MANAGER_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+      this.initState.fail();
+    }
+  }
+
+  *loadServices(searchText: string): GeneratorFn<void> {
+    const isValidSearchString =
+      searchText.length >= MINIMUM_SERVICE_LOADER_SEARCH_LENGTH;
+    this.loadServicesState.inProgress();
+    try {
+      this.services = (
+        (yield this.depotServerClient.getEntitiesByClassifierPath(
+          CORE_PURE_PATH.SERVICE,
+          {
+            search: isValidSearchString ? searchText : undefined,
+            // NOTE: since this mode is meant for contribution, we want to load services
+            // on the snapshot version (i.e. merged to the default branch on the projects)
+            scope: DepotScope.SNAPSHOT,
+            limit: DEFAULT_SERVICE_LOADER_LIMIT,
+          },
+        )) as StoredEntity[]
+      ).map((storedEntity) => extractServiceInfo(storedEntity));
+      this.loadServicesState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadServicesState.fail();
+    }
+  }
+
+  *changeService(
+    groupId: string,
+    artifactId: string,
+    servicePath: string,
+  ): GeneratorFn<void> {
+    this.loadWorkspacesState.inProgress();
+
+    try {
+      const project = ProjectData.serialization.fromJson(
+        (yield this.depotServerClient.getProject(
+          groupId,
+          artifactId,
+        )) as PlainObject<ProjectData>,
+      );
+
+      this.currentProject = project;
+
+      const serviceEntity = (yield this.depotServerClient.getEntity(
+        project,
+        MASTER_SNAPSHOT_ALIAS,
+        servicePath,
+      )) as Entity;
+      this.currentSnapshotService = extractServiceInfo({
+        groupId: groupId,
+        artifactId: artifactId,
+        versionId: MASTER_SNAPSHOT_ALIAS,
+        entity: serviceEntity,
+      });
+
+      this.applicationStore.navigator.goTo(
+        generateServiceQueryUpdaterSetupRoute(
+          project.groupId,
+          project.artifactId,
+          servicePath,
+        ),
+      );
+
+      const workspacesInConflictResolutionIds = (
+        (yield this.sdlcServerClient.getWorkspacesInConflictResolutionMode(
+          project.projectId,
+        )) as Workspace[]
+      ).map((workspace) => workspace.workspaceId);
+
+      this.groupWorkspaces = (
+        (yield this.sdlcServerClient.getGroupWorkspaces(
+          project.projectId,
+        )) as PlainObject<Workspace>[]
+      )
+        .map((v) => Workspace.serialization.fromJson(v))
+        .filter(
+          (workspace) =>
+            // NOTE we don't handle workspaces that only have conflict resolution but no standard workspace
+            // since that indicates bad state of the SDLC server
+            !workspacesInConflictResolutionIds.includes(
+              workspace.workspaceId,
+            ) && workspace.workspaceType === WorkspaceType.GROUP,
+        );
+
+      if (this.groupWorkspaces.length) {
+        yield flowResult(
+          this.changeWorkspace(
+            guaranteeNonNullable(this.groupWorkspaces[0]),
+            servicePath,
+          ),
+        );
+      }
+
+      this.loadWorkspacesState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.DEPOT_MANAGER_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+      this.loadWorkspacesState.fail();
+    }
+  }
+
+  *changeWorkspace(
+    workspace: Workspace,
+    servicePath: string,
+  ): GeneratorFn<void> {
+    this.currentGroupWorkspace = workspace;
+
+    this.checkWorkspaceCompatibilityState.inProgress();
+    try {
+      this.currentWorkspaceService = (yield flowResult(
+        this.sdlcServerClient.getWorkspaceEntity(workspace, servicePath),
+      )) as Entity;
+    } catch {
+      this.currentWorkspaceService = undefined;
+    }
+    this.checkWorkspaceCompatibilityState.reset();
+  }
+
+  *createWorkspace(
+    projectId: string,
+    workspaceId: string,
+    servicePath: string,
+  ): GeneratorFn<void> {
+    this.createWorkspaceState.inProgress();
+    try {
+      const newGroupWorkspace = Workspace.serialization.fromJson(
+        (yield this.sdlcServerClient.createWorkspace(
+          projectId,
+          workspaceId,
+          WorkspaceType.GROUP,
+        )) as PlainObject<Workspace>,
+      );
+
+      this.applicationStore.notifySuccess(
+        `Workspace '${newGroupWorkspace.workspaceId}' is succesfully created`,
+      );
+
+      const matchingGroupWorkspace = this.groupWorkspaces.find(
+        (workspace) => workspace.workspaceId === newGroupWorkspace.workspaceId,
+      );
+      const groupWorkspaceToSelect =
+        matchingGroupWorkspace ?? newGroupWorkspace;
+
+      yield flowResult(
+        this.changeWorkspace(groupWorkspaceToSelect, servicePath),
+      );
+      this.setShowCreateWorkspaceModal(false);
+
+      // NOTE: do this after closing the modal to not interfere
+      // with validation of existing workspaces in create workspace modal
+      if (!matchingGroupWorkspace) {
+        this.groupWorkspaces.push(newGroupWorkspace);
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_SETUP_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+    } finally {
+      this.createWorkspaceState.reset();
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,58 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "webworker",
+      "scripthost"
+    ],
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "nodenext",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "importsNotUsedAsValues": "error",
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./lib",
+    "tsBuildInfoFile": "./build/prod.tsbuildinfo",
+    "rootDir": "./src",
+    "jsx": "react-jsx"
+  },
+  "references": [
+    {
+      "path": "./tsconfig.package.json"
+    }
+  ],
+  "files": [
+    "./src/index.ts",
+    "./src/stores/studio/DSL_Service_LegendStudioRouter.ts",
+    "./src/stores/studio/ServiceQueryEditorStore.ts",
+    "./src/stores/studio/UpdateProjectServiceQuerySetupStore.ts",
+    "./src/stores/studio/UpdateServiceQuerySetupStore.ts",
+    "./src/components/studio/DSL_Service_LegendStudioApplicationPlugin.tsx",
+    "./src/components/studio/ServiceQueryEditor.tsx",
+    "./src/components/studio/ServiceQueryEditorReviewAction.tsx",
+    "./src/components/studio/ServiceQueryEditorStoreProvider.tsx",
+    "./src/components/studio/ServiceQueryEditorWorkspaceStatus.tsx",
+    "./src/components/studio/UpdateProjectServiceQuerySetup.tsx",
+    "./src/components/studio/UpdateServiceQuerySetup.tsx"
+  ],
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.json"
+  ],
+  "exclude": [
+    "src/**/__tests__/**/*.*",
+    "src/**/__mocks__/**/*.*"
+  ]
+}

package/tsconfig.package.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "webworker",
+      "scripthost"
+    ],
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "nodenext",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "importsNotUsedAsValues": "error",
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./lib",
+    "tsBuildInfoFile": "./build/package.tsbuildinfo",
+    "rootDir": "./"
+  },
+  "files": [
+    "./package.json"
+  ],
+  "include": [
+    "package.json"
+  ],
+  "exclude": [
+    "lib"
+  ]
+}