@rytass/bpm-core-nestjs-module 0.1.2 → 0.1.3

package/src/lib/workflow-engine/workflow-engine.enums.ts

@@ -0,0 +1,99 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+export enum ApprovalInstanceStateEnum {
+  APPROVED = 'APPROVED',
+  CANCELLED = 'CANCELLED',
+  DRAFT = 'DRAFT',
+  EXPIRED = 'EXPIRED',
+  REJECTED = 'REJECTED',
+  RETURNED = 'RETURNED',
+  RUNNING = 'RUNNING',
+}
+
+export enum ApprovalInstanceListViewEnum {
+  ALL = 'ALL',
+  CC = 'CC',
+  SENT = 'SENT',
+}
+
+export enum WorkflowTokenStatusEnum {
+  ACTIVE = 'ACTIVE',
+  CONSUMED = 'CONSUMED',
+  WAITING = 'WAITING',
+}
+
+export enum TaskStatusEnum {
+  CANCELLED = 'CANCELLED',
+  COMPLETED = 'COMPLETED',
+  IN_PROGRESS = 'IN_PROGRESS',
+  PENDING = 'PENDING',
+  TRANSFERRED = 'TRANSFERRED',
+}
+
+export enum TaskAssignmentTypeEnum {
+  CANDIDATE_GROUP = 'CANDIDATE_GROUP',
+  DIRECT_MEMBER = 'DIRECT_MEMBER',
+}
+
+export enum TaskCandidateStatusEnum {
+  CANCELLED = 'CANCELLED',
+  CLAIMED = 'CLAIMED',
+  COMPLETED = 'COMPLETED',
+  PENDING = 'PENDING',
+  SUPERSEDED = 'SUPERSEDED',
+  TRANSFERRED = 'TRANSFERRED',
+}
+
+export enum TaskDecisionActionEnum {
+  APPROVED = 'APPROVED',
+  REJECTED = 'REJECTED',
+  RETURNED = 'RETURNED',
+  TRANSFERRED = 'TRANSFERRED',
+}
+
+export enum ActivityLogEventTypeEnum {
+  ENGINE_PROCESS_REQUESTED = 'ENGINE_PROCESS_REQUESTED',
+  INSTANCE_CANCELLED = 'INSTANCE_CANCELLED',
+  INSTANCE_RESUBMITTED = 'INSTANCE_RESUBMITTED',
+  INSTANCE_STARTED = 'INSTANCE_STARTED',
+  INSTANCE_RETURNED = 'INSTANCE_RETURNED',
+  SERVICE_TASK_EXECUTED = 'SERVICE_TASK_EXECUTED',
+  SERVICE_TASK_FAILED = 'SERVICE_TASK_FAILED',
+  SLA_TRIGGERED = 'SLA_TRIGGERED',
+  TASK_CREATED = 'TASK_CREATED',
+  TASK_DECIDED = 'TASK_DECIDED',
+  TOKEN_ADVANCED = 'TOKEN_ADVANCED',
+  TOKEN_CREATED = 'TOKEN_CREATED',
+}
+
+registerEnumType(ApprovalInstanceStateEnum, {
+  name: 'ApprovalInstanceState',
+});
+
+registerEnumType(ApprovalInstanceListViewEnum, {
+  name: 'ApprovalInstanceListView',
+});
+
+registerEnumType(WorkflowTokenStatusEnum, {
+  name: 'WorkflowTokenStatus',
+});
+
+registerEnumType(TaskStatusEnum, {
+  name: 'TaskStatus',
+});
+
+registerEnumType(TaskAssignmentTypeEnum, {
+  name: 'TaskAssignmentType',
+});
+
+registerEnumType(TaskCandidateStatusEnum, {
+  name: 'TaskCandidateStatus',
+});
+
+registerEnumType(TaskDecisionActionEnum, {
+  name: 'TaskDecisionAction',
+});
+
+registerEnumType(ActivityLogEventTypeEnum, {
+  name: 'ActivityLogEventType',
+});

package/src/lib/workflow-engine/workflow-engine.module.ts

