Implement CacheHandler for caching ICS data and refactor timetable fetching logic as well as more robust error handling

Author: NLion74

package.json

@@ -1,6 +1,6 @@
 {
     "name": "webuntis-timetable",
-    "version": "1.0.0",
+    "version": "0.2.0",
     "type": "commonjs",
     "scripts": {
         "build": "tsc -p tsconfig.json",
@@ -14,7 +14,7 @@
     },
     "devDependencies": {
         "@types/express": "^5.0.3",
-        "@types/node": "^24.3.1",
+        "@types/node": "24.3.3",
         "ts-node": "^x.x.x",
         "typescript": "^x.x.x"
     }

src/cacheHandler.ts

@@ -0,0 +1,35 @@
+import { CacheEntry } from "./types";
+
+export class CacheHandler {
+    private cache = new Map<string, CacheEntry>();
+    private ttlMs: number;
+
+    constructor(ttlSeconds: number) {
+        this.ttlMs = ttlSeconds * 1000;
+        setInterval(() => this.cleanup(), 60_000);
+    }
+
+    get(user: string): CacheEntry | undefined {
+        const entry = this.cache.get(user);
+        if (!entry) return undefined;
+        const now = Date.now();
+        if (now - entry.timestamp > this.ttlMs) {
+            this.cache.delete(user);
+            return undefined;
+        }
+        return entry;
+    }
+
+    set(user: string, ics: string) {
+        this.cache.set(user, { timestamp: Date.now(), ics });
+    }
+
+    private cleanup() {
+        const now = Date.now();
+        for (const [user, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.ttlMs) {
+                this.cache.delete(user);
+            }
+        }
+    }
+}

src/ics.ts

@@ -1,4 +1,3 @@
-// src/ics.ts
 import ical, { ICalEventStatus } from "ical-generator";
 import { Lesson } from "./types";
 

src/index.ts

@@ -3,14 +3,25 @@ import { loadConfig } from "./config";
 import { fetchTimetable } from "./webuntis";
 import { lessonsToIcs } from "./ics";
 import { CacheEntry } from "./types";
+import { sessionCache, SESSION_TTL_MS } from "./webuntis";
+import { CacheHandler } from "./cacheHandler";
 
 async function main() {
     const { config, configPath } = await loadConfig();
     console.log(`Loaded config from ${configPath}`);
 
     const app = express();
+    const icsCache = new CacheHandler(config.cacheDuration);
 
-    const icsCache = new Map<string, CacheEntry>();
+    function sendIcs(res: express.Response, filename: string, ics: string) {
+        return res
+            .setHeader("Content-Type", "text/calendar")
+            .setHeader(
+                "Content-Disposition",
+                `attachment; filename=${filename}.ics`
+            )
+            .send(ics);
+    }
 
     app.get("/timetable/:name", async (req, res) => {
         try {
@@ -21,19 +32,9 @@ async function main() {
             );
             if (!user) return res.status(404).send("User not found");
 
-            const now = Date.now();
-            const cache = icsCache.get(user.username);
-            if (
-                cache &&
-                now - cache.timestamp < config.cacheDuration * 60 * 60 * 24
-            ) {
-                return res
-                    .setHeader("Content-Type", "text/calendar")
-                    .setHeader(
-                        "Content-Disposition",
-                        `attachment; filename=${user.friendlyName}.ics`
-                    )
-                    .send(cache.ics);
+            const cacheEntry = icsCache.get(user.username);
+            if (cacheEntry) {
+                return sendIcs(res, user.friendlyName, cacheEntry.ics);
             }
 
             const today = new Date();
@@ -48,14 +49,7 @@ async function main() {
                 config.timezone || "Europe/Berlin"
             );
 
-            icsCache.set(user.username, { timestamp: now, ics });
-
-            res.setHeader("Content-Type", "text/calendar");
-            res.setHeader(
-                "Content-Disposition",
-                `attachment; filename=${user.friendlyName}.ics`
-            );
-            res.send(ics);
+            return sendIcs(res, user.friendlyName, ics);
         } catch (err) {
             console.error(err);
             res.status(500).send("Error fetching timetable");

src/webuntis.ts

@@ -8,8 +8,8 @@ interface SessionEntry {
     timestamp: number;
 }
 
-const sessionCache = new Map<string, SessionEntry>();
-const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
+export const sessionCache = new Map<string, SessionEntry>();
+export const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 
 async function getUntisSession(user: User): Promise<WebUntis> {
     const cached = sessionCache.get(user.username);
@@ -41,7 +41,6 @@ export async function fetchTimetable(
     const untis = await getUntisSession(user);
 
     try {
-        await untis.login();
         const rawTimetable = await untis.getOwnTimetableForRange(
             startDate,
             endDate
@@ -59,9 +58,9 @@ export async function fetchTimetable(
             .map((entry: any) => ({
                 startTime: entry.startTime,
                 endTime: entry.endTime,
-                subject: entry.su?.[0]?.longname || "Event",
+                subject: entry.su?.[0]?.name || "Event",
                 teacher: entry.te?.[0]?.name || "Unknown Teacher",
-                room: entry.ro?.[0]?.longname || "Unknown Room",
+                room: entry.ro?.[0]?.name || "Unknown Room",
                 class:
                     entry.kl?.[1]?.longname ||
                     entry.kl?.[0]?.longname ||
@@ -70,7 +69,9 @@ export async function fetchTimetable(
             }));
 
         return mergeLessons(lessons);
-    } finally {
+    } catch (error) {
         await untis.logout();
+        sessionCache.delete(user.username);
+        throw error;
     }
 }