Restructure services

src/controllers/eventController.ts

@@ -1,8 +1,8 @@
 import { Request, Response } from "express";
-import * as EventRepo from "../repos/eventRepo";
+import { eventService } from "../services";
 
 export async function listEvents(req: Request, res: Response): Promise<void> {
-  const events = await EventRepo.findAll();
+  const events = await eventService.findAll();
   res.json(
     events.map(({ type, location, time }) => ({
       type,

src/routes/events.spec.ts

@@ -1,10 +1,10 @@
-import app from "../app";
-import * as eventRepo from "../repos/eventRepo";
 import request from "supertest";
+import app from "../app";
+import eventService from "../services/eventService";
 
 describe("/events", () => {
   it("returns list of events", async () => {
-    eventRepo.add({
+    eventService.add({
       type: "rakennuspalo: keskisuuri",
       location: "Tuusula",
       time: new Date("2021-01-31T22:00:00.000Z"),

src/server.ts

@@ -3,15 +3,14 @@ import cron from "node-cron";
 import config from "./config";
 import logger from "./logger";
 
-import * as eventRepo from "./repos/eventRepo";
-import * as feed from "./feed";
+import { eventService, feedService } from "./services";
 
 cron.schedule("* * * * *", async () => {
   logger.info("Checking feed for new events...");
-  const rawFeed = await feed.decodeFeed();
-  const events = await feed.mapFeedToEvents(rawFeed);
+  const rawFeed = await feedService.decodeFeed();
+  const events = await feedService.mapFeedToEvents(rawFeed);
   for (const event of events) {
-    eventRepo.add(event);
+    eventService.add(event);
   }
 });
 

src/repos/eventRepo.spec.ts → src/services/eventService.spec.ts

@@ -1,14 +1,14 @@
-import * as eventRepo from "./eventRepo";
+import eventService from "./eventService";
 
 describe("EventRepo", () => {
   it("adds event to repository", async () => {
-    eventRepo.add({
+    eventService.add({
       type: "rakennuspalo: keskisuuri",
       location: "Tuusula",
       time: new Date("2021-01-31T22:00:00.000Z"),
       hash: "2a39407ee0570aae8f3ba2842e11aa28ce0f5d9f",
     });
-    expect(await eventRepo.findAll()).toEqual([
+    expect(await eventService.findAll()).toEqual([
       {
         type: "rakennuspalo: keskisuuri",
         location: "Tuusula",
@@ -19,14 +19,14 @@ describe("EventRepo", () => {
   });
   it("does not add duplicate event to repository", async () => {
     for (let i = 0; i < 2; i++) {
-      eventRepo.add({
+      eventService.add({
         type: "rakennuspalo: keskisuuri",
         location: "Tuusula",
         time: new Date("2021-01-31T22:00:00.000Z"),
         hash: "2a39407ee0570aae8f3ba2842e11aa28ce0f5d9f",
       });
     }
-    expect(await eventRepo.findAll()).toEqual([
+    expect(await eventService.findAll()).toEqual([
       {
         type: "rakennuspalo: keskisuuri",
         location: "Tuusula",

src/services/eventService.ts

@@ -0,0 +1,18 @@
+import { RescueEvent } from "../types";
+
+const events: {
+  [hash: string]: RescueEvent;
+} = {};
+
+const eventService = {
+  async findAll(): Promise<RescueEvent[]> {
+    return Object.values(events);
+  },
+  async add(event: RescueEvent): Promise<void> {
+    if (!(event.hash in events)) {
+      events[event.hash] = { ...event };
+    }
+  },
+};
+
+export default eventService;

src/feed/index.spec.ts → src/services/feedService.spec.ts

@@ -1,4 +1,4 @@
-import { mapFeedToEvents } from "./index";
+import feedService from "./feedService";
 
 describe("Feed parser", () => {
   it("maps feed items to event objects", async () => {
@@ -24,7 +24,7 @@ describe("Feed parser", () => {
         </channel>
       </rss>
     `;
-    const events = await mapFeedToEvents(rawFeed);
+    const events = await feedService.mapFeedToEvents(rawFeed);
     expect(events).toEqual([
       {
         type: "rakennuspalo: pieni",

src/services/feedService.ts

@@ -0,0 +1,41 @@
+import axios from "axios";
+import iconv from "iconv-lite";
+import hash from "object-hash";
+import Parser from "rss-parser";
+import { RescueEvent } from "../types";
+
+const feedService = {
+  async decodeFeed(): Promise<string> {
+    const response = await axios.get<ArrayBuffer>(
+      "http://www.peto-media.fi/tiedotteet/rss.xml",
+      {
+        responseType: "arraybuffer",
+      }
+    );
+    return iconv.decode(Buffer.from(response.data), "iso-8859-1");
+  },
+  async mapFeedToEvents(rawFeed: string): Promise<RescueEvent[]> {
+    const parser = new Parser({
+      headers: { Accept: "application/rss+xml, text/xml; q=0.1" },
+    });
+    const feed = await parser.parseString(rawFeed);
+    return feed.items.map((item) => {
+      if (item.title === undefined) {
+        throw new Error(`Failed to parse ${item}`);
+      }
+      const [location, type] = item.title?.split(",");
+      const finnishLocation = location.split("/")[0].trim();
+      const event = {
+        location: finnishLocation.trim(),
+        type: type.trim(),
+        time: new Date(item.isoDate ?? new Date()),
+      };
+      return {
+        ...event,
+        hash: hash(event),
+      };
+    });
+  },
+};
+
+export default feedService;

src/services/index.ts

@@ -0,0 +1,4 @@
+import eventService from "./eventService";
+import feedService from "./feedService";
+
+export { eventService, feedService };