update server context to only include the notification repository

src/ServerContext.ts

@@ -1,7 +1,8 @@
 import { ETANotificationScheduler } from "./notifications/schedulers/ETANotificationScheduler";
 import { ShuttleGetterSetterRepository } from "./repositories/ShuttleGetterSetterRepository";
+import { NotificationRepository } from "./repositories/NotificationRepository";
 
 export interface ServerContext {
   shuttleRepository: ShuttleGetterSetterRepository;
-  notificationService: ETANotificationScheduler;
+  notificationRepository: NotificationRepository;
 }

src/index.ts

@@ -9,6 +9,7 @@ import { ETANotificationScheduler } from "./notifications/schedulers/ETANotifica
 import { loadShuttleTestData } from "./loaders/loadShuttleTestData";
 import { AppleNotificationSender } from "./notifications/senders/AppleNotificationSender";
 import { InMemoryNotificationRepository } from "./repositories/InMemoryNotificationRepository";
+import { NotificationRepository } from "./repositories/NotificationRepository";
 
 const typeDefs = readFileSync("./schema.graphqls", "utf8");
 
@@ -19,25 +20,32 @@ async function main() {
     introspection: process.env.NODE_ENV !== "production",
   });
 
-  const repository = new UnoptimizedInMemoryShuttleRepository();
+  const shuttleRepository = new UnoptimizedInMemoryShuttleRepository();
+
+  let notificationRepository: NotificationRepository;
   let notificationService: ETANotificationScheduler;
   if (process.argv.length > 2 && process.argv[2] == "integration-testing") {
     console.log("Using integration testing setup")
-    await loadShuttleTestData(repository);
+    await loadShuttleTestData(shuttleRepository);
 
     const appleNotificationSender = new AppleNotificationSender(false);
-    const inMemoryNotificationRepository = new InMemoryNotificationRepository();
+    notificationRepository = new InMemoryNotificationRepository();
     notificationService = new ETANotificationScheduler(
-      repository,
+      shuttleRepository,
-      inMemoryNotificationRepository,
+      notificationRepository,
       appleNotificationSender
     );
   } else {
     const repositoryDataUpdater = new TimedApiBasedShuttleRepositoryLoader(
-      repository
+      shuttleRepository,
     );
     await repositoryDataUpdater.start();
-    notificationService = new ETANotificationScheduler(repository);
+
+    notificationRepository = new InMemoryNotificationRepository();
+    notificationService = new ETANotificationScheduler(
+      shuttleRepository,
+      notificationRepository
+    );
   }
 
   const { url } = await startStandaloneServer(server, {
@@ -46,8 +54,8 @@ async function main() {
     },
     context: async () => {
       return {
-        repository,
+        shuttleRepository,
-        notificationService,
+        notificationRepository,
       }
     },
   });

src/resolvers/MutationResolvers.ts

@@ -30,7 +30,7 @@ export const MutationResolvers: Resolvers<ServerContext> = {
           : ETANotificationScheduler.defaultSecondsThresholdForNotificationToFire,
       }
 
