Revamping eatery routes and cache

Author: Aayush-Agnihotri

src/auth/authService.ts

@@ -9,11 +9,9 @@ const generateRefreshToken = (): string => {
 };
 
 const generateAccessToken = (userId: number): string => {
-  return jwt.sign(
-    { userId },
-    process.env.ACCESS_TOKEN_SECRET!,
-    { expiresIn: '15m' },
-  );
+  return jwt.sign({ userId }, process.env.ACCESS_TOKEN_SECRET!, {
+    expiresIn: '15m',
+  });
 };
 
 export const verifyDeviceUuid = async (deviceUuid: string) => {

src/eateries/eateries.schema.ts

@@ -5,7 +5,3 @@ export const getAllEateriesSchema = z.object({
     days: z.coerce.number().int().min(0).default(0),
   }),
 });
-
-// Schema for validating cached eatery data
-// This will be validated by the scraper that sends the data, max 500 eateries for safety
-export const EaterySchema = z.array(z.any()).max(500);

src/eateries/eateryRouter.ts

@@ -4,7 +4,9 @@ import { validateRequest } from '../middleware/validateRequest.js';
 import { getAllEateriesSchema } from './eateries.schema.js';
 import { getAllEateries, getEateryById } from './eateryController.js';
 
-export const eateryRouter = Router();
+const router = Router();
 
-eateryRouter.get('/', validateRequest(getAllEateriesSchema), getAllEateries);
-eateryRouter.get('/:eateryId', getEateryById);
+router.get('/', validateRequest(getAllEateriesSchema), getAllEateries);
+router.get('/:eateryId', getEateryById);
+
+export default router;

src/eateries/eateryService.ts

@@ -1,11 +1,22 @@
 import type { Event } from '@prisma/client';
 
-import { prisma } from '../prisma.js';
 import { NotFoundError } from '../utils/AppError.js';
 import { getAllEateriesData, refreshCacheFromDB } from '../utils/cache.js';
 import type { EateryWithEvents } from '../utils/cache.js';
 
