Engagement resolvers and workflow event loader

Author: Andre Turner

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

@@ -1,16 +1,15 @@
 import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
 import { stripIndent } from 'common-tags';
 import { AnonSession, ParentIdMiddlewareAdditions, Session } from '~/common';
-import { ResourceLoader } from '~/core';
+import { Loader, LoaderOf, ResourceLoader } from '~/core';
 import { EngagementStatusTransition, SecuredEngagementStatus } from './dto';
-//import { EngagementRules } from './engagement.rules';
+import { EngagementLoader } from './engagement.loader';
 import { EngagementWorkflowService } from './workflow/engagement-workflow.service';
 
 @Resolver(SecuredEngagementStatus)
 export class EngagementStatusResolver {
   constructor(
     private readonly resources: ResourceLoader,
-    //private readonly engagementRules: EngagementRules,
     private readonly engagementWorkflowService: EngagementWorkflowService,
   ) {}
 
@@ -20,20 +19,19 @@ export class EngagementStatusResolver {
   async transitions(
     @Parent()
     status: SecuredEngagementStatus & ParentIdMiddlewareAdditions,
+    @Loader(EngagementLoader) engagements: LoaderOf<EngagementLoader>,
     @AnonSession() session: Session,
   ): Promise<EngagementStatusTransition[]> {
     if (!status.canRead || !status.canEdit || !status.value) {
       return [];
     }
-    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);
+    const engagement = await engagements.load(loaderKey);
     return await this.engagementWorkflowService.getAvailableTransitions(
-      previous,
+      engagement,
       session,
     );
   }

src/components/engagement/workflow/engagement-workflow-event.loader.ts

@@ -0,0 +1,15 @@
+import { ID } from '~/common';
+import { LoaderFactory, SessionAwareLoaderStrategy } from '~/core';
+import { EngagementWorkflowEvent as WorkflowEvent } from './dto';
+import { EngagementWorkflowService } from './engagement-workflow.service';
+
+@LoaderFactory(() => WorkflowEvent)
+export class EngagementWorkflowEventLoader extends SessionAwareLoaderStrategy<WorkflowEvent> {
+  constructor(private readonly service: EngagementWorkflowService) {
+    super();
+  }
+
+  async loadMany(ids: readonly ID[]) {
+    return await this.service.readMany(ids, this.session);
+  }
+}

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

@@ -0,0 +1,55 @@
+import { Parent, Query, ResolveField, Resolver } from '@nestjs/graphql';
+import { Loader, LoaderOf } from '@seedcompany/data-loader';
+import { stripIndent } from 'common-tags';
+import {
+  AnonSession,
+  ParentIdMiddlewareAdditions,
+  Session,
+  viewOfChangeset,
+} from '~/common';
+import { SerializedWorkflow } from '../../../workflow/dto';
+import { SecuredEngagementStatus } from '../../dto';
+import { EngagementLoader } from '../../engagement.loader';
+import { EngagementWorkflowTransition } from '../dto';
+import { EngagementWorkflowService } from '../engagement-workflow.service';
+
+@Resolver(SecuredEngagementStatus)
+export class EngagementTransitionsResolver {
+  constructor(private readonly workflow: EngagementWorkflowService) {}
+
+  @Query(() => SerializedWorkflow)
+  async engagementWorkflow() {
+    return this.workflow.serialize();
+  }
+
+  @ResolveField(() => [EngagementWorkflowTransition], {
+    description:
+      'The transitions currently available to execute for this engagement',
+  })
+  async transitions(
+    @Parent() status: SecuredEngagementStatus & ParentIdMiddlewareAdditions,
+    @Loader(EngagementLoader) engagements: LoaderOf<EngagementLoader>,
+    @AnonSession() session: Session,
+  ): Promise<readonly EngagementWorkflowTransition[]> {
+    if (!status.canRead || !status.value) {
+      return [];
+    }
+    const engagement = await engagements.load({
+      id: status.parentId,
+      view: viewOfChangeset(status.changeset),
+    });
+    return await this.workflow.getAvailableTransitions(engagement, session);
+  }
+
+  @ResolveField(() => Boolean, {
+    description: stripIndent`
+      Is the current user allowed to bypass transitions entirely
+      and change to any other state?
+   `,
+  })
+  async canBypassTransitions(
+    @AnonSession() session: Session,
+  ): Promise<boolean> {
+    return this.workflow.canBypass(session);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { AnonSession, Session } from '~/common';
+import { Engagement, IEngagement } from '../../dto';
+import { EngagementWorkflowEvent as WorkflowEvent } from '../dto';
+import { EngagementWorkflowService } from '../engagement-workflow.service';
+
+@Resolver(IEngagement)
+export class EngagementWorkflowEventsResolver {
+  constructor(private readonly service: EngagementWorkflowService) {}
+
+  @ResolveField(() => [WorkflowEvent])
+  async workflowEvents(
+    @Parent() engagement: Engagement,
+    @AnonSession() session: Session,
+  ): Promise<readonly WorkflowEvent[]> {
+    return await this.service.list(engagement, session);
+  }
+}