-      await context.notificationService.scheduleNotification(notificationData);
+      await context.notificationRepository.scheduleNotification(notificationData);
 
       const response: NotificationResponse = {
         message: "Notification scheduled",
@@ -40,8 +40,8 @@ export const MutationResolvers: Resolvers<ServerContext> = {
       return response;
     },
     cancelNotification: async (_parent, args, context, _info) => {
-      if (context.notificationService.isNotificationScheduled(args.input)) {
+      if (context.notificationRepository.isNotificationScheduled(args.input)) {
-        await context.notificationService.cancelNotificationIfExists(args.input);
+        await context.notificationRepository.cancelNotificationIfExists(args.input);
         return {
           success: true,
           message: "Notification cancelled",

src/resolvers/QueryResolvers.ts

@@ -18,11 +18,11 @@ export const QueryResolvers: Resolvers<ServerContext> = {
     },
     isNotificationScheduled: async (_parent, args, contextValue, _info) => {
       const notificationData = args.input;
-      return contextValue.notificationService.isNotificationScheduled(notificationData);
+      return contextValue.notificationRepository.isNotificationScheduled(notificationData);
     },
     secondsThresholdForNotification: async (_parent, args, contextValue, _info) => {
       const notificationData = args.input;
-      return contextValue.notificationService.getSecondsThresholdForScheduledNotification(notificationData);
+      return contextValue.notificationRepository.getSecondsThresholdForScheduledNotification(notificationData);
     },
   },
 }

test/resolvers/MutationResolverTests.test.ts

@@ -44,7 +44,7 @@ describe("MutationResolvers", () => {
       const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
       expect(notificationResponse.success).toBe(false);
 
-      expect(context.notificationService.isNotificationScheduled(notificationInput)).toBe(false);
+      expect(context.notificationRepository.isNotificationScheduled(notificationInput)).toBe(false);
     }
 
 
@@ -72,7 +72,7 @@ describe("MutationResolvers", () => {
       expect(notificationResponse?.success).toBe(true);
       expect(notificationResponse?.data).toEqual(expectedNotificationData);
 
-      expect(context.notificationService.getSecondsThresholdForScheduledNotification(expectedNotificationData)).toBe(240);
+      expect(context.notificationRepository.getSecondsThresholdForScheduledNotification(expectedNotificationData)).toBe(240);
     });
 
     it("adds a notification with the default seconds threshold if none is provided", async () => {
@@ -93,7 +93,7 @@ describe("MutationResolvers", () => {
       const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
       expect(notificationResponse?.success).toBe(true);
 
-      expect(context.notificationService.getSecondsThresholdForScheduledNotification(notificationInput)).toBe(180);
+      expect(context.notificationRepository.getSecondsThresholdForScheduledNotification(notificationInput)).toBe(180);
     });
 
     it("fails if the shuttle ID doesn't exist", async () => {
@@ -150,7 +150,7 @@ describe("MutationResolvers", () => {
         stopId: stop.id,
         secondsThreshold: 180,
       }
-      await context.notificationService.scheduleNotification(notificationInput);
+      await context.notificationRepository.scheduleNotification(notificationInput);
 
       const notificationLookup = {
         ...notificationInput
@@ -166,7 +166,7 @@ describe("MutationResolvers", () => {
       expect(notificationResponse.success).toBe(true);
       expect(notificationResponse.data).toEqual(notificationLookup);
 
-      expect(context.notificationService.isNotificationScheduled(notificationLookup)).toBe(false);
+      expect(context.notificationRepository.isNotificationScheduled(notificationLookup)).toBe(false);
     });
 
     it("fails if the notification doesn't exist", async () => {

test/resolvers/QueryResolverTests.test.ts

@@ -112,7 +112,7 @@ describe("QueryResolvers", () => {
         deviceId: "1",
         secondsThreshold: 240,
       };
-      await context.notificationService.scheduleNotification(notification);
+      await context.notificationRepository.scheduleNotification(notification);
 
       const notificationLookup: any = {
         ...notification,

test/testHelpers/apolloTestServerHelpers.ts

@@ -5,6 +5,7 @@ import { UnoptimizedInMemoryShuttleRepository } from "../../src/repositories/Uno
 import { beforeEach } from "@jest/globals";
 import { ServerContext } from "../../src/ServerContext";
 import { ETANotificationScheduler } from "../../src/notifications/schedulers/ETANotificationScheduler";
+import { InMemoryNotificationRepository } from "../../src/repositories/InMemoryNotificationRepository";
 
 
 function setUpTestServer() {
@@ -26,7 +27,7 @@ export function setupTestServerContext() {
 
   beforeEach(() => {
     context.shuttleRepository = new UnoptimizedInMemoryShuttleRepository();
-    context.notificationService = new ETANotificationScheduler(context.repository);
+    context.notificationRepository = new InMemoryNotificationRepository();
   });
 
   return context as ServerContext;