@@ -0,0 +1,75 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ConditionModule } from '../condition/condition.module';
+import { DelegationModule } from '../delegation/delegation.module';
+import { FormDefinitionVersionEntity } from '../form/form-definition-version.entity';
+import { ManagerResolutionEntity } from '../organization/manager-resolution.entity';
+import { NotificationEntity } from '../notification/notification.entity';
+import { NotificationModule } from '../notification/notification.module';
+import { OrgUnitEntity } from '../organization/org-unit.entity';
+import { SignatureModule } from '../signature/signature.module';
+import { MembershipEntity } from '../organization/membership.entity';
+import { ApprovalTemplateVersionEntity } from '../template/approval-template-version.entity';
+import { ApprovalTemplateEntity } from '../template/approval-template.entity';
+import { ActivityLogEntity } from './activity-log.entity';
+import { ApprovalInstanceEntity } from './approval-instance.entity';
+import { TaskDecisionEntity } from './task-decision.entity';
+import { TaskCandidateEntity } from './task-candidate.entity';
+import { TaskEntity } from './task.entity';
+import { WorkflowEngineMutations } from './workflow-engine.mutations';
+import { WorkflowEngineQueries } from './workflow-engine.queries';
+import { WorkflowEngineService } from './workflow-engine.service';
+import { BPM_WORKFLOW_ENGINE_SERVICE } from './workflow-engine.tokens';
+import { BPMWorkflowServiceTaskDispatcher } from './workflow-service-task-dispatcher.token';
+import { WorkflowTokenEntity } from './workflow-token.entity';
+
+export interface WorkflowEngineModuleOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  readonly serviceTaskDispatcherProvider?: Provider<BPMWorkflowServiceTaskDispatcher>;
+}
+
+@Module({
+  imports: [
+    ConditionModule,
+    DelegationModule,
+    NotificationModule,
+    SignatureModule,
+    TypeOrmModule.forFeature([
+      ActivityLogEntity,
+      ApprovalInstanceEntity,
+      ApprovalTemplateEntity,
+      ApprovalTemplateVersionEntity,
+      FormDefinitionVersionEntity,
+      ManagerResolutionEntity,
+      MembershipEntity,
+      NotificationEntity,
+      OrgUnitEntity,
+      TaskCandidateEntity,
+      TaskDecisionEntity,
+      TaskEntity,
+      WorkflowTokenEntity,
+    ]),
+  ],
+  providers: [
+    WorkflowEngineMutations,
+    WorkflowEngineQueries,
+    WorkflowEngineService,
+    {
+      provide: BPM_WORKFLOW_ENGINE_SERVICE,
+      useExisting: WorkflowEngineService,
+    },
+  ],
+  exports: [BPM_WORKFLOW_ENGINE_SERVICE, WorkflowEngineService],
+})
+export class WorkflowEngineModule {
+  static forRoot(options: WorkflowEngineModuleOptions = {}): DynamicModule {
+    return {
+      imports: options.imports ? [...options.imports] : [],
+      module: WorkflowEngineModule,
+      providers: options.serviceTaskDispatcherProvider
+        ? [options.serviceTaskDispatcherProvider]
+        : [],
+    };
+  }
+}

package/src/lib/workflow-engine/workflow-engine.mutations.ts

