+171 -21

public/app.js

reviewed

··· 98 98 let allStories = []; // Store all stories for filtering 99 99 let showVerifiedOnly = false; // Default to showing all stories 100 100 101 101 + // Cache for ETags and data to support conditional requests 102 102 + const etagCache = { 103 103 + stories: null, 104 104 + totalStories: null, 105 105 + verifiedUsers: null 106 106 + }; 107 107 + 108 108 + // Cache for actual response data 109 109 + const responseCache = { 110 110 + stories: null, 111 111 + totalStories: null, 112 112 + verifiedUsers: null 113 113 + }; 114 114 + 101 115 // Fetch stories data 102 116 function fetchStories() { 103 117 // Update last refresh time ··· 111 125 } 112 126 113 127 // Fetch total stories count first 114 114 - fetch(`/api/stats/total-stories?_=${Date.now()}`) 115 115 - .then((response) => response.json()) 128 128 + const totalStoriesOptions = { 129 129 + headers: {} 130 130 + }; 131 131 + 132 132 + // Add If-None-Match header if we have an ETag 133 133 + if (etagCache.totalStories) { 134 134 + totalStoriesOptions.headers['If-None-Match'] = etagCache.totalStories; 135 135 + } 136 136 + 137 137 + fetch('/api/stats/total-stories', totalStoriesOptions) 138 138 + .then((response) => { 139 139 + // Store the new ETag if available 140 140 + const etag = response.headers.get('ETag'); 141 141 + if (etag) etagCache.totalStories = etag; 142 142 + 143 143 + // If 304 Not Modified, use cached data 144 144 + if (response.status === 304) { 145 145 + console.log('Total stories not modified, using cached data'); 146 146 + return responseCache.totalStories; // Use cached data 147 147 + } 148 148 + 149 149 + return response.json(); 150 150 + }) 116 151 .then((data) => { 117 117 - if (data && typeof data.count !== "undefined") { 118 118 - totalStoriesCount = data.count; 119 119 - currentFrontpageCountEl.textContent = totalStoriesCount; 152 152 + if (data) { 153 153 + // Store in cache for future 304 responses 154 154 + responseCache.totalStories = data; 155 155 + 156 156 + if (typeof data.count !== "undefined") { 157 157 + totalStoriesCount = data.count; 158 158 + currentFrontpageCountEl.textContent = totalStoriesCount; 159 159 + } 120 160 } 121 161 }) 122 162 .catch((error) => { ··· 124 164 }); 125 165 126 166 // Fetch verified user stats for the top row 127 127 - fetch(`/api/stats/verified-users?_=${Date.now()}`) 128 128 - .then((response) => response.json()) 167 167 + const verifiedUsersOptions = { 168 168 + headers: {} 169 169 + }; 170 170 + 171 171 + // Add If-None-Match header if we have an ETag 172 172 + if (etagCache.verifiedUsers) { 173 173 + verifiedUsersOptions.headers['If-None-Match'] = etagCache.verifiedUsers; 174 174 + } 175 175 + 176 176 + fetch('/api/stats/verified-users', verifiedUsersOptions) 177 177 + .then((response) => { 178 178 + // Store the new ETag if available 179 179 + const etag = response.headers.get('ETag'); 180 180 + if (etag) etagCache.verifiedUsers = etag; 181 181 + 182 182 + // If 304 Not Modified, use cached data 183 183 + if (response.status === 304) { 184 184 + console.log('Verified users stats not modified, using cached data'); 185 185 + return responseCache.verifiedUsers; // Use cached data 186 186 + } 187 187 + 188 188 + return response.json(); 189 189 + }) 129 190 .then((data) => { 130 130 - verifiedUserStats = data; 131 131 - // Update top row stats with the new data 132 132 - updateTopStats(data); 191 191 + if (data) { 192 192 + // Store in cache for future 304 responses 193 193 + responseCache.verifiedUsers = data; 194 194 + 195 195 + verifiedUserStats = data; 196 196 + updateTopStats(data); // Update UI with the new stats 197 197 + } 133 198 }) 134 199 .catch((error) => { 135 200 console.error("Error fetching verified user stats:", error); 136 201 }); 137 202 138 138 - fetch(`/api/stories?_=${Date.now()}`) 203 203 + // Fetch stories 204 204 + const storiesOptions = { 205 205 + headers: {} 206 206 + }; 207 207 + 208 208 + // Add If-None-Match header if we have an ETag 209 209 + if (etagCache.stories) { 210 210 + storiesOptions.headers['If-None-Match'] = etagCache.stories; 211 211 + } 212 212 + 213 213 + fetch('/api/stories', storiesOptions) 139 214 .then((response) => { 215 215 + // Store the new ETag if available 216 216 + const etag = response.headers.get('ETag'); 217 217 + if (etag) etagCache.stories = etag; 218 218 + 140 219 if (!response.ok) { 220 220 + // Allow 304 Not Modified 221 221 + if (response.status === 304) { 222 222 + console.log('Stories not modified, using cached data'); 223 223 + return responseCache.stories; // Use cached data 224 224 + } 141 225 throw new Error("Network response was not ok"); 142 226 } 143 227 return response.json(); 144 228 }) 145 229 .then((data) => { 146 146 - // Store all stories for filtering 147 147 - allStories = data; 148 148 - 149 149 - // Apply filters and update UI 150 150 - applyFiltersAndUpdateUI(); 230 230 + if (data) { 231 231 + // Store in cache for future 304 responses 232 232 + responseCache.stories = data; 233 233 + 234 234 + // Store all stories for filtering 235 235 + allStories = data; 236 236 + // Apply filters and update UI 237 237 + applyFiltersAndUpdateUI(); 238 238 + } 151 239 }) 152 240 .catch((error) => { 153 241 storyList.innerHTML = `<div class="loading">Error loading data: ${error.message}</div>`; ··· 287 375 } 288 376 289 377 // Load story snapshots and display graph 378 378 + // Cache for story snapshot ETags and data 379 379 + const snapshotEtagCache = {}; 380 380 + const snapshotDataCache = {}; 381 381 + 290 382 function loadStoryGraph(storyId) { 291 383 if (activeStoryId === storyId) return; 292 384 activeStoryId = storyId; ··· 295 387 rankChart.style.display = "none"; 296 388 noGraph.innerHTML = '<div class="loading">Loading graph data...</div>'; 297 389 298 298 - fetch(`/api/story/${storyId}/snapshots?_=${Date.now()}`) 390 390 + const options = { 391 391 + headers: {} 392 392 + }; 393 393 + 394 394 + // Add If-None-Match header if we have an ETag for this story 395 395 + if (snapshotEtagCache[storyId]) { 396 396 + options.headers['If-None-Match'] = snapshotEtagCache[storyId]; 397 397 + } 398 398 + 399 399 + // Use template literal correctly since we need string interpolation 400 400 + fetch(`/api/story/${storyId}/snapshots`, options) 299 401 .then((response) => { 402 402 + // Store the new ETag if available 403 403 + const etag = response.headers.get('ETag'); 404 404 + if (etag) snapshotEtagCache[storyId] = etag; 405 405 + 300 406 if (!response.ok) { 407 407 + // Allow 304 Not Modified 408 408 + if (response.status === 304) { 409 409 + console.log(`Story ${storyId} snapshots not modified, using cached data`); 410 410 + // Use the cached data for this story ID 411 411 + if (snapshotDataCache[storyId]) { 412 412 + return snapshotDataCache[storyId]; 413 413 + } 414 414 + // If we don't have cached data, re-fetch 415 415 + throw new Error("Cache miss on 304, re-fetching"); 416 416 + } 301 417 throw new Error("Failed to fetch snapshot data"); 302 418 } 303 419 return response.json(); ··· 309 425 return; 310 426 } 311 427 428 428 + // Cache the snapshots data for future use 429 429 + snapshotDataCache[storyId] = snapshots; 430 430 + 312 431 displayGraph(snapshots); 313 432 }) 314 433 .catch((error) => { ··· 430 549 now = Date.now(); 431 550 432 551 // Get total stories from the API 433 433 - fetch(`/api/stats/total-stories?_=${Date.now()}`) 434 434 - .then((response) => response.json()) 552 552 + const options = { 553 553 + headers: {} 554 554 + }; 555 555 + 556 556 + // Add If-None-Match header if we have an ETag 557 557 + if (etagCache.totalStories) { 558 558 + options.headers['If-None-Match'] = etagCache.totalStories; 559 559 + } 560 560 + 561 561 + fetch('/api/stats/total-stories', options) 562 562 + .then((response) => { 563 563 + // Store the new ETag if available 564 564 + const etag = response.headers.get('ETag'); 565 565 + if (etag) etagCache.totalStories = etag; 566 566 + 567 567 + // If 304 Not Modified, use cached data 568 568 + if (response.status === 304) { 569 569 + console.log('Total stories not modified, using cached data for metrics'); 570 570 + return responseCache.totalStories; 571 571 + } 572 572 + 573 573 + return response.json(); 574 574 + }) 435 575 .then((data) => { 436 436 - currentFrontpageCountEl.textContent = 437 437 - data.count !== undefined ? data.count : allStories.length; 576 576 + if (data) { 577 577 + // Update cache 578 578 + responseCache.totalStories = data; 579 579 + 580 580 + if (data.count !== undefined) { 581 581 + currentFrontpageCountEl.textContent = data.count; 582 582 + } else { 583 583 + currentFrontpageCountEl.textContent = allStories.length; // Fallback to local data 584 584 + } 585 585 + } else { 586 586 + currentFrontpageCountEl.textContent = allStories.length; // Fallback to local data 587 587 + } 438 588 }) 439 589 .catch((error) => { 440 590 console.error("Error fetching total stories count:", error);

