Serialize workflow for GQL

Author: CarsonF

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

@@ -1,4 +1,4 @@
-import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { Parent, Query, ResolveField, Resolver } from '@nestjs/graphql';
 import { Loader, LoaderOf } from '@seedcompany/data-loader';
 import { stripIndent } from 'common-tags';
 import {
@@ -7,6 +7,7 @@ import {
   Session,
   viewOfChangeset,
 } from '~/common';
+import { SerializedWorkflow } from '../../../workflow/dto';
 import { SecuredProjectStep } from '../../dto';
 import { ProjectLoader } from '../../project.loader';
 import { ProjectWorkflowTransition } from '../dto';
@@ -16,6 +17,11 @@ import { ProjectWorkflowService } from '../project-workflow.service';
 export class ProjectTransitionsResolver {
   constructor(private readonly workflow: ProjectWorkflowService) {}
 
+  @Query(() => SerializedWorkflow)
+  async projectWorkflow() {
+    return this.workflow.serialize();
+  }
+
   @ResolveField(() => [ProjectWorkflowTransition], {
     description:
       'The transitions currently available to execute for this project',

src/components/workflow/dto/index.ts

@@ -1,3 +1,4 @@
 export * from './execute-transition.input';
 export * from './workflow-event.dto';
 export * from './workflow-transition.dto';
+export { SerializedWorkflow } from './serialized-workflow.dto';

src/components/workflow/dto/serialized-workflow.dto.ts

@@ -0,0 +1,140 @@
+import { createUnionType, Field, ObjectType } from '@nestjs/graphql';
+import { cacheable } from '@seedcompany/common';
+import * as uuid from 'uuid';
+import { DataObject, ID, IdField } from '~/common';
+import { Workflow } from '../define-workflow';
+import { DynamicState } from '../transitions/dynamic-state';
+import { TransitionType } from './workflow-transition.dto';
+
+@ObjectType('WorkflowState')
+export class SerializedWorkflowState extends DataObject {
+  @Field()
+  readonly value: string;
+
+  @Field()
+  readonly label: string;
+}
+
+@ObjectType('WorkflowTransitionStaticTo')
+export class SerializedWorkflowTransitionStaticTo extends DataObject {
+  @Field()
+  readonly state: SerializedWorkflowState;
+}
+
+@ObjectType('WorkflowTransitionDynamicTo')
+export class SerializedWorkflowTransitionDynamicTo extends DataObject {
+  @IdField()
+  readonly id: string;
+
+  @Field()
+  readonly label: string;
+
+  @Field(() => [SerializedWorkflowState])
+  readonly relatedStates: readonly SerializedWorkflowState[];
+}
+
+export const SerializedWorkflowTransitionTo = createUnionType({
+  name: 'WorkflowTransitionTo',
+  types: () => [
+    SerializedWorkflowTransitionStaticTo,
+    SerializedWorkflowTransitionDynamicTo,
+  ],
+  resolveType: (
+    value:
+      | SerializedWorkflowTransitionStaticTo
+      | SerializedWorkflowTransitionDynamicTo,
+  ) =>
+    'state' in value
+      ? SerializedWorkflowTransitionStaticTo
+      : SerializedWorkflowTransitionDynamicTo,
+});
+
+@ObjectType('WorkflowCondition')
+export class SerializedWorkflowCondition extends DataObject {
+  @Field()
+  readonly label: string;
+}
+
+@ObjectType('WorkflowNotifier')
+export class SerializedWorkflowNotifier extends DataObject {
+  @Field()
+  readonly label: string;
+}
+
+@ObjectType('WorkflowTransition')
+export class SerializedWorkflowTransition extends DataObject {
+  @IdField()
+  readonly key: ID;
+
+  @Field()
+  readonly devName: string;
+
+  @Field()
+  readonly label: string;
+
+  @Field(() => TransitionType)
+  readonly type: TransitionType;
+
+  @Field(() => [SerializedWorkflowState])
+  readonly from: readonly SerializedWorkflowState[];
+
+  @Field(() => SerializedWorkflowTransitionTo)
+  readonly to: typeof SerializedWorkflowTransitionTo;
+
+  @Field(() => [SerializedWorkflowCondition])
+  readonly conditions: readonly SerializedWorkflowCondition[];
+
+  @Field(() => [SerializedWorkflowNotifier])
+  readonly notifiers: readonly SerializedWorkflowNotifier[];
+}
+
+@ObjectType('Workflow')
+export class SerializedWorkflow extends DataObject {
+  @IdField()
+  readonly id: ID;
+
+  @Field(() => [SerializedWorkflowState])
+  readonly states: readonly SerializedWorkflowState[];
+
+  @Field(() => [SerializedWorkflowTransition])
+  readonly transitions: readonly SerializedWorkflowTransition[];
+
+  static from<W extends Workflow>(workflow: W): SerializedWorkflow {
+    const serializeState = (state: Workflow['state']) => {
+      const { value, label } = workflow.states.entry(state);
+      return { value, label };
+    };
+    const dynamicToId = cacheable(
+      new Map<DynamicState<W['state'], W['context']>, string>(),
+      () => uuid.v1(),
+    );
+    return {
+      id: workflow.id,
+      states: [...workflow.states].map(serializeState),
+      transitions: workflow.transitions.map((transition) => ({
+        key: transition.key,
+        devName: transition.name,
+        label: transition.label,
+        type: transition.type,
+        from: transition.from ? [...transition.from].map(serializeState) : [],
+        to:
+          typeof transition.to === 'string'
+            ? {
+                state: serializeState(transition.to),
+              }
+            : {
+                id: dynamicToId(transition.to),
+                label: transition.to.description,
+                relatedStates:
+                  transition.to.relatedStates?.map(serializeState) ?? [],
+              },
+        conditions: (transition.conditions ?? []).map((condition) => ({
+          label: condition.description,
+        })),
+        notifiers: (transition.notifiers ?? []).map((notifier) => ({
+          label: notifier.description,
+        })),
+      })),
+    };
+  }
+}

src/components/workflow/workflow.service.ts

@@ -3,7 +3,10 @@ import { Nil } from '@seedcompany/common';
 import { ID, Session, UnauthorizedException } from '~/common';
 import { Privileges } from '../authorization';
 import { Workflow } from './define-workflow';
-import { ExecuteTransitionInput as ExecuteTransitionInputFn } from './dto';
+import {
+  ExecuteTransitionInput as ExecuteTransitionInputFn,
+  SerializedWorkflow,
+} from './dto';
 import { withTransitionKey } from './workflow.granter';
 
 type ExecuteTransitionInput = ReturnType<
@@ -119,6 +122,10 @@ export const WorkflowService = <W extends Workflow>(workflow: W) => {
       }
       return input.bypassTo;
     }
+
+    serialize() {
+      return SerializedWorkflow.from(this.workflow);
+    }
   }
 
   return WorkflowServiceClass;