@@ -0,0 +1,85 @@
+import { Args, Mutation, Resolver } from '@nestjs/graphql';
+import {
+  BPMAdminOnly,
+  BPMAuthenticated,
+  BPMCurrentMemberId,
+} from '../bpm-auth';
+import { ApprovalInstanceEntity } from './approval-instance.entity';
+import { CancelApprovalInstanceInput } from './dto/cancel-approval-instance.input';
+import { DecideTaskInput } from './dto/decide-task.input';
+import { DryRunApprovalWorkflowInput } from './dto/dry-run-approval-workflow.input';
+import { ResubmitApprovalInstanceInput } from './dto/resubmit-approval-instance.input';
+import { SubmitApprovalInstanceInput } from './dto/submit-approval-instance.input';
+import { TaskDecisionEntity } from './task-decision.entity';
+import { WorkflowDryRunResultObject } from './workflow-dry-run.object';
+import { WorkflowEngineService } from './workflow-engine.service';
+
+@Resolver()
+@BPMAuthenticated()
+export class WorkflowEngineMutations {
+  constructor(private readonly workflowEngineService: WorkflowEngineService) {}
+
+  @Mutation(() => ApprovalInstanceEntity)
+  async submitApprovalInstance(
+    @Args('input') input: SubmitApprovalInstanceInput,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<ApprovalInstanceEntity> {
+    return this.workflowEngineService.submitApprovalInstance({
+      ...input,
+      initiatorMemberId: currentMemberId,
+      initiatorMetadataSnapshotJson: null,
+    });
+  }
+
+  @Mutation(() => Boolean)
+  @BPMAdminOnly()
+  async processApprovalInstance(
+    @Args('instanceId', { type: () => String }) instanceId: string,
+  ): Promise<boolean> {
+    await this.workflowEngineService.processInstance(instanceId);
+
+    return true;
+  }
+
+  @Mutation(() => TaskDecisionEntity)
+  async decideTask(
+    @Args('input') input: DecideTaskInput,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<TaskDecisionEntity> {
+    return this.workflowEngineService.decideTask({
+      ...input,
+      decidedByMemberId: currentMemberId,
+    });
+  }
+
+  @Mutation(() => ApprovalInstanceEntity)
+  async cancelApprovalInstance(
+    @Args('input') input: CancelApprovalInstanceInput,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<ApprovalInstanceEntity> {
+    return this.workflowEngineService.cancelApprovalInstance({
+      ...input,
+      cancelledByMemberId: currentMemberId,
+    });
+  }
+
+  @Mutation(() => ApprovalInstanceEntity)
+  async resubmitApprovalInstance(
+    @Args('input') input: ResubmitApprovalInstanceInput,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<ApprovalInstanceEntity> {
+    return this.workflowEngineService.resubmitApprovalInstance({
+      ...input,
+      initiatorMemberId: currentMemberId,
+    });
+  }
+
+  @Mutation(() => WorkflowDryRunResultObject)
+  async dryRunApprovalWorkflow(
+    @Args('input') input: DryRunApprovalWorkflowInput,
+  ): Promise<WorkflowDryRunResultObject> {
+    return Promise.resolve(
+      this.workflowEngineService.dryRunApprovalWorkflow(input),
+    );
+  }
+}

package/src/lib/workflow-engine/workflow-engine.queries.ts

@@ -0,0 +1,229 @@
+import { Args, Int, Query, Resolver } from '@nestjs/graphql';
+import {
+  BPMAuthenticated,
+  BPMCurrentAuthContext,
+  BPMCurrentMemberId,
+  BPMAuthContext,
+} from '../bpm-auth';
+import { ActivityLogEntity } from './activity-log.entity';
+import { ApprovalInstanceEntity } from './approval-instance.entity';
+import { ApprovalInstancePageInfoObject } from './approval-instance-page-info.object';
+import { ApprovalTemplateEntity } from '../template/approval-template.entity';
+import { TaskCandidateEntity } from './task-candidate.entity';
+import { TaskDecisionEntity } from './task-decision.entity';
+import { TaskEntity } from './task.entity';
+import { WorkflowDashboardSummaryObject } from './workflow-dashboard-summary.object';
+import {
+  ApprovalInstanceListViewEnum,
+  ApprovalInstanceStateEnum,
+} from './workflow-engine.enums';
+import { WorkflowEngineService } from './workflow-engine.service';
+import { WorkflowTokenEntity } from './workflow-token.entity';
+
+@Resolver()
+@BPMAuthenticated()
+export class WorkflowEngineQueries {
+  constructor(private readonly workflowEngineService: WorkflowEngineService) {}
+
+  @Query(() => [ApprovalInstanceEntity])
+  async approvalInstances(
+    @Args('view', {
+      nullable: true,
+      type: () => ApprovalInstanceListViewEnum,
+    })
+    view: ApprovalInstanceListViewEnum | null,
+    @Args('searchText', { nullable: true, type: () => String })
+    searchText: string | null,
+    @Args('state', {
+      nullable: true,
+      type: () => [ApprovalInstanceStateEnum],
+    })
+    state: readonly ApprovalInstanceStateEnum[] | null,
+    @Args('templateId', { nullable: true, type: () => String })
+    templateId: string | null,
+    @Args('page', { nullable: true, type: () => Int })
+    page: number | null,
+    @Args('pageSize', { nullable: true, type: () => Int })
+    pageSize: number | null,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<readonly ApprovalInstanceEntity[]> {
+    return this.workflowEngineService.listApprovalInstances(
+      currentAuthContext,
+      {
+        page: page ?? undefined,
+        pageSize: pageSize ?? undefined,
+        searchText: searchText ?? undefined,
+        state: state ?? undefined,
+        templateId: templateId ?? undefined,
+        view: view ?? undefined,
+      },
+    );
+  }
+
+  @Query(() => Int)
+  async approvalInstanceCount(
+    @Args('view', {
+      nullable: true,
+      type: () => ApprovalInstanceListViewEnum,
+    })
+    view: ApprovalInstanceListViewEnum | null,
+    @Args('searchText', { nullable: true, type: () => String })
+    searchText: string | null,
+    @Args('state', {
+      nullable: true,
+      type: () => [ApprovalInstanceStateEnum],
+    })
+    state: readonly ApprovalInstanceStateEnum[] | null,
+    @Args('templateId', { nullable: true, type: () => String })
+    templateId: string | null,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<number> {
+    return this.workflowEngineService.countApprovalInstances(
+      currentAuthContext,
+      {
+        searchText: searchText ?? undefined,
+        state: state ?? undefined,
+        templateId: templateId ?? undefined,
+        view: view ?? undefined,
+      },
+    );
+  }
+
+  @Query(() => ApprovalInstancePageInfoObject)
+  async approvalInstancePageInfo(
+    @Args('view', {
+      nullable: true,
+      type: () => ApprovalInstanceListViewEnum,
+    })
+    view: ApprovalInstanceListViewEnum | null,
+    @Args('searchText', { nullable: true, type: () => String })
+    searchText: string | null,
+    @Args('state', {
+      nullable: true,
+      type: () => [ApprovalInstanceStateEnum],
+    })
+    state: readonly ApprovalInstanceStateEnum[] | null,
+    @Args('templateId', { nullable: true, type: () => String })
+    templateId: string | null,
+    @Args('page', { nullable: true, type: () => Int })
+    page: number | null,
+    @Args('pageSize', { nullable: true, type: () => Int })
+    pageSize: number | null,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<ApprovalInstancePageInfoObject> {
+    return this.workflowEngineService.readApprovalInstancePageInfo(
+      currentAuthContext,
+      {
+        page: page ?? undefined,
+        pageSize: pageSize ?? undefined,
+        searchText: searchText ?? undefined,
+        state: state ?? undefined,
+        templateId: templateId ?? undefined,
+        view: view ?? undefined,
+      },
+    );
+  }
+
+  @Query(() => WorkflowDashboardSummaryObject)
+  async workflowDashboardSummary(
+    @Args('from', { nullable: true, type: () => Date }) from: Date | null,
+    @Args('to', { nullable: true, type: () => Date }) to: Date | null,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<WorkflowDashboardSummaryObject> {
+    return this.workflowEngineService.readWorkflowDashboardSummary(
+      currentAuthContext,
+      {
+        from: from ?? undefined,
+        to: to ?? undefined,
+      },
+    );
+  }
+
+  @Query(() => ApprovalInstanceEntity)
+  async approvalInstance(
+    @Args('id', { type: () => String }) id: string,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<ApprovalInstanceEntity> {
+    return this.workflowEngineService.getApprovalInstance(
+      id,
+      currentAuthContext,
+    );
+  }
+
+  @Query(() => [WorkflowTokenEntity])
+  async workflowTokens(
+    @Args('instanceId', { type: () => String }) instanceId: string,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<readonly WorkflowTokenEntity[]> {
+    return this.workflowEngineService.listWorkflowTokens(
+      instanceId,
+      currentAuthContext,
+    );
+  }
+
+  @Query(() => [TaskEntity])
+  async tasks(
+    @Args('instanceId', { type: () => String }) instanceId: string,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<readonly TaskEntity[]> {
+    return this.workflowEngineService.listTasks(instanceId, currentAuthContext);
+  }
+
+  @Query(() => [TaskEntity])
+  async inboxTasks(
+    @Args('assigneeMemberId', { type: () => String }) assigneeMemberId: string,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<readonly TaskEntity[]> {
+    return this.workflowEngineService.listInboxTasks(currentMemberId);
+  }
+
+  @Query(() => [TaskEntity])
+  async approvalHistoryTasks(
+    @Args('assigneeMemberId', { type: () => String }) assigneeMemberId: string,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<readonly TaskEntity[]> {
+    return this.workflowEngineService.listApprovalHistoryTasks(currentMemberId);
+  }
+
+  @Query(() => [ApprovalTemplateEntity])
+  async launchableApprovalTemplates(
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<readonly ApprovalTemplateEntity[]> {
+    return this.workflowEngineService.listLaunchableApprovalTemplates(
+      currentMemberId,
+    );
+  }
+
+  @Query(() => [TaskDecisionEntity])
+  async taskDecisions(
+    @Args('taskId', { type: () => String }) taskId: string,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<readonly TaskDecisionEntity[]> {
+    return this.workflowEngineService.listTaskDecisions(
+      taskId,
+      currentAuthContext,
+    );
+  }
+
+  @Query(() => [TaskCandidateEntity])
+  async taskCandidates(
+    @Args('taskId', { type: () => String }) taskId: string,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<readonly TaskCandidateEntity[]> {
+    return this.workflowEngineService.listTaskCandidates(
+      taskId,
+      currentAuthContext,
+    );
+  }
+
+  @Query(() => [ActivityLogEntity])
+  async activityLogs(
+    @Args('instanceId', { type: () => String }) instanceId: string,
+    @BPMCurrentAuthContext() currentAuthContext: BPMAuthContext,
+  ): Promise<readonly ActivityLogEntity[]> {
+    return this.workflowEngineService.listActivityLogs(
+      instanceId,
+      currentAuthContext,
+    );
+  }
+}