Pass dependencies to Command.process

Author: Lan2u

src/authentication/verify-email/landing-page.ts

@@ -63,6 +63,7 @@ export const landing =
       // by the user clicking the verification link.
       const resultantEvent = await verifyEmail.process({
         events: resourceEvents.right.events,
+        deps,
         command: {
           emailAddress: decoded.right.emailAddress,
           memberNumber: decoded.right.memberNumber,

src/commands/apply-command-to-resource.ts

@@ -9,10 +9,8 @@ import {
 } from '../types/failure-with-status';
 import {StatusCodes} from 'http-status-codes';
 
-type Deps = Pick<Dependencies, 'commitEvent' | 'getResourceEvents'>;
-
 export const applyToResource =
-  <T>(deps: Deps, command: Command<T>) =>
+  <T>(deps: Dependencies, command: Command<T>) =>
   (
     input: T,
     actor: Actor
@@ -25,7 +23,9 @@ export const applyToResource =
     return pipe(
       resource,
       deps.getResourceEvents,
-      TE.bind('event', ({events}) => command.process({command: inputAndActor, events})),
+      TE.bind('event', ({events}) =>
+        command.process({command: inputAndActor, events, deps})
+      ),
       TE.chain(({event, version}) => O.isSome(event) ? deps.commitEvent(resource, version)(event.value) : TE.right({
         status: StatusCodes.CREATED as StatusCodes.CREATED,
         message: 'Success'

src/commands/command.ts

@@ -5,19 +5,23 @@ import * as TE from 'fp-ts/TaskEither';
 import {Actor} from '../types/actor';
 import {Resource} from '../types/resource';
 import {FailureWithStatus} from '../types/failure-with-status';
+import {Dependencies} from '../dependencies';
 
 export type WithActor<T> = T & {actor: Actor};
+export type CommandProcessInput<T> = {
+  command: WithActor<T>;
+  events: ReadonlyArray<DomainEvent>;
+  deps?: Dependencies;
+};
+
 type CommandResult = TE.TaskEither<
   FailureWithStatus,
   O.Option<DomainEvent>
 >;
 
 export type Command<T> = {
   resource: (command: T) => Resource;
-  process: (input: {
-    command: WithActor<T>;
-    events: ReadonlyArray<DomainEvent>;
-  }) => CommandResult;
+  process: (input: CommandProcessInput<T>) => CommandResult;
   decode: Type<T, T, unknown>['decode'];
   isAuthorized: (input: {
     actor: Actor;

tests/commands/apply-command-to-resource.test.ts

@@ -0,0 +1,30 @@
+import * as O from 'fp-ts/Option';
+import * as TE from 'fp-ts/TaskEither';
+import * as t from 'io-ts';
+import {Command} from '../../src/commands';
+import {applyToResource} from '../../src/commands/apply-command-to-resource';
+import {arbitraryActor, getTaskEitherRightOrFail} from '../helpers';
+import {happyPathAdapters} from '../init-dependencies/happy-path-adapters.helper';
+
+describe('apply-command-to-resource', () => {
+  it('passes dependencies to command.process', async () => {
+    const actor = arbitraryActor();
+    const process = jest.fn(() => TE.right(O.none));
+    const command: Command<{id: string}> = {
+      resource: ({id}) => ({type: 'Area', id}),
+      process,
+      decode: t.strict({id: t.string}).decode,
+      isAuthorized: () => true,
+    };
+
+    await getTaskEitherRightOrFail(
+      applyToResource(happyPathAdapters, command)({id: 'area-1'}, actor)
+    );
+
+    expect(process).toHaveBeenCalledWith({
+      command: {id: 'area-1', actor},
+      events: [],
+      deps: happyPathAdapters,
+    });
+  });
+});

tests/read-models/test-framework.ts

@@ -50,10 +50,7 @@ export type TestFramework = {
   ) => Promise<ReadonlyArray<EventOfType<T>>>;
   commands: ToFrameworkCommands<typeof commands>;
   sharedReadModel: Dependencies['sharedReadModel'];
-  depsForApplyToResource: {
-    commitEvent: Dependencies['commitEvent'];
-    getResourceEvents: Dependencies['getResourceEvents'];
-  };
+  depsForApplyToResource: Dependencies;
   eventStoreDb: libsqlClient.Client;
   googleDB: libsqlClient.Client;
   getTroubleTicketData: Dependencies['getTroubleTicketData'];
@@ -86,18 +83,32 @@ export const initTestFramework = async (): Promise<TestFramework> => {
     pipe(getAllEvents(eventDB)(), T.map(getRightOrFail))();
   const frameworkGetAllEventsByType = <EN extends EventName>(eventType: EN) =>
     pipe(getAllEventsByType(eventDB)(eventType), T.map(getRightOrFail))();
+  const depsForApplyToResource: Dependencies = {
+    commitEvent: frameworkCommitEvent,
+    getAllEvents: getAllEvents(eventDB),
+    getAllEventsByType: getAllEventsByType(eventDB),
+    getResourceEvents: getResourceEvents(eventDB),
+    sharedReadModel,
+    logger,
+    rateLimitSendingOfEmails: TE.right,
+    sendEmail: () => TE.right('success'),
+    lastQuizSync: lastSync(googleDB),
+    getSheetData: getSheetData(googleDB),
+    getSheetDataByMemberNumber: getSheetDataByMemberNumber(googleDB),
+    getTroubleTicketData: getTroubleTicketData(
+      googleDB,
+      O.some(TROUBLE_TICKET_SHEET_ID)
+    ),
+  };
 
   const frameworkify =
     <T>(command: Command<T>) =>
     async (commandPayload: T & {actor?: Actor}) => {
       await pipe(
-        applyToResource(
-          {
-            commitEvent: frameworkCommitEvent,
-            getResourceEvents: getResourceEvents(eventDB),
-          },
-          command
-        )(commandPayload, commandPayload.actor ?? arbitraryActor())
+        applyToResource(depsForApplyToResource, command)(
+          commandPayload,
+          commandPayload.actor ?? arbitraryActor()
+        )
       )();
     };
 
@@ -113,10 +124,7 @@ export const initTestFramework = async (): Promise<TestFramework> => {
     eventStoreDb: eventDB,
     googleDB,
     sharedReadModel,
-    depsForApplyToResource: {
-      commitEvent: frameworkCommitEvent,
-      getResourceEvents: getResourceEvents(eventDB),
-    },
+    depsForApplyToResource,
     close: () => {
       eventDB.close();
       googleDB.close();