Reworking engagement service to engagement workflow

Author: Andre Turner

src/components/engagement/engagement-status.resolver.ts

@@ -1,12 +1,18 @@
 import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
 import { stripIndent } from 'common-tags';
 import { AnonSession, ParentIdMiddlewareAdditions, Session } from '~/common';
+import { ResourceLoader } from '~/core';
 import { EngagementStatusTransition, SecuredEngagementStatus } from './dto';
-import { EngagementRules } from './engagement.rules';
+//import { EngagementRules } from './engagement.rules';
+import { EngagementWorkflowService } from './workflow/engagement-workflow.service';
 
 @Resolver(SecuredEngagementStatus)
 export class EngagementStatusResolver {
-  constructor(private readonly engagementRules: EngagementRules) {}
+  constructor(
+    private readonly resources: ResourceLoader,
+    //private readonly engagementRules: EngagementRules,
+    private readonly engagementWorkflowService: EngagementWorkflowService,
+  ) {}
 
   @ResolveField(() => [EngagementStatusTransition], {
     description: 'The available statuses a engagement can be transitioned to.',
@@ -19,11 +25,16 @@ export class EngagementStatusResolver {
     if (!status.canRead || !status.canEdit || !status.value) {
       return [];
     }
-    return await this.engagementRules.getAvailableTransitions(
-      status.parentId,
+    const { EngagementLoader } = await import('./engagement.loader');
+    const engagements = await this.resources.getLoader(EngagementLoader);
+    const loaderKey = {
+      id: status.parentId,
+      view: { active: true },
+    } as const;
+    const previous = await engagements.load(loaderKey);
+    return await this.engagementWorkflowService.getAvailableTransitions(
+      previous,
       session,
-      undefined,
-      status.changeset,
     );
   }
 
@@ -36,6 +47,6 @@ export class EngagementStatusResolver {
   async canBypassTransitions(
     @AnonSession() session: Session,
   ): Promise<boolean> {
-    return await this.engagementRules.canBypassWorkflow(session);
+    return await this.engagementWorkflowService.canBypassWorkflow(session);
   }
 }

src/components/engagement/engagement.service.ts

@@ -46,12 +46,13 @@ import {
   EngagementRepository,
   LanguageOrEngagementId,
 } from './engagement.repository';
-import { EngagementRules } from './engagement.rules';
+//import { EngagementRules } from './engagement.rules';
 import {
   EngagementCreatedEvent,
   EngagementUpdatedEvent,
   EngagementWillDeleteEvent,
 } from './events';
+import { EngagementWorkflowService } from './workflow/engagement-workflow.service';
 
 @Injectable()
 export class EngagementService {
@@ -62,7 +63,8 @@ export class EngagementService {
     private readonly products: ProductService & {},
     private readonly config: ConfigService,
     private readonly files: FileService,
-    private readonly engagementRules: EngagementRules,
+    //private readonly engagementRules: EngagementRules,
+    private readonly engagementWorkflow: EngagementWorkflowService,
     private readonly privileges: Privileges,
     @Inject(forwardRef(() => ProjectService))
     private readonly projectService: ProjectService & {},
@@ -263,14 +265,13 @@ export class EngagementService {
       await this.verifyFirstScripture({ engagementId: input.id });
     }
 
-    if (input.status) {
-      await this.engagementRules.verifyStatusChange(
-        input.id,
-        session,
-        input.status,
-        changeset,
-      );
-    }
+    // if (input.status) {
+    //   await this.engagementWorkflow.verifyStatusChange(
+    //     input.id,
+    //     session,
+    //     input.status,
+    //   );
+    // }
 
     const previous = await this.repo.readOne(input.id, session, view);
     const object = (await this.secure(previous, session)) as LanguageEngagement;
@@ -288,9 +289,17 @@ export class EngagementService {
       session,
     );
 
+    let updated = previous;
+    if (changes.status) {
+      await this.engagementWorkflow.executeTransitionLegacy(
+        object,
+        changes.status,
+        session,
+      );
+    }
     await this.repo.updateLanguage(object, changes, changeset);
 
-    const updated = (await this.repo.readOne(
+    updated = (await this.repo.readOne(
       input.id,
       session,
       view,
@@ -308,14 +317,14 @@ export class EngagementService {
     changeset?: ID,
   ): Promise<InternshipEngagement> {
     const view: ObjectView = viewOfChangeset(changeset);
-    if (input.status) {
-      await this.engagementRules.verifyStatusChange(
-        input.id,
-        session,
-        input.status,
-        changeset,
-      );
-    }
+    // if (input.status) {
+    //   await this.engagementWorkflow.verifyStatusChange(
+    //     input.id,
+    //     session,
+    //     input.status,
+    //     changeset,
+    //   );
+    // }
 
     const previous = await this.repo.readOne(input.id, session, view);
     const object = (await this.secure(
@@ -328,6 +337,15 @@ export class EngagementService {
       .for(session, InternshipEngagement, object)
       .verifyChanges(changes, { pathPrefix: 'engagement' });
 
+    let updated = previous;
+    if (changes.status) {
+      await this.engagementWorkflow.executeTransitionLegacy(
+        object,
+        changes.status,
+        session,
+      );
+    }
+
     await this.files.updateDefinedFile(
       object.growthPlan,
       'engagement.growthPlan',
@@ -337,7 +355,7 @@ export class EngagementService {
 
     await this.repo.updateInternship(object, changes, changeset);
 
-    const updated = (await this.repo.readOne(
+    updated = (await this.repo.readOne(
       input.id,
       session,
       view,

src/components/engagement/workflow/engagement-workflow.service.ts

@@ -0,0 +1,136 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { Session, UnsecuredDto } from '~/common';
+import { IEventBus, ResourceLoader } from '~/core';
+import {
+  findTransition,
+  WorkflowService,
+} from '../../workflow/workflow.service';
+import { Engagement, EngagementStatus } from '../dto';
+import {
+  ExecuteEngagementTransitionInput,
+  EngagementWorkflowEvent as WorkflowEvent,
+} from './dto';
+import { EngagementWorkflow } from './engagement-workflow';
+import { EngagementWorkflowRepository } from './engagement-workflow.repository';
+//import { EngagementTransitionedEvent } from './events/engagement-transitioned.event';
+
+@Injectable()
+export class EngagementWorkflowService extends WorkflowService(
+  () => EngagementWorkflow,
+) {
+  constructor(
+    private readonly resources: ResourceLoader,
+    private readonly repo: EngagementWorkflowRepository,
+    private readonly eventBus: IEventBus,
+    private readonly moduleRef: ModuleRef,
+  ) {
+    super();
+  }
+
+  // async list(report: Project, session: Session): Promise<WorkflowEvent[]> {
+  //   const dtos = await this.repo.list(report.id, session);
+  //   return dtos.map((dto) => this.secure(dto, session));
+  // }
+
+  // async readMany(ids: readonly ID[], session: Session) {
+  //   const dtos = await this.repo.readMany(ids, session);
+  //   return dtos.map((dto) => this.secure(dto, session));
+  // }
+
+  private secure(
+    dto: UnsecuredDto<WorkflowEvent>,
+    session: Session,
+  ): WorkflowEvent {
+    return {
+      ...this.privileges.for(session, WorkflowEvent).secure(dto),
+      transition: this.transitionByKey(dto.transition, dto.to),
+    };
+  }
+
+  async getAvailableTransitions(engagement: Engagement, session: Session) {
+    return await this.resolveAvailable(
+      engagement.status.value!,
+      { engagement, moduleRef: this.moduleRef },
+      { ...engagement, engagement },
+      session,
+    );
+  }
+
+  async canBypassWorkflow(session: Session) {
+    return this.canBypass(session);
+  }
+
+  canBypass(session: Session) {
+    return this.privileges.for(session, WorkflowEvent).can('create');
+  }
+
+  async executeTransition(
+    input: ExecuteEngagementTransitionInput,
+    session: Session,
+  ) {
+    const { engagement: engagementId, notes } = input;
+
+    const { EngagementLoader } = await import('../engagement.loader');
+    const engagements = await this.resources.getLoader(EngagementLoader);
+    const loaderKey = {
+      id: engagementId,
+      view: { active: true },
+    } as const;
+    const previous = await engagements.load(loaderKey);
+
+    const next =
+      this.getBypassIfValid(input, session) ??
+      findTransition(
+        await this.getAvailableTransitions(previous, session),
+        input.transition,
+      );
+
+    const unsecuredEvent = await this.repo.recordEvent(
+      {
+        engagement: engagementId,
+        ...(typeof next !== 'string'
+          ? { transition: next.key, to: next.to }
+          : { to: next }),
+        notes,
+      },
+      session,
+    );
+
+    engagements.clear(loaderKey);
+    const updated = await engagements.load(loaderKey);
+
+    // const event = new EngagementTransitionedEvent(
+    //   updated,
+    //   previous.status.value!,
+    //   next,
+    //   unsecuredEvent,
+    // );
+    // await this.eventBus.publish(event);
+
+    return updated;
+  }
+
+  /** @deprecated */
+  async executeTransitionLegacy(
+    currentEngagement: Engagement,
+    step: EngagementStatus,
+    session: Session,
+  ) {
+    const transitions = await this.getAvailableTransitions(
+      currentEngagement,
+      session,
+    );
+    // Pick the first matching to step.
+    // Lack of detail is one of the reasons why this is legacy logic.
+    const transition = transitions.find((t) => t.to === step);
+
+    await this.executeTransition(
+      {
+        engagement: currentEngagement.id,
+        ...(transition ? { transition: transition.key } : { bypassTo: step }),
+      },
+      session,
+    );
+  }
+}

src/components/engagement/workflow/resolvers/engagement-execute-transition.resolver.ts

@@ -0,0 +1,18 @@
+import { Args, Mutation, Resolver } from '@nestjs/graphql';
+import { LoggedInSession, Session } from '~/common';
+import { Engagement, IEngagement } from '../../dto';
+import { ExecuteEngagementTransitionInput } from '../dto';
+import { EngagementWorkflowService } from '../engagement-workflow.service';
+
+@Resolver()
+export class EngagementExecuteTransitionResolver {
+  constructor(private readonly workflow: EngagementWorkflowService) {}
+
+  @Mutation(() => IEngagement)
+  async transitionEngagement(
+    @Args({ name: 'input' }) input: ExecuteEngagementTransitionInput,
+    @LoggedInSession() session: Session,
+  ): Promise<Engagement> {
+    return await this.workflow.executeTransition(input, session);
+  }
+}

src/components/engagement/workflow/resolvers/engagement-workflow-event.resolver.ts

@@ -0,0 +1,17 @@
+import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { mapSecuredValue } from '~/common';
+import { Loader, LoaderOf } from '~/core';
+import { ActorLoader } from '../../../user/actor.loader';
+import { SecuredActor } from '../../../user/dto';
+import { EngagementWorkflowEvent as WorkflowEvent } from '../dto';
+
+@Resolver(WorkflowEvent)
+export class EngagementWorkflowEventResolver {
+  @ResolveField(() => SecuredActor)
+  async who(
+    @Parent() event: WorkflowEvent,
+    @Loader(ActorLoader) actors: LoaderOf<ActorLoader>,
+  ): Promise<SecuredActor> {
+    return await mapSecuredValue(event.who, ({ id }) => actors.load(id));
+  }
+}

src/components/engagement/workflow/transitions/conditions.ts

@@ -0,0 +1,15 @@
+import { TransitionCondition } from '../../../workflow/transitions/conditions';
+import { ResolveEngagementParams } from './dynamic-step';
+
+type Condition = TransitionCondition<ResolveEngagementParams>;
+
+//delete this condition; created just to test engagement conditions
+export const IsInternship: Condition = {
+  description: 'Internship',
+  resolve({ engagement }) {
+    return {
+      status:
+        engagement.__typename !== 'InternshipEngagement' ? 'ENABLED' : 'OMIT',
+    };
+  },
+};

src/components/engagement/workflow/transitions/dynamic-step.ts

@@ -0,0 +1,31 @@
+import { ModuleRef } from '@nestjs/core';
+import { DynamicState } from '../../../workflow/transitions/dynamic-state';
+import {
+  Engagement,
+  EngagementStatus,
+  EngagementStatus as Step,
+} from '../../dto';
+import { EngagementWorkflowRepository } from '../engagement-workflow.repository';
+
+export interface ResolveEngagementParams {
+  engagement: Engagement;
+  moduleRef: ModuleRef;
+  migrationPrevStep?: EngagementStatus;
+}
+
+export const BackTo = (
+  ...steps: EngagementStatus[]
+): DynamicState<Step, ResolveEngagementParams> => ({
+  description: 'Back',
+  relatedStates: steps,
+  async resolve({ engagement, moduleRef, migrationPrevStep }) {
+    if (migrationPrevStep) {
+      return migrationPrevStep;
+    }
+    const repo = moduleRef.get(EngagementWorkflowRepository);
+    const found = await repo.mostRecentStep(engagement.id, steps);
+    return found ?? steps[0] ?? EngagementStatus.InDevelopment;
+  },
+});
+
+export const BackToActive = BackTo(Step.Active, Step.ActiveChangedPlan);