+async function getCachedEateries(): Promise<EateryWithEvents[]> {
+  try {
+    return getAllEateriesData();
+  } catch {
+    // If cache is cold (should never happen), populate it from the database
+    await refreshCacheFromDB();
+    return getAllEateriesData();
+  }
+}
+
 export const getAllEateries = async (days: number = 0) => {
+  const cachedEateries = await getCachedEateries();
+
   // Calculate date range for filtering events
   // days=0 means today, days=1 means tomorrow, etc.
   const now = new Date();
@@ -18,96 +29,7 @@ export const getAllEateries = async (days: number = 0) => {
   const endOfDay = new Date(targetDay);
   endOfDay.setHours(23, 59, 59, 999);
 
-  // Try to get from cache first
-  try {
-    const cachedEateries = getAllEateriesData();
-
-    // Filter events to only include those on the specified day
-    const filteredEateries = filterEateries(
-      cachedEateries,
-      startOfDay,
-      endOfDay,
-    );
-
-    return filteredEateries;
-  } catch {
-    // If cache is cold (should never happen), fall back to database
-    refreshCacheFromDB();
-    const cachedEateries = getAllEateriesData();
-
-    // Filter events to only include those on the specified day
-    const filteredEateries = filterEateries(
-      cachedEateries,
-      startOfDay,
-      endOfDay,
-    );
-
-    return filteredEateries;
-  }
-};
-
-export const getEateryById = async (eateryId: number) => {
-  // Try to get eatery from cache first
-  try {
-    const cachedEateries = getAllEateriesData();
-    const eatery = cachedEateries.find((e) => e.id === eateryId);
-
-    if (!eatery) {
-      throw new NotFoundError('Eatery not found');
-    }
-
-    return eatery;
-  } catch (error) {
-    // If cache is cold or eatery not found in cache, fall back to database
-    if (error instanceof NotFoundError) {
-      throw error;
-    }
-    refreshCacheFromDB();
-    const cachedEateries = getAllEateriesData();
-    const eatery = cachedEateries.find((e) => e.id === eateryId);
-
-    if (eatery) {
-      return eatery;
-    }
-
-    // As a last resort, fetch directly from the database
-    const fromDB = await prisma.eatery.findUnique({
-      where: { id: eateryId },
-      include: {
-        events: {
-          include: {
-            menu: {
-              include: {
-                items: {
-                  include: {
-                    dietaryPreferences: true,
-                    allergens: true,
-                  },
-                },
-              },
-            },
-            userEventVotes: true,
-          },
-          orderBy: {
-            startTimestamp: 'asc',
-          },
-        },
-      },
-    });
-
-    if (!fromDB) {
-      throw new NotFoundError('Eatery not in DB');
-    }
-
-    return fromDB;
-  }
-};
-
-function filterEateries(
-  cachedEateries: EateryWithEvents[],
-  startOfDay: Date,
-  endOfDay: Date,
-) {
+  // Filter events to only include those on the specified day
   const filteredEateries = cachedEateries.map((eatery) => ({
     ...eatery,
     events: eatery.events.filter((event: Event) => {
@@ -118,5 +40,17 @@ function filterEateries(
       return eventStart <= endOfDay && eventEnd >= startOfDay;
     }),
   }));
+
   return filteredEateries;
-}
+};
+
+export const getEateryById = async (eateryId: number) => {
+  const cachedEateries = await getCachedEateries();
+  const eatery = cachedEateries.find((e) => e.id === eateryId);
+
+  if (!eatery) {
+    throw new NotFoundError(`Eatery with ID ${eateryId} not found`);
+  }
+
+  return eatery;
+};

src/server.ts

@@ -4,13 +4,14 @@ import express from 'express';
 import type { Request, Response } from 'express';
 
 import authRouter from './auth/authRouter.js';
-import { eateryRouter } from './eateries/eateryRouter.js';
+import eateryRouter from './eateries/eateryRouter.js';
 import { requireAuth } from './middleware/authentication.js';
 import { globalErrorHandler } from './middleware/errorHandler.js';
 import { requestLogger } from './middleware/logger.js';
 import { ipRateLimiter } from './middleware/rateLimit.js';
 import { prisma } from './prisma.js';
 import userRouter from './users/userRouter.js';
+import { cacheRouter } from './utils/cache.js';
 import { refreshCacheFromDB } from './utils/cache.js';
 
 const app = express();
@@ -49,6 +50,7 @@ router.get('/health', async (_: Request, res: Response) => {
 
 // Public routes
 router.use('/auth', authRouter);
+router.use('/internal/cache', cacheRouter);
 router.use('/eateries', eateryRouter);
 
 // Protected routes

src/utils/cache.ts

@@ -1,4 +1,5 @@
 import NodeCache from 'node-cache';
+import { z } from 'zod';
 
 import type { Eatery, Event } from '@prisma/client';
 
@@ -9,55 +10,64 @@ import {
   Router,
 } from 'express';
 
-import { EaterySchema } from '../eateries/eateries.schema.js';
+import { validateRequest } from '../middleware/validateRequest.js';
 import { prisma } from '../prisma.js';
 import { UnauthorizedError } from './AppError.js';
 
 export const cacheRouter = Router();
-export const appCache = new NodeCache({ stdTTL: 0 }); // never expire
+const appCache = new NodeCache({ stdTTL: 0 }); // never expire
 
 export type EateryWithEvents = Eatery & { events: Event[] };
 
-function requireSecret(req: Request, _res: Response, next: NextFunction): void {
+/**
+ * Cache keys used throughout the application
+ */
+const CACHE_KEYS = {
+  ALL_EATERIES_DATA: 'allEateriesData',
+  ALL_EATERIES_ETAG: 'allEateriesEtag',
+} as const;
+
+/**
+ * Schema for validating cached eatery data
+ * This will be validated by the scraper that sends the data
+ * Max 100 eateries for safety to prevent memory issues
+ */
+const allEateriesSchema = z.object({
+  body: z.object({
+    eateries: z.array(z.any()).max(100),
+  }),
+});
+
+function requireCacheRefreshSecret(
+  req: Request,
+  _res: Response,
+  next: NextFunction,
+): void {
   const provided = req.header(process.env.CACHE_REFRESH_HEADER!);
   if (!provided || provided !== process.env.CACHE_REFRESH_SECRET) {
-    throw new UnauthorizedError();
+    throw new UnauthorizedError('Invalid cache refresh secret provided');
   }
   next();
 }
 
 export function getAllEateriesData(): EateryWithEvents[] {
-  const data = appCache.get<EateryWithEvents[]>('allEateriesData');
+  const data = appCache.get<EateryWithEvents[]>(CACHE_KEYS.ALL_EATERIES_DATA);
   if (!data) {
-    const err = new Error(
-      'Cache is cold. allEateriesData is not set.',
-    ) as Error & { status?: number };
-    err.status = 503;
-    throw err;
+    throw new Error('Cache miss: eateries data not found in cache');
   }
   return data;
 }
 
-// Private cache refresh route for scraper
-cacheRouter.post('/internal/refresh-cache', requireSecret, (req, res) => {
-  const parse = EaterySchema.safeParse(req.body);
-  if (!parse.success) {
-    res
-      .status(400)
-      .json({ error: 'Invalid payload', issues: parse.error.issues });
-    return;
+export function getEateriesEtag(): string {
+  const etag = appCache.get<string>(CACHE_KEYS.ALL_EATERIES_ETAG);
+  if (!etag) {
+    throw new Error('Cache miss: eateries ETag not found in cache');
   }
-
-  appCache.set('allEateriesData', parse.data);
-  const etag = `"eateries-${Date.now()}"`;
-  appCache.set('allEateriesEtag', etag);
-
-  console.log('Cache updated, allEateriesData refreshed.');
-  res.status(200).json({ ok: true });
-});
+  return etag;
+}
 
 export async function refreshCacheFromDB() {
-  appCache.del('allEateriesData');
+  clearAppCache();
   const eateries = await prisma.eatery.findMany({
     include: {
       events: {
@@ -80,12 +90,36 @@ export async function refreshCacheFromDB() {
       },
     },
   });
-  appCache.set('allEateriesData', eateries);
-  const etag = `"eateries-${Date.now()}"`;
-  appCache.set('allEateriesEtag', etag);
-  console.log('Cache updated from DB, allEateriesData refreshed.');
+  populateCache(eateries);
 }
 
 export function clearAppCache(): void {
   appCache.flushAll();
 }
+
+function populateCache(eateries: EateryWithEvents[]): void {
+  appCache.set(CACHE_KEYS.ALL_EATERIES_DATA, eateries);
+  const etag = `"eateries-${Date.now()}"`;
+  appCache.set(CACHE_KEYS.ALL_EATERIES_ETAG, etag);
+  console.log(
+    `Cache updated at ${new Date().toISOString()}, ${eateries.length} eateries cached.`,
+  );
+}
+
+/**
+ * Private cache refresh route for scraper
+ * Allows the scraper to update the cache with new eatery data
+ */
+cacheRouter.post(
+  '/',
+  requireCacheRefreshSecret,
+  validateRequest(allEateriesSchema),
+  (req, res) => {
+    const { eateries } = req.body;
+    populateCache(eateries);
+    return res.status(200).json({
+      message: 'Cache refreshed successfully',
+      count: eateries.length,
+    });
+  },
+);