@finos/legend-application-studio 23.0.0 → 23.0.2

package/src/stores/editor/sidebar-state/WorkflowManagerState.ts

@@ -0,0 +1,645 @@
+/**
+ * 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 { TreeNodeData, TreeData } from '@finos/legend-art';
+import { observable, action, flowResult, makeObservable, flow } from 'mobx';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../application/LegendStudioEvent.js';
+import type { EditorStore } from '../EditorStore.js';
+import type { EditorSDLCState } from '../EditorSDLCState.js';
+import {
+  type GeneratorFn,
+  type PlainObject,
+  uuid,
+  assertErrorThrown,
+  LogEvent,
+  ActionState,
+  filterByType,
+} from '@finos/legend-shared';
+import { type Version, WorkflowJob, Workflow } from '@finos/legend-server-sdlc';
+
+export abstract class WorkflowExplorerTreeNodeData implements TreeNodeData {
+  isSelected?: boolean | undefined;
+  isOpen?: boolean | undefined;
+  id: string;
+  label: string;
+  childrenIds: string[] | undefined;
+
+  constructor(id: string, label: string) {
+    this.id = id;
+    this.label = label;
+  }
+}
+
+const getWorkflowNodeId = (workflowId: string): string =>
+  `workflow_${workflowId}`;
+const getJobId = (jobId: string): string => `job_${jobId}`;
+
+export class WorkflowTreeNodeData extends WorkflowExplorerTreeNodeData {
+  workflow: Workflow;
+  constructor(workflow: Workflow) {
+    super(getWorkflowNodeId(workflow.id), workflow.id);
+    this.workflow = workflow;
+  }
+}
+
+export class WorkflowJobTreeNodeData extends WorkflowExplorerTreeNodeData {
+  workflowJob: WorkflowJob;
+  constructor(workflowJob: WorkflowJob) {
+    super(getJobId(workflowJob.id), workflowJob.name);
+    this.workflowJob = workflowJob;
+  }
+}
+
+const addWorkflowJobNodeToTree = (
+  workflowJob: WorkflowJob,
+  workflowNode: WorkflowTreeNodeData,
+  treeData: TreeData<WorkflowExplorerTreeNodeData>,
+): WorkflowJobTreeNodeData => {
+  const node = new WorkflowJobTreeNodeData(workflowJob);
+  if (workflowNode.childrenIds) {
+    workflowNode.childrenIds.push(node.id);
+  } else {
+    workflowNode.childrenIds = [node.id];
+  }
+
+  treeData.nodes.set(node.id, node);
+  return node;
+};
+
+const updateWorkflowJobData = (
+  workflowJobs: WorkflowJob[],
+  workflowId: string,
+  treeData: TreeData<WorkflowExplorerTreeNodeData>,
+): void => {
+  const workflowNode = treeData.nodes.get(getWorkflowNodeId(workflowId));
+  if (workflowNode instanceof WorkflowTreeNodeData) {
+    workflowNode.childrenIds?.forEach((id) => treeData.nodes.delete(id));
+    workflowNode.childrenIds = [];
+    workflowJobs.forEach((job) =>
+      addWorkflowJobNodeToTree(job, workflowNode, treeData),
+    );
+  }
+};
+
+export class WorkflowLogState {
+  readonly editorStore: EditorStore;
+  readonly workflowManagerState: WorkflowManagerState;
+  readonly fetchJobLogState = ActionState.create();
+
+  job: WorkflowJob | undefined;
+  logs: string;
+
+  constructor(
+    editorStore: EditorStore,
+    workflowManagerState: WorkflowManagerState,
+    job: WorkflowJob | undefined,
+    logs: string | undefined,
+  ) {
+    makeObservable(this, {
+      job: observable,
+      logs: observable,
+      setLogs: action,
+      setJob: action,
+      closeModal: action,
+      refreshJobLogs: flow,
+      viewJobLogs: flow,
+    });
+
+    this.editorStore = editorStore;
+    this.workflowManagerState = workflowManagerState;
+    this.job = job;
+    this.logs = logs ?? '';
+  }
+
+  setLogs(val: string): void {
+    this.logs = val;
+  }
+
+  setJob(val: WorkflowJob | undefined): void {
+    this.job = val;
+  }
+
+  closeModal(): void {
+    this.setJob(undefined);
+    this.setLogs('');
+  }
+
+  *refreshJobLogs(workflowJob: WorkflowJob): GeneratorFn<void> {
+    try {
+      this.fetchJobLogState.inProgress();
+      const job = (yield flowResult(
+        this.workflowManagerState.getJob(workflowJob),
+      )) as WorkflowJob;
+      this.setJob(job);
+      const logs = (yield flowResult(
+        this.workflowManagerState.getJobLogs(workflowJob),
+      )) as string;
+      this.setLogs(logs);
+      this.fetchJobLogState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.fetchJobLogState.fail();
+    }
+  }
+
+  *viewJobLogs(workflowJob: WorkflowJob): GeneratorFn<void> {
+    try {
+      this.setJob(workflowJob);
+      this.fetchJobLogState.inProgress();
+      const logs = (yield flowResult(
+        this.workflowManagerState.getJobLogs(workflowJob),
+      )) as string;
+      this.setLogs(logs);
+      this.fetchJobLogState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.fetchJobLogState.fail();
+    }
+  }
+}
+
+export class WorkflowState {
+  readonly uuid = uuid();
+  readonly editorStore: EditorStore;
+  readonly workflowManagerState: WorkflowManagerState;
+
+  treeData: TreeData<WorkflowExplorerTreeNodeData>;
+  isExecutingWorkflowRequest = false;
+
+  constructor(
+    editorStore: EditorStore,
+    workflowManagerState: WorkflowManagerState,
+    workflow: Workflow,
+    jobs: WorkflowJob[] | undefined,
+  ) {
+    makeObservable(this, {
+      treeData: observable.ref,
+      isExecutingWorkflowRequest: observable,
+      setWorkflowTreeData: action,
+      fetchAllWorkspaceWorkJobs: flow,
+      onTreeNodeSelect: flow,
+      cancelJob: flow,
+      refreshWorkflow: flow,
+      retryJob: flow,
+    });
+
+    this.editorStore = editorStore;
+    this.workflowManagerState = workflowManagerState;
+    this.treeData = this.buildTreeData(workflow, jobs);
+  }
+
+  setWorkflowTreeData(val: TreeData<WorkflowExplorerTreeNodeData>): void {
+    this.treeData = val;
+  }
+
+  buildTreeData(
+    workflow: Workflow,
+    jobs: WorkflowJob[] | undefined,
+  ): TreeData<WorkflowExplorerTreeNodeData> {
+    const rootIds: string[] = [];
+    const nodes = new Map<string, WorkflowExplorerTreeNodeData>();
+    const treeData = { rootIds, nodes };
+    const workflowNode = new WorkflowTreeNodeData(workflow);
+    treeData.rootIds.push(workflowNode.id);
+    treeData.nodes.set(workflowNode.id, workflowNode);
+    if (jobs) {
+      workflowNode.isOpen = true;
+      updateWorkflowJobData(jobs, workflow.id, treeData);
+    }
+    return treeData;
+  }
+
+  *fetchAllWorkspaceWorkJobs(
+    workflowId: string,
+    treeData: TreeData<WorkflowExplorerTreeNodeData>,
+  ): GeneratorFn<void> {
+    try {
+      this.isExecutingWorkflowRequest = true;
+      const workflowJobs = (
+        (yield flowResult(
+          this.workflowManagerState.getJobs(workflowId),
+        )) as WorkflowJob[]
+      ).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      updateWorkflowJobData(workflowJobs, workflowId, treeData);
+      this.setWorkflowTreeData({ ...treeData });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.isExecutingWorkflowRequest = false;
+    }
+  }
+
+  *onTreeNodeSelect(
+    node: WorkflowExplorerTreeNodeData,
+    treeData: TreeData<WorkflowExplorerTreeNodeData>,
+  ): GeneratorFn<void> {
+    if (node instanceof WorkflowTreeNodeData) {
+      if (!node.childrenIds) {
+        yield flowResult(
+          this.fetchAllWorkspaceWorkJobs(node.workflow.id, treeData),
+        );
+      }
+      node.isOpen = !node.isOpen;
+    }
+    this.setWorkflowTreeData({ ...treeData });
+  }
+
+  *cancelJob(
+    workflowJob: WorkflowJob,
+    treeData: TreeData<WorkflowExplorerTreeNodeData>,
+  ): GeneratorFn<void> {
+    try {
+      this.isExecutingWorkflowRequest = true;
+      this.workflowManagerState.cancelJob(workflowJob);
+      yield flowResult(this.refreshWorkflow(workflowJob.workflowId, treeData));
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.isExecutingWorkflowRequest = false;
+    }
+  }
+
+  *refreshWorkflow(
+    workflowId: string,
+    treeData: TreeData<WorkflowExplorerTreeNodeData>,
+  ): GeneratorFn<void> {
+    const node = treeData.nodes.get(getWorkflowNodeId(workflowId));
+    if (node instanceof WorkflowTreeNodeData) {
+      const workflow = (yield flowResult(
+        this.workflowManagerState.getWorkflow(workflowId),
+      )) as Workflow;
+      node.workflow = workflow;
+    }
+    yield flowResult(this.fetchAllWorkspaceWorkJobs(workflowId, treeData));
+  }
+
+  *retryJob(
+    workflowJob: WorkflowJob,
+    treeData: TreeData<WorkflowExplorerTreeNodeData>,
+  ): GeneratorFn<void> {
+    try {
+      this.isExecutingWorkflowRequest = true;
+      yield flowResult(this.workflowManagerState.retryJob(workflowJob));
+      yield flowResult(this.refreshWorkflow(workflowJob.workflowId, treeData));
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.isExecutingWorkflowRequest = false;
+    }
+  }
+}
+
+export abstract class WorkflowManagerState {
+  readonly editorStore: EditorStore;
+  readonly sdlcState: EditorSDLCState;
+  readonly fetchWorkflowsState = ActionState.create();
+
+  logState: WorkflowLogState;
+  workflowStates: WorkflowState[] = [];
+
+  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
+    makeObservable(this, {
+      logState: observable,
+      workflowStates: observable,
+      fetchAllWorkflows: flow,
+      getWorkflows: flow,
+      getWorkflow: flow,
+      getJobs: flow,
+      getJob: flow,
+      retryJob: flow,
+      cancelJob: flow,
+      getJobLogs: flow,
+    });
+
+    this.editorStore = editorStore;
+    this.sdlcState = sdlcState;
+
+    this.logState = new WorkflowLogState(
+      this.editorStore,
+      this,
+      undefined,
+      undefined,
+    );
+  }
+
+  abstract getWorkflows(): GeneratorFn<Workflow[]>;
+  abstract getWorkflow(workflowId: string): GeneratorFn<Workflow>;
+  abstract getJobs(workflowId: string): GeneratorFn<WorkflowJob[]>;
+  abstract getJob(job: WorkflowJob): GeneratorFn<WorkflowJob[]>;
+  abstract retryJob(workflowJob: WorkflowJob): GeneratorFn<void>;
+  abstract cancelJob(workflowJob: WorkflowJob): GeneratorFn<void>;
+  abstract getJobLogs(workflowJob: WorkflowJob): GeneratorFn<string>;
+
+  *fetchAllWorkflows(): GeneratorFn<void> {
+    try {
+      this.fetchWorkflowsState.inProgress();
+      // NOTE: this network call can take a while, so we might consider limiting the number of workflows to 10 or so
+      const workflows = (yield flowResult(this.getWorkflows())) as Workflow[];
+      const openWorkflowIds = this.workflowStates
+        .map((workflowState) =>
+          Array.from(workflowState.treeData.nodes.values()),
+        )
+        .flat()
+        .filter(filterByType(WorkflowTreeNodeData))
+        .filter((node) => node.isOpen)
+        .map((node) => node.workflow.id);
+      const jobsIndex = new Map<string, WorkflowJob[]>();
+      yield Promise.all(
+        workflows
+          .filter((workflow) => openWorkflowIds.includes(workflow.id))
+          // NOTE: this network call can take a while, so we might consider limiting the number of workflows to 10 or so
+          .map((workflow) =>
+            flowResult(this.getJobs(workflow.id)).then((jobs: WorkflowJob[]) =>
+              jobsIndex.set(
+                workflow.id,
+                jobs
+                  .slice()
+                  .sort(
+                    (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+                  ),
+              ),
+            ),
+          ),
+      );
+      this.workflowStates = workflows.map(
+        (workflow) =>
+          new WorkflowState(
+            this.editorStore,
+            this,
+            workflow,
+            jobsIndex.get(workflow.id),
+          ),
+      );
+      this.fetchWorkflowsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.fetchWorkflowsState.fail();
+    }
+  }
+}
+
+export class WorkspaceWorkflowManagerState extends WorkflowManagerState {
+  override *getJobs(workflowId: string): GeneratorFn<WorkflowJob[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowJobs(
+        this.sdlcState.activeProject.projectId,
+        this.sdlcState.activeWorkspace,
+        workflowId,
+        undefined,
+        undefined,
+        undefined,
+      )) as PlainObject<WorkflowJob>[]
+    ).map((v) => WorkflowJob.serialization.fromJson(v));
+  }
+
+  override *getJob(job: WorkflowJob): GeneratorFn<WorkflowJob[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowJob(
+        this.sdlcState.activeProject.projectId,
+        this.sdlcState.activeWorkspace,
+        job,
+      )) as PlainObject<WorkflowJob>[]
+    ).map((v) => WorkflowJob.serialization.fromJson(v));
+  }
+
+  override *getWorkflows(): GeneratorFn<Workflow[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflows(
+        this.sdlcState.activeProject.projectId,
+        this.sdlcState.activeWorkspace,
+        undefined,
+        undefined,
+        undefined,
+      )) as PlainObject<Workflow>[]
+    ).map((v) => Workflow.serialization.fromJson(v));
+  }
+
+  override *getWorkflow(workflowId: string): GeneratorFn<Workflow> {
+    return Workflow.serialization.fromJson(
+      (yield this.editorStore.sdlcServerClient.getWorkflow(
+        this.sdlcState.activeProject.projectId,
+        this.sdlcState.activeWorkspace,
+        workflowId,
+      )) as PlainObject<Workflow>,
+    );
+  }
+
+  override *retryJob(workflowJob: WorkflowJob): GeneratorFn<void> {
+    (yield this.editorStore.sdlcServerClient.retryWorkflowJob(
+      this.sdlcState.activeProject.projectId,
+      this.sdlcState.activeWorkspace,
+      workflowJob,
+    )) as PlainObject<WorkflowJob>[];
+  }
+
+  override *cancelJob(workflowJob: WorkflowJob): GeneratorFn<void> {
+    (yield this.editorStore.sdlcServerClient.cancelWorkflowJob(
+      this.sdlcState.activeProject.projectId,
+      this.sdlcState.activeWorkspace,
+      workflowJob,
+    )) as PlainObject<WorkflowJob>[];
+  }
+
+  override *getJobLogs(workflowJob: WorkflowJob): GeneratorFn<string> {
+    return (yield this.editorStore.sdlcServerClient.getWorkflowJobLogs(
+      this.sdlcState.activeProject.projectId,
+      this.sdlcState.activeWorkspace,
+      workflowJob,
+    )) as string;
+  }
+}
+
+export class ProjectVersionWorkflowManagerState extends WorkflowManagerState {
+  version: Version;
+  constructor(
+    editorStore: EditorStore,
+    sdlcState: EditorSDLCState,
+    version: Version,
+  ) {
+    super(editorStore, sdlcState);
+    this.version = version;
+  }
+
+  override *getJobs(workflowId: string): GeneratorFn<WorkflowJob[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowJobsByVersion(
+        this.sdlcState.activeProject.projectId,
+        this.version.id.id,
+        workflowId,
+        undefined,
+        undefined,
+        undefined,
+      )) as PlainObject<WorkflowJob>[]
+    ).map((v) => WorkflowJob.serialization.fromJson(v));
+  }
+
+  override *getJob(job: WorkflowJob): GeneratorFn<WorkflowJob[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowJobByVersion(
+        this.sdlcState.activeProject.projectId,
+        this.version.id.id,
+        job,
+      )) as PlainObject<WorkflowJob>[]
+    ).map((v) => WorkflowJob.serialization.fromJson(v));
+  }
+
+  override *getWorkflows(): GeneratorFn<Workflow[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowsByVersion(
+        this.sdlcState.activeProject.projectId,
+        this.version.id.id,
+        undefined,
+        undefined,
+        undefined,
+      )) as PlainObject<Workflow>[]
+    ).map((v) => Workflow.serialization.fromJson(v));
+  }
+
+  override *getWorkflow(workflowId: string): GeneratorFn<Workflow> {
+    return Workflow.serialization.fromJson(
+      (yield this.editorStore.sdlcServerClient.getWorkflowByVersion(
+        this.sdlcState.activeProject.projectId,
+        this.version.id.id,
+        workflowId,
+      )) as PlainObject<Workflow>,
+    );
+  }
+
+  override *retryJob(workflowJob: WorkflowJob): GeneratorFn<void> {
+    (yield this.editorStore.sdlcServerClient.retryWorkflowJobByVersion(
+      this.sdlcState.activeProject.projectId,
+      this.version.id.id,
+      workflowJob,
+    )) as PlainObject<WorkflowJob>[];
+  }
+
+  override *cancelJob(workflowJob: WorkflowJob): GeneratorFn<void> {
+    (yield this.editorStore.sdlcServerClient.cancelWorkflowJobByVersion(
+      this.sdlcState.activeProject.projectId,
+      this.version.id.id,
+      workflowJob,
+    )) as PlainObject<WorkflowJob>[];
+  }
+
+  override *getJobLogs(workflowJob: WorkflowJob): GeneratorFn<string> {
+    return (yield this.editorStore.sdlcServerClient.getWorkflowJobLogsByVersion(
+      this.sdlcState.activeProject.projectId,
+      this.version.id.id,
+      workflowJob,
+    )) as string;
+  }
+}
+
+export class ProjectWorkflowManagerState extends WorkflowManagerState {
+  override *getJobs(workflowId: string): GeneratorFn<WorkflowJob[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowJobs(
+        this.sdlcState.activeProject.projectId,
+        undefined,
+        workflowId,
+        undefined,
+        undefined,
+        undefined,
+      )) as PlainObject<WorkflowJob>[]
+    ).map((v) => WorkflowJob.serialization.fromJson(v));
+  }
+
+  override *getJob(job: WorkflowJob): GeneratorFn<WorkflowJob[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflowJob(
+        this.sdlcState.activeProject.projectId,
+        undefined,
+        job,
+      )) as PlainObject<WorkflowJob>[]
+    ).map((v) => WorkflowJob.serialization.fromJson(v));
+  }
+
+  override *getWorkflows(): GeneratorFn<Workflow[]> {
+    return (
+      (yield this.editorStore.sdlcServerClient.getWorkflows(
+        this.sdlcState.activeProject.projectId,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+      )) as PlainObject<Workflow>[]
+    ).map((v) => Workflow.serialization.fromJson(v));
+  }
+
+  override *getWorkflow(workflowId: string): GeneratorFn<Workflow> {
+    return Workflow.serialization.fromJson(
+      (yield this.editorStore.sdlcServerClient.getWorkflow(
+        this.sdlcState.activeProject.projectId,
+        undefined,
+        workflowId,
+      )) as PlainObject<Workflow>,
+    );
+  }
+
+  override *retryJob(workflowJob: WorkflowJob): GeneratorFn<void> {
+    (yield this.editorStore.sdlcServerClient.retryWorkflowJob(
+      this.sdlcState.activeProject.projectId,
+      undefined,
+      workflowJob,
+    )) as PlainObject<WorkflowJob>[];
+  }
+
+  override *cancelJob(workflowJob: WorkflowJob): GeneratorFn<void> {
+    (yield this.editorStore.sdlcServerClient.cancelWorkflowJob(
+      this.sdlcState.activeProject.projectId,
+      undefined,
+      workflowJob,
+    )) as PlainObject<WorkflowJob>[];
+  }
+
+  override *getJobLogs(workflowJob: WorkflowJob): GeneratorFn<string> {
+    return (yield this.editorStore.sdlcServerClient.getWorkflowJobLogs(
+      this.sdlcState.activeProject.projectId,
+      undefined,
+      workflowJob,
+    )) as string;
+  }
+}