+35 -17

src/features/services/check_hn.ts

reviewed

··· 1 1 import { CronJob } from "cron"; 2 2 import * as Sentry from "@sentry/bun"; 3 3 - import { db, environment } from "../../index"; 3 3 + import { db, environment, invalidateAllCaches } from "../../index"; 4 4 import { 5 5 users as usersTable, 6 6 stories as storiesTable, ··· 147 147 // First, filter out job stories and create a map of adjusted positions 148 148 const positionMap = new Map<number, number>(); // Maps story ID to adjusted position 149 149 let adjustedPosition = 0; 150 150 - 150 150 + 151 151 for (let i = 0; i < stories.length; i++) { 152 152 const story = stories[i]; 153 153 if (!story) continue; 154 154 - 154 154 + 155 155 // Skip jobs, but include other types (mainly 'story') 156 156 - if (story.type === 'job') { 157 157 - console.log(`[INFO] Skipping job at original position ${i + 1}, ID: ${story.id}`); 156 156 + if (story.type === "job") { 157 157 + console.log( 158 158 + `[INFO] Skipping job at original position ${i + 1}, ID: ${story.id}`, 159 159 + ); 158 160 continue; 159 161 } 160 160 - 162 162 + 161 163 // Only increment position for non-job stories 162 164 adjustedPosition++; 163 165 positionMap.set(story.id, adjustedPosition); 164 164 - 166 166 + 165 167 // Add to non-job story IDs for front page consideration 166 168 if (adjustedPosition <= TOP_STORIES_LIMIT) { 167 169 nonJobStoryIds.push(story.id); 168 170 } 169 171 } 170 170 - 171 171 - console.log(`Filtered out job stories. Have ${adjustedPosition} stories after filtering.`); 172 172 - console.log(`Front page contains the top ${Math.min(TOP_STORIES_LIMIT, nonJobStoryIds.length)} non-job stories`); 173 173 - 172 172 + 173 173 + console.log( 174 174 + `Filtered out job stories. Have ${adjustedPosition} stories after filtering.`, 175 175 + ); 176 176 + console.log( 177 177 + `Front page contains the top ${Math.min(TOP_STORIES_LIMIT, nonJobStoryIds.length)} non-job stories`, 178 178 + ); 179 179 + 174 180 // Now use the adjusted positions when processing stories 175 181 const frontPageIds = nonJobStoryIds.slice(0, TOP_STORIES_LIMIT); 176 176 - 182 182 + 177 183 // Process each story 178 184 for (let i = 0; i < stories.length; i++) { 179 185 const story = stories[i]; 180 186 if (!story) { 181 181 - console.log(`[WARNING] Null story at original position ${i + 1}, skipping`); 187 187 + console.log( 188 188 + `[WARNING] Null story at original position ${i + 1}, skipping`, 189 189 + ); 182 190 continue; 183 191 } 184 184 - 192 192 + 185 193 // Skip job stories entirely 186 186 - if (story.type === 'job') { 194 194 + if (story.type === "job") { 187 195 continue; 188 196 } 189 189 - 197 197 + 190 198 // Use the adjusted position for non-job stories 191 191 - const position = positionMap.get(story.id) || (i + 1); 199 199 + const position = positionMap.get(story.id) || i + 1; 192 200 const isOnFrontPage = position <= TOP_STORIES_LIMIT; 193 201 const isNumberOne = position === 1; 194 202 ··· 796 804 await processStories(); 797 805 console.log("Story processing completed"); 798 806 807 807 + // Invalidate all caches after data update 808 808 + invalidateAllCaches(); 809 809 + console.log("All query caches invalidated"); 810 810 + 799 811 console.log("Starting cleanup of expired stories..."); 800 812 // Clean up expired stories 801 813 await cleanupExpiredStories(); 802 814 console.log("Cleanup completed"); 815 815 + 816 816 + // Invalidate caches again after cleanup 817 817 + invalidateAllCaches(); 803 818 } catch (error) { 804 819 console.error("Error in checkHackerNews:", error); 805 820 Sentry.captureException(error); ··· 830 845 831 846 // Run immediately on startup 832 847 checkHackerNews(); 848 848 + 849 849 + // Initialize query cache 850 850 + console.log("Query cache initialized"); 833 851 834 852 console.log("HackerNews monitoring service started"); 835 853 }

+169 -78

src/index.ts

reviewed

··· 7 7 import { count } from "drizzle-orm"; 8 8 import { stories } from "./libs/schema"; 9 9 10 10 + // Cache system for database queries 11 11 + type CacheItem<T> = { 12 12 + data: T; 13 13 + timestamp: number; 14 14 + expiresAt: number; 15 15 + }; 16 16 + 17 17 + class QueryCache { 18 18 + private cache: Map<string, CacheItem<unknown>> = new Map(); 19 19 + private defaultTTL: number = 60 * 5; // 5 minutes in seconds 20 20 + 21 21 + constructor(defaultTTL?: number) { 22 22 + if (defaultTTL) { 23 23 + this.defaultTTL = defaultTTL; 24 24 + } 25 25 + console.log(`Initialized query cache with ${this.defaultTTL}s TTL`); 26 26 + } 27 27 + 28 28 + async get<T>( 29 29 + key: string, 30 30 + queryFn: () => Promise<T>, 31 31 + ttl: number = this.defaultTTL 32 32 + ): Promise<T> { 33 33 + const now = Math.floor(Date.now() / 1000); 34 34 + const cached = this.cache.get(key); 35 35 + 36 36 + // Return cached value if it exists and is not expired 37 37 + if (cached && cached.expiresAt > now) { 38 38 + console.log(`Cache hit for ${key} (expires in ${cached.expiresAt - now}s)`); 39 39 + return cached.data as T; 40 40 + } 41 41 + 42 42 + // Execute the query 43 43 + console.log(`Cache miss for ${key}, fetching from database...`); 44 44 + const data = await queryFn(); 45 45 + 46 46 + // Cache the result 47 47 + this.cache.set(key, { 48 48 + data, 49 49 + timestamp: now, 50 50 + expiresAt: now + ttl, 51 51 + }); 52 52 + 53 53 + return data; 54 54 + } 55 55 + 56 56 + invalidate(key: string): void { 57 57 + if (this.cache.has(key)) { 58 58 + console.log(`Invalidating cache for ${key}`); 59 59 + this.cache.delete(key); 60 60 + } 61 61 + } 62 62 + 63 63 + invalidateAll(): void { 64 64 + console.log("Invalidating entire cache"); 65 65 + this.cache.clear(); 66 66 + } 67 67 + } 68 68 + 69 69 + // Create a global cache instance 70 70 + const queryCache = new QueryCache(); 71 71 + 10 72 const environment = process.env.NODE_ENV; 11 73 const commit = (() => { 12 74 try { ··· 69 131 "/api/stories": async () => { 70 132 try { 71 133 // Get stories that reached the front page (leaderboard) 72 72 - const storyAlerts = await db.query.stories.findMany({ 73 73 - where: (stories, { eq }) => eq(stories.isOnLeaderboard, true), 74 74 - orderBy: (stories, { asc }) => [asc(stories.position)], 75 75 - limit: 100, 76 76 - }); 77 77 - 78 78 - // Transform story data to match the format expected by the frontend 79 79 - const alerts = storyAlerts.map((story) => ({ 80 80 - id: story.id, 81 81 - title: story.title, 82 82 - url: story.url || `https://news.ycombinator.com/item?id=${story.id}`, 83 83 - rank: story.position, 84 84 - peakRank: story.peakPosition, 85 85 - points: story.score, 86 86 - peakPoints: story.peakScore, 87 87 - comments: story.descendants, 88 88 - timestamp: story.enteredLeaderboardAt 89 89 - ? new Date(story.enteredLeaderboardAt * 1000).toISOString() 90 90 - : new Date(story.firstSeenAt * 1000).toISOString(), 91 91 - by: story.by, 92 92 - isFromMonitoredUser: story.isFromMonitoredUser, 93 93 - })); 134 134 + const alerts = await queryCache.get( 135 135 + 'leaderboard_stories', 136 136 + async () => { 137 137 + const storyAlerts = await db.query.stories.findMany({ 138 138 + where: (stories, { eq }) => eq(stories.isOnLeaderboard, true), 139 139 + orderBy: (stories, { asc }) => [asc(stories.position)], 140 140 + limit: 100, 141 141 + }); 142 142 + 143 143 + // Transform story data to match the format expected by the frontend 144 144 + return storyAlerts.map((story) => ({ 145 145 + id: story.id, 146 146 + title: story.title, 147 147 + url: story.url || `https://news.ycombinator.com/item?id=${story.id}`, 148 148 + rank: story.position, 149 149 + peakRank: story.peakPosition, 150 150 + points: story.score, 151 151 + peakPoints: story.peakScore, 152 152 + comments: story.descendants, 153 153 + timestamp: story.enteredLeaderboardAt 154 154 + ? new Date(story.enteredLeaderboardAt * 1000).toISOString() 155 155 + : new Date(story.firstSeenAt * 1000).toISOString(), 156 156 + by: story.by, 157 157 + isFromMonitoredUser: story.isFromMonitoredUser, 158 158 + })); 159 159 + } 160 160 + ); 94 161 95 162 return new Response(JSON.stringify(alerts), { 96 163 headers: { 97 164 "Content-Type": "application/json", 98 98 - "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate", 99 99 - "Pragma": "no-cache", 100 100 - "Expires": "0" 165 165 + "Cache-Control": "max-age=300", 166 166 + "ETag": `"${version}-stories-${Date.now()}"`, 101 167 }, 102 168 }); 103 169 } catch (error) { ··· 113 179 }, 114 180 "/api/stats/total-stories": async () => { 115 181 try { 116 116 - // Count all stories in the database 117 117 - const result = await db.select({ count: count() }).from(stories); 118 118 - const totalCount = Number(result[0]?.count); 182 182 + // Count all stories in the database using the cache 183 183 + const totalCount = await queryCache.get( 184 184 + 'total_stories_count', 185 185 + async () => { 186 186 + const result = await db.select({ count: count() }).from(stories); 187 187 + return Number(result[0]?.count); 188 188 + } 189 189 + ); 119 190 120 191 return new Response( 121 192 JSON.stringify({ ··· 125 196 { 126 197 headers: { 127 198 "Content-Type": "application/json", 128 128 - "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate", 129 129 - "Pragma": "no-cache", 130 130 - "Expires": "0" 199 199 + "Cache-Control": "max-age=300", 200 200 + "ETag": `"${version}-stats-${Date.now()}"`, 131 201 }, 132 202 }, 133 203 ); ··· 144 214 }, 145 215 "/api/stats/verified-users": async () => { 146 216 try { 147 147 - // Get stats for verified user stories 148 148 - const verifiedStories = await db.query.stories.findMany({ 149 149 - where: (stories, { eq }) => eq(stories.isFromMonitoredUser, true), 150 150 - }); 151 151 - // Get count of verified users in the system 152 152 - const verifiedUsersCount = await db.query.users 153 153 - .findMany({ 154 154 - where: (users, { eq }) => eq(users.verified, true), 155 155 - }) 156 156 - .then((users) => users.length); 157 157 - 158 158 - // Count stories on front page (rank <= 30) 159 159 - const frontPageCount = verifiedStories.filter( 160 160 - (s) => s.isOnLeaderboard, 161 161 - ).length; 162 162 - 163 163 - // Calculate average peak points for verified users 164 164 - let totalPeakPoints = 0; 165 165 - for (const s of verifiedStories) { 166 166 - if (s.peakScore) totalPeakPoints += s.peakScore; 167 167 - } 168 168 - const avgPeakPoints = verifiedStories.length 169 169 - ? Math.round(totalPeakPoints / verifiedStories.length) 170 170 - : 0; 217 217 + // Get stats for verified user stories using the cache 218 218 + const verifiedStats = await queryCache.get( 219 219 + 'verified_users_stats', 220 220 + async () => { 221 221 + // Get stats for verified user stories 222 222 + const verifiedStories = await db.query.stories.findMany({ 223 223 + where: (stories, { eq }) => eq(stories.isFromMonitoredUser, true), 224 224 + }); 225 225 + // Get count of verified users in the system 226 226 + const verifiedUsersCount = await db.query.users 227 227 + .findMany({ 228 228 + where: (users, { eq }) => eq(users.verified, true), 229 229 + }) 230 230 + .then((users) => users.length); 231 231 + 232 232 + // Count stories on front page (rank <= 30) 233 233 + const frontPageCount = verifiedStories.filter( 234 234 + (s) => s.isOnLeaderboard, 235 235 + ).length; 236 236 + 237 237 + // Calculate average peak points for verified users 238 238 + let totalPeakPoints = 0; 239 239 + for (const s of verifiedStories) { 240 240 + if (s.peakScore) totalPeakPoints += s.peakScore; 241 241 + } 242 242 + const avgPeakPoints = verifiedStories.length 243 243 + ? Math.round(totalPeakPoints / verifiedStories.length) 244 244 + : 0; 245 245 + 246 246 + return { 247 247 + totalCount: verifiedUsersCount, 248 248 + frontPageCount: frontPageCount, 249 249 + avgPeakPoints: avgPeakPoints, 250 250 + }; 251 251 + } 252 252 + ); 171 253 172 254 return new Response( 173 255 JSON.stringify({ 174 174 - totalCount: verifiedUsersCount, 175 175 - frontPageCount: frontPageCount, 176 176 - avgPeakPoints: avgPeakPoints, 256 256 + ...verifiedStats, 177 257 timestamp: Math.floor(Date.now() / 1000), 178 258 }), 179 259 { 180 260 headers: { 181 261 "Content-Type": "application/json", 182 182 - "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate", 183 183 - "Pragma": "no-cache", 184 184 - "Expires": "0" 262 262 + "Cache-Control": "max-age=300", 263 263 + "ETag": `"${version}-verified-${Date.now()}"`, 185 264 }, 186 265 }, 187 266 ); ··· 206 285 }); 207 286 } 208 287 209 209 - // Get snapshots for the story 210 210 - const snapshots = await db.query.leaderboardSnapshots.findMany({ 211 211 - where: (snapshots, { eq }) => eq(snapshots.storyId, storyId), 212 212 - orderBy: (snapshots, { asc }) => [asc(snapshots.timestamp)], 213 213 - }); 214 214 - 215 215 - // Transform snapshot data for frontend 216 216 - const graphData = snapshots.map((snapshot) => ({ 217 217 - timestamp: snapshot.timestamp, 218 218 - position: snapshot.position, 219 219 - score: snapshot.score, 220 220 - date: new Date(snapshot.timestamp * 1000).toISOString(), 221 221 - })); 288 288 + // Get snapshots for the story using the cache 289 289 + const graphData = await queryCache.get( 290 290 + `story_snapshots_${storyId}`, 291 291 + async () => { 292 292 + // Get snapshots for the story 293 293 + const snapshots = await db.query.leaderboardSnapshots.findMany({ 294 294 + where: (snapshots, { eq }) => eq(snapshots.storyId, storyId), 295 295 + orderBy: (snapshots, { asc }) => [asc(snapshots.timestamp)], 296 296 + }); 297 297 + 298 298 + // Transform snapshot data for frontend 299 299 + return snapshots.map((snapshot) => ({ 300 300 + timestamp: snapshot.timestamp, 301 301 + position: snapshot.position, 302 302 + score: snapshot.score, 303 303 + date: new Date(snapshot.timestamp * 1000).toISOString(), 304 304 + })); 305 305 + }, 306 306 + 3600 // Cache story snapshots for 1 hour as they change less frequently 307 307 + ); 222 308 223 309 return new Response(JSON.stringify(graphData), { 224 310 headers: { 225 311 "Content-Type": "application/json", 226 226 - "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate", 227 227 - "Pragma": "no-cache", 228 228 - "Expires": "0" 312 312 + "Cache-Control": "max-age=3600", 313 313 + "ETag": `"${version}-snapshot-${storyId}-${Date.now()}"`, 229 314 }, 230 315 }); 231 316 } catch (error) { ··· 261 346 } milliseconds on version: ${version}@${commit}!\n\n----------------------------------\n`, 262 347 ); 263 348 264 264 - export { slackApp, slackClient, version, name, environment, db }; 349 349 + // Function to invalidate all caches - call this when data is updated 350 350 + function invalidateAllCaches() { 351 351 + console.log("Invalidating all query caches"); 352 352 + queryCache.invalidateAll(); 353 353 + } 354 354 + 355 355 + export { slackApp, slackClient, version, name, environment, db, queryCache, invalidateAllCaches };